@lobehub/chat 1.70.3 → 1.70.5

package/src/services/plugin/client.test.ts

@@ -3,7 +3,7 @@ import { eq } from 'drizzle-orm';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { clientDB, initializeDB } from '@/database/client/db';
-import { installedPlugins, users } from '@/database/schemas';
+import { userInstalledPlugins, users } from '@/database/schemas';
 import { LobeTool } from '@/types/tool';
 import { LobeToolCustomPlugin } from '@/types/tool/plugin';
 
@@ -40,8 +40,8 @@ describe('PluginService', () => {
       await pluginService.installPlugin(fakePlugin);
 
       // Assert
-      const result = await clientDB.query.installedPlugins.findFirst({
-        where: eq(installedPlugins.identifier, fakePlugin.identifier),
+      const result = await clientDB.query.userInstalledPlugins.findFirst({
+        where: eq(userInstalledPlugins.identifier, fakePlugin.identifier),
       });
       expect(result).toMatchObject(fakePlugin);
     });
@@ -52,7 +52,7 @@ describe('PluginService', () => {
       // Arrange
       const fakePlugins = [{ identifier: 'test-plugin', type: 'plugin' }] as LobeTool[];
       await clientDB
-        .insert(installedPlugins)
+        .insert(userInstalledPlugins)
         .values([{ identifier: 'test-plugin', type: 'plugin', userId }]);
       // Act
       const data = await pluginService.getInstalledPlugins();
@@ -66,14 +66,14 @@ describe('PluginService', () => {
     it('should uninstall a plugin', async () => {
       // Arrange
       const identifier = 'test-plugin';
-      await clientDB.insert(installedPlugins).values([{ identifier, type: 'plugin', userId }]);
+      await clientDB.insert(userInstalledPlugins).values([{ identifier, type: 'plugin', userId }]);
 
       // Act
       await pluginService.uninstallPlugin(identifier);
 
       // Assert
-      const result = await clientDB.query.installedPlugins.findFirst({
-        where: eq(installedPlugins.identifier, identifier),
+      const result = await clientDB.query.userInstalledPlugins.findFirst({
+        where: eq(userInstalledPlugins.identifier, identifier),
       });
       expect(result).toBe(undefined);
     });
@@ -92,8 +92,8 @@ describe('PluginService', () => {
       await pluginService.createCustomPlugin(customPlugin);
 
       // Assert
-      const result = await clientDB.query.installedPlugins.findFirst({
-        where: eq(installedPlugins.identifier, customPlugin.identifier),
+      const result = await clientDB.query.userInstalledPlugins.findFirst({
+        where: eq(userInstalledPlugins.identifier, customPlugin.identifier),
       });
       expect(result).toMatchObject(customPlugin);
     });
@@ -104,14 +104,14 @@ describe('PluginService', () => {
       // Arrange
       const identifier = 'plugin-id';
       const value = { customParams: { ab: '1' } } as unknown as LobeToolCustomPlugin;
-      await clientDB.insert(installedPlugins).values([{ identifier, type: 'plugin', userId }]);
+      await clientDB.insert(userInstalledPlugins).values([{ identifier, type: 'plugin', userId }]);
 
       // Act
       await pluginService.updatePlugin(identifier, value);
 
       // Assert
-      const result = await clientDB.query.installedPlugins.findFirst({
-        where: eq(installedPlugins.identifier, identifier),
+      const result = await clientDB.query.userInstalledPlugins.findFirst({
+        where: eq(userInstalledPlugins.identifier, identifier),
       });
       expect(result).toMatchObject(value);
     });
@@ -122,14 +122,14 @@ describe('PluginService', () => {
       // Arrange
       const identifier = 'plugin-id';
       const manifest = { name: 'NewPluginManifest' } as unknown as LobeChatPluginManifest;
-      await clientDB.insert(installedPlugins).values([{ identifier, type: 'plugin', userId }]);
+      await clientDB.insert(userInstalledPlugins).values([{ identifier, type: 'plugin', userId }]);
 
       // Act
       await pluginService.updatePluginManifest(identifier, manifest);
 
       // Assert
-      const result = await clientDB.query.installedPlugins.findFirst({
-        where: eq(installedPlugins.identifier, identifier),
+      const result = await clientDB.query.userInstalledPlugins.findFirst({
+        where: eq(userInstalledPlugins.identifier, identifier),
       });
       expect(result).toMatchObject({ manifest });
     });
@@ -138,7 +138,7 @@ describe('PluginService', () => {
   describe('removeAllPlugins', () => {
     it('should remove all plugins', async () => {
       // Arrange
-      await clientDB.insert(installedPlugins).values([
+      await clientDB.insert(userInstalledPlugins).values([
         { identifier: '123', type: 'plugin', userId },
         { identifier: '234', type: 'plugin', userId },
       ]);
@@ -147,8 +147,8 @@ describe('PluginService', () => {
       await pluginService.removeAllPlugins();
 
       // Assert
-      const result = await clientDB.query.installedPlugins.findMany({
-        where: eq(installedPlugins.userId, userId),
+      const result = await clientDB.query.userInstalledPlugins.findMany({
+        where: eq(userInstalledPlugins.userId, userId),
       });
       expect(result.length).toEqual(0);
     });
@@ -159,14 +159,14 @@ describe('PluginService', () => {
       // Arrange
       const id = 'plugin-id';
       const settings = { color: 'blue' };
-      await clientDB.insert(installedPlugins).values([{ identifier: id, type: 'plugin', userId }]);
+      await clientDB.insert(userInstalledPlugins).values([{ identifier: id, type: 'plugin', userId }]);
 
       // Act
       await pluginService.updatePluginSettings(id, settings);
 
       // Assert
-      const result = await clientDB.query.installedPlugins.findFirst({
-        where: eq(installedPlugins.identifier, id),
+      const result = await clientDB.query.userInstalledPlugins.findFirst({
+        where: eq(userInstalledPlugins.identifier, id),
       });
 
       expect(result).toMatchObject({ settings });

package/src/services/user/_deprecated.test.ts

@@ -57,7 +57,7 @@ describe('ClientService', () => {
   });
 
   it('should update user settings correctly', async () => {
-    const settingsPatch: DeepPartial<UserSettings> = { general: { themeMode: 'dark' } };
+    const settingsPatch: DeepPartial<UserSettings> = { general: { fontSize: 12 } };
     (UserModel.updateSettings as Mock).mockResolvedValue(undefined);
 
     await clientService.updateUserSettings(settingsPatch);

package/src/services/user/client.test.ts

@@ -54,7 +54,7 @@ describe('ClientService', () => {
   });
 
   it('should update user settings correctly', async () => {
-    const settingsPatch: DeepPartial<UserSettings> = { general: { themeMode: 'dark' } };
+    const settingsPatch: DeepPartial<UserSettings> = { general: { fontSize: 12 } };
 
     await clientService.updateUserSettings(settingsPatch);
 

package/src/store/aiInfra/slices/aiProvider/__tests__/selectors.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, it } from 'vitest';
+
+import { aiProviderSelectors } from '../selectors';
+
+describe('aiProviderSelectors', () => {
+  const mockState: any = {
+    aiProviderList: [
+      { id: 'provider1', enabled: true, sort: 1 },
+      { id: 'provider2', enabled: false, sort: 2 },
+      { id: 'provider3', enabled: true, sort: 0 },
+    ],
+    aiProviderDetail: {
+      id: 'provider1',
+      keyVaults: {
+        baseURL: 'https://api.example.com',
+        apiKey: 'test-key',
+      },
+    },
+    aiProviderLoadingIds: ['loading-provider'],
+    aiProviderConfigUpdatingIds: ['updating-provider'],
+    activeAiProvider: 'provider1',
+    aiProviderRuntimeConfig: {
+      provider1: {
+        keyVaults: {
+          baseURL: 'https://api.example.com',
+          apiKey: 'test-key',
+        },
+        settings: {
+          searchMode: 'internal',
+        },
+        fetchOnClient: true,
+      },
+      provider2: {
+        keyVaults: {
+          baseURL: 'https://api2.example.com',
+        },
+        settings: {},
+      },
+      ollama: {
+        keyVaults: {},
+        settings: {},
+        fetchOnClient: true,
+      },
+    },
+    // Required by AIProviderStoreState
+    activeProviderModelList: [],
+    initAiProviderList: [],
+    providerSearchKeyword: '',
+    aiModelLoadingIds: [],
+    modelFetchingStatus: {},
+    modelRuntimeConfig: {},
+    modelSearchKeyword: '',
+  };
+
+  describe('enabledAiProviderList', () => {
+    it('should return enabled providers sorted by sort', () => {
+      const result = aiProviderSelectors.enabledAiProviderList(mockState);
+      expect(result).toEqual([
+        { id: 'provider3', enabled: true, sort: 0 },
+        { id: 'provider1', enabled: true, sort: 1 },
+      ]);
+    });
+  });
+
+  describe('disabledAiProviderList', () => {
+    it('should return disabled providers', () => {
+      const result = aiProviderSelectors.disabledAiProviderList(mockState);
+      expect(result).toEqual([{ id: 'provider2', enabled: false, sort: 2 }]);
+    });
+  });
+
+  describe('isProviderEnabled', () => {
+    it('should return true for enabled provider', () => {
+      expect(aiProviderSelectors.isProviderEnabled('provider1')(mockState)).toBe(true);
+    });
+
+    it('should return false for disabled provider', () => {
+      expect(aiProviderSelectors.isProviderEnabled('provider2')(mockState)).toBe(false);
+    });
+  });
+
+  describe('isProviderLoading', () => {
+    it('should return true for loading provider', () => {
+      expect(aiProviderSelectors.isProviderLoading('loading-provider')(mockState)).toBe(true);
+    });
+
+    it('should return false for non-loading provider', () => {
+      expect(aiProviderSelectors.isProviderLoading('provider1')(mockState)).toBe(false);
+    });
+  });
+
+  describe('activeProviderConfig', () => {
+    it('should return active provider config', () => {
+      expect(aiProviderSelectors.activeProviderConfig(mockState)).toEqual(
+        mockState.aiProviderDetail,
+      );
+    });
+  });
+
+  describe('isAiProviderConfigLoading', () => {
+    it('should return true if provider id does not match active provider', () => {
+      expect(aiProviderSelectors.isAiProviderConfigLoading('provider2')(mockState)).toBe(true);
+    });
+
+    it('should return false if provider id matches active provider', () => {
+      expect(aiProviderSelectors.isAiProviderConfigLoading('provider1')(mockState)).toBe(false);
+    });
+  });
+
+  describe('isActiveProviderEndpointNotEmpty', () => {
+    it('should return true when baseURL exists', () => {
+      expect(aiProviderSelectors.isActiveProviderEndpointNotEmpty(mockState)).toBe(true);
+    });
+
+    it('should return false when no endpoint info exists', () => {
+      const stateWithoutEndpoint = {
+        ...mockState,
+        aiProviderDetail: { keyVaults: {} },
+      };
+      expect(aiProviderSelectors.isActiveProviderEndpointNotEmpty(stateWithoutEndpoint)).toBe(
+        false,
+      );
+    });
+  });
+
+  describe('isActiveProviderApiKeyNotEmpty', () => {
+    it('should return true when apiKey exists', () => {
+      expect(aiProviderSelectors.isActiveProviderApiKeyNotEmpty(mockState)).toBe(true);
+    });
+
+    it('should return false when no api key exists', () => {
+      const stateWithoutApiKey = {
+        ...mockState,
+        aiProviderDetail: { keyVaults: {} },
+      };
+      expect(aiProviderSelectors.isActiveProviderApiKeyNotEmpty(stateWithoutApiKey)).toBe(false);
+    });
+  });
+
+  describe('providerConfigById', () => {
+    it('should return config for existing provider', () => {
+      expect(aiProviderSelectors.providerConfigById('provider1')(mockState)).toEqual(
+        mockState.aiProviderRuntimeConfig.provider1,
+      );
+    });
+
+    it('should return undefined for non-existing provider', () => {
+      expect(aiProviderSelectors.providerConfigById('non-existing')(mockState)).toBeUndefined();
+    });
+
+    it('should return undefined for empty id', () => {
+      expect(aiProviderSelectors.providerConfigById('')(mockState)).toBeUndefined();
+    });
+  });
+
+  describe('isProviderConfigUpdating', () => {
+    it('should return true for updating provider', () => {
+      expect(aiProviderSelectors.isProviderConfigUpdating('updating-provider')(mockState)).toBe(
+        true,
+      );
+    });
+
+    it('should return false for non-updating provider', () => {
+      expect(aiProviderSelectors.isProviderConfigUpdating('provider1')(mockState)).toBe(false);
+    });
+  });
+
+  describe('isProviderFetchOnClient', () => {
+    it('should return false if provider is in disable browser request list', () => {
+      expect(
+        aiProviderSelectors.isProviderFetchOnClient('provider-with-disabled-browser')(mockState),
+      ).toBe(false);
+    });
+
+    it('should follow user settings for whitelisted providers', () => {
+      expect(aiProviderSelectors.isProviderFetchOnClient('ollama')(mockState)).toBe(true);
+    });
+
+    it('should return false if no endpoint and api key', () => {
+      const state = {
+        ...mockState,
+        aiProviderRuntimeConfig: {
+          test: {
+            keyVaults: {},
+            settings: {},
+          },
+        },
+      };
+      expect(aiProviderSelectors.isProviderFetchOnClient('test')(state)).toBe(false);
+    });
+
+    it('should return true if only baseURL exists', () => {
+      const state = {
+        ...mockState,
+        aiProviderRuntimeConfig: {
+          test: {
+            keyVaults: { baseURL: 'http://test.com' },
+            settings: {},
+          },
+        },
+      };
+      expect(aiProviderSelectors.isProviderFetchOnClient('test')(state)).toBe(true);
+    });
+
+    it('should follow user settings if both endpoint and api key exist', () => {
+      expect(aiProviderSelectors.isProviderFetchOnClient('provider1')(mockState)).toBe(true);
+    });
+  });
+
+  describe('providerKeyVaults', () => {
+    it('should return key vaults for existing provider', () => {
+      expect(aiProviderSelectors.providerKeyVaults('provider1')(mockState)).toEqual(
+        mockState.aiProviderRuntimeConfig.provider1.keyVaults,
+      );
+    });
+
+    it('should return undefined for undefined provider', () => {
+      expect(aiProviderSelectors.providerKeyVaults(undefined)(mockState)).toBeUndefined();
+    });
+
+    it('should return undefined for non-existing provider', () => {
+      expect(aiProviderSelectors.providerKeyVaults('non-existing')(mockState)).toBeUndefined();
+    });
+  });
+
+  describe('isProviderHasBuiltinSearch', () => {
+    it('should return true if provider has search mode', () => {
+      expect(aiProviderSelectors.isProviderHasBuiltinSearch('provider1')(mockState)).toBe(true);
+    });
+
+    it('should return false if provider has no search mode', () => {
+      expect(aiProviderSelectors.isProviderHasBuiltinSearch('provider2')(mockState)).toBe(false);
+    });
+  });
+
+  describe('isProviderHasBuiltinSearchConfig', () => {
+    it('should return false if search mode is internal', () => {
+      expect(aiProviderSelectors.isProviderHasBuiltinSearchConfig('provider1')(mockState)).toBe(
+        false,
+      );
+    });
+
+    it('should return false if no search mode exists', () => {
+      expect(aiProviderSelectors.isProviderHasBuiltinSearchConfig('provider2')(mockState)).toBe(
+        false,
+      );
+    });
+  });
+});

package/src/store/global/action.test.ts

@@ -408,4 +408,19 @@ describe('createPreferenceSlice', () => {
       expect(result.current.status.inputHeight).toEqual(300);
     });
   });
+
+  describe('switchThemeMode', () => {
+    it('should switch theme mode', async () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      // Perform the action
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.switchThemeMode('light');
+      });
+
+      // Assert that updateUserSettings was called with the correct theme mode
+      expect(result.current.status.themeMode).toEqual('light');
+    });
+  });
 });

package/src/store/global/actions/__tests__/general.test.ts

@@ -0,0 +1,221 @@
+import { act, renderHook } from '@testing-library/react';
+import { ThemeMode } from 'antd-style';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { withSWR } from '~test-utils';
+
+import { CURRENT_VERSION } from '@/const/version';
+import { globalService } from '@/services/global';
+import { useGlobalStore } from '@/store/global';
+import { initialState } from '@/store/global/initialState';
+import { switchLang } from '@/utils/client/switchLang';
+
+vi.mock('@/utils/client/switchLang', () => ({
+  switchLang: vi.fn(),
+}));
+
+vi.mock('@/services/global', () => ({
+  globalService: {
+    getLatestVersion: vi.fn(),
+  },
+}));
+
+describe('generalActionSlice', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    useGlobalStore.setState(initialState);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('updateSystemStatus', () => {
+    it('should not update status when not initialized', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        result.current.updateSystemStatus({ inputHeight: 200 });
+      });
+
+      expect(result.current.status).toEqual(initialState.status);
+    });
+
+    it('should update status when initialized', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.updateSystemStatus({ inputHeight: 200 });
+      });
+
+      expect(result.current.status.inputHeight).toBe(200);
+    });
+
+    it('should not update if new status equals current status', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const saveToLocalStorageSpy = vi.spyOn(result.current.statusStorage, 'saveToLocalStorage');
+
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.updateSystemStatus({ inputHeight: initialState.status.inputHeight });
+      });
+
+      expect(saveToLocalStorageSpy).not.toHaveBeenCalled();
+    });
+
+    it('should save to localStorage when status is updated', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const saveToLocalStorageSpy = vi.spyOn(result.current.statusStorage, 'saveToLocalStorage');
+
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.updateSystemStatus({ inputHeight: 300 });
+      });
+
+      expect(saveToLocalStorageSpy).toHaveBeenCalledWith(
+        expect.objectContaining({ inputHeight: 300 }),
+      );
+    });
+
+    it('should merge nested objects correctly', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.updateSystemStatus({
+          expandSessionGroupKeys: ['test1', 'test2'],
+        });
+      });
+
+      expect(result.current.status.expandSessionGroupKeys).toEqual(['test1', 'test2']);
+    });
+  });
+
+  describe('switchLocale', () => {
+    it('should update language in system status and call switchLang', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const locale = 'zh-CN';
+
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.switchLocale(locale);
+      });
+
+      expect(result.current.status.language).toBe(locale);
+      expect(switchLang).toHaveBeenCalledWith(locale);
+    });
+
+    it('should not update language if status is not initialized', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const locale = 'zh-CN';
+
+      act(() => {
+        result.current.switchLocale(locale);
+      });
+
+      expect(result.current.status.language).toBeUndefined();
+    });
+  });
+
+  describe('switchThemeMode', () => {
+    it('should update theme mode in system status', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const themeMode: ThemeMode = 'dark';
+
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.switchThemeMode(themeMode);
+      });
+
+      expect(result.current.status.themeMode).toBe(themeMode);
+    });
+
+    it('should not update theme mode if status is not initialized', () => {
+      const { result } = renderHook(() => useGlobalStore());
+      const themeMode: ThemeMode = 'dark';
+
+      act(() => {
+        result.current.switchThemeMode(themeMode);
+      });
+
+      expect(result.current.status.themeMode).toBe(initialState.status.themeMode);
+    });
+
+    it('should handle light theme mode', () => {
+      const { result } = renderHook(() => useGlobalStore());
+
+      act(() => {
+        useGlobalStore.setState({ isStatusInit: true });
+        result.current.switchThemeMode('light');
+      });
+
+      expect(result.current.status.themeMode).toBe('light');
+    });
+  });
+
+  describe('useCheckLatestVersion', () => {
+    it('should not fetch version when check is disabled', () => {
+      const getLatestVersionSpy = vi.spyOn(globalService, 'getLatestVersion');
+
+      renderHook(() => useGlobalStore().useCheckLatestVersion(false), {
+        wrapper: withSWR,
+      });
+
+      expect(getLatestVersionSpy).not.toHaveBeenCalled();
+    });
+
+    it('should set hasNewVersion when major version is newer', async () => {
+      const latestVersion = '999.0.0';
+      vi.spyOn(globalService, 'getLatestVersion').mockResolvedValueOnce(latestVersion);
+
+      const { result } = renderHook(() => useGlobalStore().useCheckLatestVersion(), {
+        wrapper: withSWR,
+      });
+
+      await act(async () => {
+        await result.current.data;
+      });
+
+      expect(useGlobalStore.getState().hasNewVersion).toBe(true);
+      expect(useGlobalStore.getState().latestVersion).toBe(latestVersion);
+    });
+
+    it('should not set hasNewVersion for same major.minor version', async () => {
+      const currentParts = CURRENT_VERSION.split('.');
+      const latestVersion = `${currentParts[0]}.${currentParts[1]}.999`;
+      vi.spyOn(globalService, 'getLatestVersion').mockResolvedValueOnce(latestVersion);
+
+      const { result } = renderHook(() => useGlobalStore().useCheckLatestVersion(), {
+        wrapper: withSWR,
+      });
+
+      await act(async () => {
+        await result.current.data;
+      });
+
+      // Reset hasNewVersion and latestVersion
+      useGlobalStore.setState({ hasNewVersion: undefined, latestVersion: undefined });
+
+      expect(useGlobalStore.getState().hasNewVersion).toBeUndefined();
+      expect(useGlobalStore.getState().latestVersion).toBeUndefined();
+    });
+
+    it('should not set hasNewVersion when version is invalid', async () => {
+      vi.spyOn(globalService, 'getLatestVersion').mockResolvedValueOnce('invalid.version');
+
+      const { result } = renderHook(() => useGlobalStore().useCheckLatestVersion(), {
+        wrapper: withSWR,
+      });
+
+      await act(async () => {
+        await result.current.data;
+      });
+
+      // Reset hasNewVersion and latestVersion
+      useGlobalStore.setState({ hasNewVersion: undefined, latestVersion: undefined });
+
+      expect(useGlobalStore.getState().hasNewVersion).toBeUndefined();
+      expect(useGlobalStore.getState().latestVersion).toBeUndefined();
+    });
+  });
+});

package/src/store/global/actions/general.ts

@@ -1,13 +1,16 @@
+import { ThemeMode } from 'antd-style';
 import isEqual from 'fast-deep-equal';
 import { gt, parse, valid } from 'semver';
 import { SWRResponse } from 'swr';
 import type { StateCreator } from 'zustand/vanilla';
 
+import { LOBE_THEME_APPEARANCE } from '@/const/theme';
 import { CURRENT_VERSION } from '@/const/version';
 import { useOnlyFetchOnceSWR } from '@/libs/swr';
 import { globalService } from '@/services/global';
 import type { SystemStatus } from '@/store/global/initialState';
 import { LocaleMode } from '@/types/locale';
+import { setCookie } from '@/utils/client/cookie';
 import { switchLang } from '@/utils/client/switchLang';
 import { merge } from '@/utils/merge';
 import { setNamespace } from '@/utils/storeDebug';
@@ -18,6 +21,7 @@ const n = setNamespace('g');
 
 export interface GlobalGeneralAction {
   switchLocale: (locale: LocaleMode) => void;
+  switchThemeMode: (themeMode: ThemeMode) => void;
   updateSystemStatus: (status: Partial<SystemStatus>, action?: any) => void;
   useCheckLatestVersion: (enabledCheck?: boolean) => SWRResponse<string>;
   useInitSystemStatus: () => SWRResponse;
@@ -34,15 +38,20 @@ export const generalActionSlice: StateCreator<
 
     switchLang(locale);
   },
+  switchThemeMode: (themeMode) => {
+    get().updateSystemStatus({ themeMode });
+
+    setCookie(LOBE_THEME_APPEARANCE, themeMode === 'auto' ? undefined : themeMode);
+  },
   updateSystemStatus: (status, action) => {
     // Status cannot be modified when it is not initialized
     if (!get().isStatusInit) return;
 
     const nextStatus = merge(get().status, status);
+
     if (isEqual(get().status, nextStatus)) return;
 
     set({ status: nextStatus }, false, action || n('updateSystemStatus'));
-
     get().statusStorage.saveToLocalStorage(nextStatus);
   },