@lobehub/chat 1.82.10 → 1.83.0

package/src/libs/trpc/client/lambda.ts

@@ -2,6 +2,7 @@ import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import { createTRPCReact } from '@trpc/react-query';
 import superjson from 'superjson';
 
+import { isDesktop } from '@/const/version';
 import { ModelProvider } from '@/libs/agent-runtime';
 import type { LambdaRouter } from '@/server/routers/lambda';
 
@@ -10,7 +11,16 @@ import { ErrorResponse } from './types';
 const links = [
   httpBatchLink({
     fetch: async (input, init) => {
+      if (isDesktop) {
+        const { desktopRemoteRPCFetch } = await import('./helpers/desktopRemoteRPCFetch');
+
+        const res = await desktopRemoteRPCFetch(input as string, init);
+
+        if (res) return res;
+      }
+
       const response = await fetch(input, init);
+
       if (response.ok) return response;
 
       const errorRes: ErrorResponse = await response.clone().json();
@@ -20,7 +30,6 @@ const links = [
 
       errorRes.forEach((item) => {
         const errorData = item.error.json;
-
         const status = errorData.data.httpStatus;
 
         switch (status) {

package/src/libs/trpc/client/tools.ts

@@ -1,11 +1,17 @@
 import { createTRPCClient, httpBatchLink } from '@trpc/client';
 import superjson from 'superjson';
 
+import { isDesktop } from '@/const/version';
 import type { ToolsRouter } from '@/server/routers/tools';
 
+import { fetchWithDesktopRemoteRPC } from './helpers/desktopRemoteRPCFetch';
+
 export const toolsClient = createTRPCClient<ToolsRouter>({
   links: [
     httpBatchLink({
+      fetch: isDesktop
+        ? (input, init) => fetchWithDesktopRemoteRPC(input as string, init)
+        : undefined,
       headers: async () => {
         // dynamic import to avoid circular dependency
         const { createHeaderWithAuth } = await import('@/services/_auth');

package/src/server/globalConfig/index.ts

@@ -40,9 +40,6 @@ export const getServerGlobalConfig = async () => {
         enabled: isDesktop ? true : undefined,
         fetchOnClient: isDesktop ? false : !process.env.OLLAMA_PROXY_URL,
       },
-      openai: {
-        enabled: isDesktop ? false : undefined,
-      },
       tencentcloud: {
         enabledKey: 'ENABLED_TENCENT_CLOUD',
         modelListKey: 'TENCENT_CLOUD_MODEL_LIST',

package/src/server/modules/ElectronIPCClient/index.ts

@@ -1,5 +1,7 @@
 import { ElectronIpcClient } from '@lobechat/electron-server-ipc';
 
+import packageJSON from '@/../apps/desktop/package.json';
+
 class LobeHubElectronIpcClient extends ElectronIpcClient {
   // 获取数据库路径
   getDatabasePath = async (): Promise<string> => {
@@ -33,4 +35,4 @@ class LobeHubElectronIpcClient extends ElectronIpcClient {
   };
 }
 
-export const electronIpcClient = new LobeHubElectronIpcClient();
+export const electronIpcClient = new LobeHubElectronIpcClient(packageJSON.name);

package/src/server/routers/desktop/index.ts

@@ -1,8 +1,10 @@
 import { router } from '@/libs/trpc/lambda';
+import { mcpRouter } from '@/server/routers/desktop/mcp';
 
 import { pgTableRouter } from './pgTable';
 
 export const desktopRouter = router({
+  mcp: mcpRouter,
   pgTable: pgTableRouter,
 });
 

package/src/server/routers/desktop/mcp.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+
+import { isServerMode } from '@/const/version';
+import { passwordProcedure } from '@/libs/trpc/edge';
+import { authedProcedure, router } from '@/libs/trpc/lambda';
+import { mcpService } from '@/server/services/mcp';
+
+const stdioParamsSchema = z.object({
+  args: z.array(z.string()).optional().default([]),
+  command: z.string().min(1),
+  name: z.string().min(1),
+  type: z.literal('stdio').default('stdio'),
+});
+
+const mcpProcedure = isServerMode ? authedProcedure : passwordProcedure;
+
+export const mcpRouter = router({
+  getStdioMcpServerManifest: mcpProcedure.input(stdioParamsSchema).query(async ({ input }) => {
+    return await mcpService.getStdioMcpServerManifest(input.name, input.command, input.args);
+  }),
+
+  /* eslint-disable sort-keys-fix/sort-keys-fix */
+  // --- MCP Interaction ---
+  // listTools now accepts MCPClientParams directly
+  listTools: mcpProcedure
+    .input(stdioParamsSchema) // Use the unified schema
+    .query(async ({ input }) => {
+      // Pass the validated MCPClientParams to the service
+      return await mcpService.listTools(input);
+    }),
+
+  // callTool now accepts MCPClientParams, toolName, and args
+  callTool: mcpProcedure
+    .input(
+      z.object({
+        params: stdioParamsSchema, // Use the unified schema for client params
+        args: z.any(), // Arguments for the tool call
+        toolName: z.string(),
+      }),
+    )
+    .mutation(async ({ input }) => {
+      // Pass the validated params, toolName, and args to the service
+      const data = await mcpService.callTool(input.params, input.toolName, input.args);
+
+      return JSON.stringify(data);
+    }),
+});

package/src/server/routers/lambda/user.ts

@@ -3,10 +3,12 @@ import { z } from 'zod';
 import { v4 as uuidv4 } from 'uuid'; // 需要添加此导入
 
 import { enableClerk } from '@/const/auth';
+import { isDesktop } from '@/const/version';
 import { MessageModel } from '@/database/models/message';
 import { SessionModel } from '@/database/models/session';
 import { UserModel, UserNotFoundError } from '@/database/models/user';
 import { ClerkAuth } from '@/libs/clerk-auth';
+import { pino } from '@/libs/logger';
 import { LobeNextAuthDbAdapter } from '@/libs/next-auth/adapter';
 import { authedProcedure, router } from '@/libs/trpc/lambda';
 import { serverDatabase } from '@/libs/trpc/lambda/middleware';
@@ -50,33 +52,46 @@ export const userRouter = router({
       try {
         state = await ctx.userModel.getUserState(KeyVaultsGateKeeper.getUserKeyVaults);
       } catch (error) {
-        if (enableClerk && error instanceof UserNotFoundError) {
-          const user = await ctx.clerkAuth.getCurrentUser();
-          if (user) {
-            const userService = new UserService();
-
-            await userService.createUser(user.id, {
-              created_at: user.createdAt,
-              email_addresses: user.emailAddresses.map((e) => ({
-                email_address: e.emailAddress,
-                id: e.id,
-              })),
-              first_name: user.firstName,
-              id: user.id,
-              image_url: user.imageUrl,
-              last_name: user.lastName,
-              phone_numbers: user.phoneNumbers.map((e) => ({
-                id: e.id,
-                phone_number: e.phoneNumber,
-              })),
-              primary_email_address_id: user.primaryEmailAddressId,
-              primary_phone_number_id: user.primaryPhoneNumberId,
-              username: user.username,
-            } as UserJSON);
+        // user not create yet
+        if (error instanceof UserNotFoundError) {
+          // if in clerk auth mode
+          if (enableClerk) {
+            const user = await ctx.clerkAuth.getCurrentUser();
+            if (user) {
+              const userService = new UserService();
+
+              await userService.createUser(user.id, {
+                created_at: user.createdAt,
+                email_addresses: user.emailAddresses.map((e) => ({
+                  email_address: e.emailAddress,
+                  id: e.id,
+                })),
+                first_name: user.firstName,
+                id: user.id,
+                image_url: user.imageUrl,
+                last_name: user.lastName,
+                phone_numbers: user.phoneNumbers.map((e) => ({
+                  id: e.id,
+                  phone_number: e.phoneNumber,
+                })),
+                primary_email_address_id: user.primaryEmailAddressId,
+                primary_phone_number_id: user.primaryPhoneNumberId,
+                username: user.username,
+              } as UserJSON);
+
+              continue;
+            }
+          }
 
+          // if in desktop mode, make sure desktop user exist
+          else if (isDesktop) {
+            await UserModel.makeSureUserExist(ctx.serverDB, ctx.userId);
+            pino.info('create desktop user');
             continue;
           }
         }
+
+        console.error('getUserState:', error);
         throw error;
       }
     }

package/src/server/routers/tools/mcp.ts

@@ -35,12 +35,6 @@ const checkStdioEnvironment = (params: z.infer<typeof mcpClientParamsSchema>) =>
 const mcpProcedure = isServerMode ? authedProcedure : passwordProcedure;
 
 export const mcpRouter = router({
-  getStdioMcpServerManifest: mcpProcedure.input(stdioParamsSchema).query(async ({ input }) => {
-    // Stdio check can be done here or rely on the service/client layer
-    checkStdioEnvironment(input);
-
-    return await mcpService.getStdioMcpServerManifest(input.name, input.command, input.args);
-  }),
   getStreamableMcpServerManifest: mcpProcedure
     .input(
       z.object({

package/src/services/electron/remoteServer.ts

@@ -1,4 +1,4 @@
-import { RemoteServerConfig, dispatch } from '@lobechat/electron-client-ipc';
+import { DataSyncConfig, dispatch } from '@lobechat/electron-client-ipc';
 
 class RemoteServerService {
   /**
@@ -11,7 +11,7 @@ class RemoteServerService {
   /**
    * 设置远程服务器配置
    */
-  setRemoteServerConfig = async (config: RemoteServerConfig) => {
+  setRemoteServerConfig = async (config: DataSyncConfig) => {
     return dispatch('setRemoteServerConfig', config);
   };
 
@@ -25,8 +25,8 @@ class RemoteServerService {
   /**
    * 请求授权
    */
-  requestAuthorization = async (serverUrl: string) => {
-    return dispatch('requestAuthorization', serverUrl);
+  requestAuthorization = async (config: DataSyncConfig) => {
+    return dispatch('requestAuthorization', config);
   };
 
   /**

package/src/services/mcp.ts

@@ -1,4 +1,5 @@
-import { toolsClient } from '@/libs/trpc/client';
+import { isDesktop } from '@/const/version';
+import { desktopClient, toolsClient } from '@/libs/trpc/client';
 import { ChatToolPayload } from '@/types/message';
 
 class MCPService {
@@ -13,10 +14,20 @@ class MCPService {
 
     if (!plugin) return;
 
-    return toolsClient.mcp.callTool.mutate(
-      { args, params: { ...plugin.customParams?.mcp, name: identifier } as any, toolName: apiName },
-      { signal },
-    );
+    const data = {
+      args,
+      params: { ...plugin.customParams?.mcp, name: identifier } as any,
+      toolName: apiName,
+    };
+
+    const isStdio = plugin?.customParams?.mcp?.type === 'stdio';
+
+    // For desktop and stdio, use the desktopClient
+    if (isDesktop && isStdio) {
+      return desktopClient.mcp.callTool.mutate(data, { signal });
+    }
+
+    return toolsClient.mcp.callTool.mutate(data, { signal });
   }
 
   async getStreamableMcpServerManifest(identifier: string, url: string) {
@@ -24,11 +35,10 @@ class MCPService {
   }
 
   async getStdioMcpServerManifest(identifier: string, command: string, args?: string[]) {
-    return toolsClient.mcp.getStdioMcpServerManifest.query({
+    return desktopClient.mcp.getStdioMcpServerManifest.query({
       args: args,
       command,
       name: identifier,
-      type: 'stdio',
     });
   }
 }

package/src/services/upload.ts

@@ -148,6 +148,15 @@ class UploadService {
     return result;
   };
 
+  uploadToDesktop = async (file: File) => {
+    const fileArrayBuffer = await file.arrayBuffer();
+    const hash = sha256(fileArrayBuffer);
+
+    const { desktopFileAPI } = await import('@/services/electron/file');
+    const { metadata } = await desktopFileAPI.uploadFile(file, hash);
+    return metadata;
+  };
+
   uploadToClientS3 = async (hash: string, file: File): Promise<FileMetadata> => {
     await clientS3Storage.putObject(hash, file);
 

package/src/store/chat/slices/aiChat/actions/generateAIChat.ts

@@ -602,13 +602,22 @@ export const generateAIChat: StateCreator<
           }
         }
 
-        if (toolCalls && toolCalls.length > 0) {
+        let parsedToolCalls = toolCalls;
+        if (parsedToolCalls && parsedToolCalls.length > 0) {
           internal_toggleToolCallingStreaming(messageId, undefined);
+          parsedToolCalls = parsedToolCalls.map((item) => ({
+            ...item,
+            function: {
+              ...item.function,
+              arguments: !!item.function.arguments ? item.function.arguments : '{}',
+            },
+          }));
+          isFunctionCall = true;
         }
 
         // update the content after fetch result
         await internal_updateMessageContent(messageId, content, {
-          toolCalls,
+          toolCalls: parsedToolCalls,
           reasoning: !!reasoning ? { ...reasoning, duration } : undefined,
           search: !!grounding?.citations ? grounding : undefined,
           imageList: finalImages.length > 0 ? finalImages : undefined,

package/src/store/chat/slices/builtinTool/actions/localFile.ts

@@ -1,8 +1,11 @@
 import {
   ListLocalFileParams,
+  LocalMoveFilesResultItem,
   LocalReadFileParams,
   LocalReadFilesParams,
   LocalSearchFilesParams,
+  MoveLocalFilesParams,
+  RenameLocalFileParams,
 } from '@lobechat/electron-client-ipc';
 import { StateCreator } from 'zustand/vanilla';
 
@@ -11,16 +14,27 @@ import { ChatStore } from '@/store/chat/store';
 import {
   LocalFileListState,
   LocalFileSearchState,
+  LocalMoveFilesState,
   LocalReadFileState,
   LocalReadFilesState,
+  LocalRenameFileState,
 } from '@/tools/local-files/type';
 
 export interface LocalFileAction {
+  internal_triggerLocalFileToolCalling: <T = any>(
+    id: string,
+    callingService: () => Promise<{ content: any; state: T }>,
+  ) => Promise<boolean>;
+
   listLocalFiles: (id: string, params: ListLocalFileParams) => Promise<boolean>;
+  moveLocalFiles: (id: string, params: MoveLocalFilesParams) => Promise<boolean>;
   reSearchLocalFiles: (id: string, params: LocalSearchFilesParams) => Promise<boolean>;
   readLocalFile: (id: string, params: LocalReadFileParams) => Promise<boolean>;
   readLocalFiles: (id: string, params: LocalReadFilesParams) => Promise<boolean>;
+  renameLocalFile: (id: string, params: RenameLocalFileParams) => Promise<boolean>;
+  // Added rename action
   searchLocalFiles: (id: string, params: LocalSearchFilesParams) => Promise<boolean>;
+
   toggleLocalFileLoading: (id: string, loading: boolean) => void;
 }
 
@@ -30,15 +44,13 @@ export const localFileSlice: StateCreator<
   [],
   LocalFileAction
 > = (set, get) => ({
-  listLocalFiles: async (id, params) => {
+  internal_triggerLocalFileToolCalling: async (id, callingService) => {
     get().toggleLocalFileLoading(id, true);
     try {
-      const data = await localFileService.listLocalFiles(params);
-      console.log(data);
-      await get().updatePluginState(id, { listResults: data } as LocalFileListState);
-      await get().internal_updateMessageContent(id, JSON.stringify(data));
+      const { state, content } = await callingService();
+      await get().updatePluginState(id, state as any);
+      await get().internal_updateMessageContent(id, JSON.stringify(content));
     } catch (error) {
-      console.error('Error listing local files:', error);
       await get().internal_updateMessagePluginError(id, {
         body: error,
         message: (error as Error).message,
@@ -50,6 +62,41 @@ export const localFileSlice: StateCreator<
     return true;
   },
 
+  listLocalFiles: async (id, params) => {
+    return get().internal_triggerLocalFileToolCalling<LocalFileListState>(id, async () => {
+      const result = await localFileService.listLocalFiles(params);
+      const state: LocalFileListState = { listResults: result };
+      return { content: result, state };
+    });
+  },
+
+  moveLocalFiles: async (id, params) => {
+    return get().internal_triggerLocalFileToolCalling<LocalMoveFilesState>(id, async () => {
+      const results: LocalMoveFilesResultItem[] = await localFileService.moveLocalFiles(params);
+
+      // 检查所有文件是否成功移动以更新消息内容
+      const allSucceeded = results.every((r) => r.success);
+      const someFailed = results.some((r) => !r.success);
+      const successCount = results.filter((r) => r.success).length;
+      const failedCount = results.length - successCount;
+
+      let message = '';
+
+      if (allSucceeded) {
+        message = `Successfully moved ${results.length} item(s).`;
+      } else if (someFailed) {
+        message = `Moved ${successCount} item(s) successfully. Failed to move ${failedCount} item(s).`;
+      } else {
+        // 所有都失败了？
+        message = `Failed to move all ${results.length} item(s).`;
+      }
+
+      const state: LocalMoveFilesState = { results, successCount, totalCount: results.length };
+
+      return { content: { message, results }, state };
+    });
+  },
+
   reSearchLocalFiles: async (id, params) => {
     get().toggleLocalFileLoading(id, true);
 
@@ -59,63 +106,73 @@ export const localFileSlice: StateCreator<
   },
 
   readLocalFile: async (id, params) => {
-    get().toggleLocalFileLoading(id, true);
-
-    try {
+    return get().internal_triggerLocalFileToolCalling<LocalReadFileState>(id, async () => {
       const result = await localFileService.readLocalFile(params);
-
-      await get().updatePluginState(id, { fileContent: result } as LocalReadFileState);
-      await get().internal_updateMessageContent(id, JSON.stringify(result));
-    } catch (error) {
-      console.error('Error reading local file:', error);
-      await get().internal_updateMessagePluginError(id, {
-        body: error,
-        message: (error as Error).message,
-        type: 'PluginServerError',
-      });
-    }
-    get().toggleLocalFileLoading(id, false);
-    return true;
+      const state: LocalReadFileState = { fileContent: result };
+      return { content: result, state };
+    });
   },
 
   readLocalFiles: async (id, params) => {
-    get().toggleLocalFileLoading(id, true);
-
-    try {
+    return get().internal_triggerLocalFileToolCalling<LocalReadFilesState>(id, async () => {
       const results = await localFileService.readLocalFiles(params);
-      await get().updatePluginState(id, { filesContent: results } as LocalReadFilesState);
-      await get().internal_updateMessageContent(id, JSON.stringify(results));
-    } catch (error) {
-      console.error('Error reading local files:', error);
-      await get().internal_updateMessagePluginError(id, {
-        body: error,
-        message: (error as Error).message,
-        type: 'PluginServerError',
-      });
-    }
-    get().toggleLocalFileLoading(id, false);
+      const state: LocalReadFilesState = { filesContent: results };
+      return { content: results, state };
+    });
+  },
 
-    return true;
+  renameLocalFile: async (id, params) => {
+    return get().internal_triggerLocalFileToolCalling<LocalRenameFileState>(id, async () => {
+      const { path: currentPath, newName } = params;
+
+      // Basic validation for newName (can be done here or backend, maybe better in backend)
+      if (
+        !newName ||
+        newName.includes('/') ||
+        newName.includes('\\') ||
+        newName === '.' ||
+        newName === '..' ||
+        /["*/:<>?\\|]/.test(newName)
+      ) {
+        throw new Error(
+          'Invalid new name provided. It cannot be empty, contain path separators, or invalid characters.',
+        );
+      }
+
+      const result = await localFileService.renameLocalFile({ newName, path: currentPath }); // Call the specific service
+
+      let state: LocalRenameFileState;
+      let content: { message: string; success: boolean };
+
+      if (result.success) {
+        state = { newPath: result.newPath!, oldPath: currentPath, success: true };
+        // Simplified message
+        content = {
+          message: `Successfully renamed file ${currentPath} to ${newName}.`,
+          success: true,
+        };
+      } else {
+        const errorMessage = result.error;
+        state = {
+          error: errorMessage,
+          newPath: '',
+          oldPath: params.path,
+          success: false,
+        };
+        content = { message: errorMessage, success: false };
+      }
+      return { content, state };
+    });
   },
 
   searchLocalFiles: async (id, params) => {
-    get().toggleLocalFileLoading(id, true);
-    try {
-      const data = await localFileService.searchLocalFiles(params);
-      await get().updatePluginState(id, { searchResults: data } as LocalFileSearchState);
-      await get().internal_updateMessageContent(id, JSON.stringify(data));
-    } catch (error) {
-      console.error('Error searching local files:', error);
-      await get().internal_updateMessagePluginError(id, {
-        body: error,
-        message: (error as Error).message,
-        type: 'PluginServerError',
-      });
-    }
-    get().toggleLocalFileLoading(id, false);
-
-    return true;
+    return get().internal_triggerLocalFileToolCalling<LocalFileSearchState>(id, async () => {
+      const result = await localFileService.searchLocalFiles(params);
+      const state: LocalFileSearchState = { searchResults: result };
+      return { content: result, state };
+    });
   },
+
   toggleLocalFileLoading: (id, loading) => {
     // Assuming a loading state structure similar to searchLoading
     set(

package/src/store/electron/actions/sync.ts

@@ -1,8 +1,8 @@
-import { RemoteServerConfig } from '@lobechat/electron-client-ipc';
+import { DataSyncConfig } from '@lobechat/electron-client-ipc';
+import isEqual from 'fast-deep-equal';
 import useSWR, { SWRResponse, mutate } from 'swr';
 import type { StateCreator } from 'zustand/vanilla';
 
-import { INBOX_SESSION_ID } from '@/const/session';
 import { remoteServerService } from '@/services/electron/remoteServer';
 
 import { initialState } from '../initialState';
@@ -12,11 +12,12 @@ import type { ElectronStore } from '../store';
  * 设置操作
  */
 export interface ElectronRemoteServerAction {
-  connectRemoteServer: (params: { isSelfHosted: boolean; serverUrl?: string }) => Promise<void>;
+  connectRemoteServer: (params: DataSyncConfig) => Promise<void>;
   disconnectRemoteServer: () => Promise<void>;
   refreshServerConfig: () => Promise<void>;
   refreshUserData: () => Promise<void>;
-  useRemoteServerConfig: () => SWRResponse;
+  useDataSyncConfig: () => SWRResponse;
+  useRefreshDataWhenActive: (active?: boolean) => SWRResponse;
 }
 
 const REMOTE_SERVER_CONFIG_KEY = 'electron:getRemoteServerConfig';
@@ -28,7 +29,7 @@ export const remoteSyncSlice: StateCreator<
   ElectronRemoteServerAction
 > = (set, get) => ({
   connectRemoteServer: async (values) => {
-    if (!values.serverUrl) return;
+    if (!values.remoteServerUrl) return;
 
     set({ isConnectingServer: true });
     try {
@@ -36,12 +37,12 @@ export const remoteSyncSlice: StateCreator<
       const config = await remoteServerService.getRemoteServerConfig();
 
       // 如果已经激活，需要先清除
-      if (config.active) {
-        await remoteServerService.clearRemoteServerConfig();
+      if (!isEqual(config, values)) {
+        await remoteServerService.setRemoteServerConfig({ ...values, active: false });
       }
 
       // 请求授权
-      const result = await remoteServerService.requestAuthorization(values.serverUrl);
+      const result = await remoteServerService.requestAuthorization(values);
 
       if (!result.success) {
         console.error('请求授权失败:', result.error);
@@ -65,9 +66,9 @@ export const remoteSyncSlice: StateCreator<
   disconnectRemoteServer: async () => {
     set({ isConnectingServer: false });
     try {
-      await remoteServerService.clearRemoteServerConfig();
+      await remoteServerService.setRemoteServerConfig({ active: false, storageMode: 'local' });
       // 更新表单URL为空
-      set({ remoteServerConfig: initialState.remoteServerConfig });
+      set({ dataSyncConfig: initialState.dataSyncConfig });
       // 刷新状态
       await get().refreshServerConfig();
     } catch (error) {
@@ -93,11 +94,10 @@ export const remoteSyncSlice: StateCreator<
     await getChatStoreState().refreshMessages();
     await getChatStoreState().refreshTopic();
     await getUserStoreState().refreshUserState();
-    getSessionStoreState().switchSession(INBOX_SESSION_ID);
   },
 
-  useRemoteServerConfig: () =>
-    useSWR<RemoteServerConfig>(
+  useDataSyncConfig: () =>
+    useSWR<DataSyncConfig>(
       REMOTE_SERVER_CONFIG_KEY,
       async () => {
         try {
@@ -109,13 +109,14 @@ export const remoteSyncSlice: StateCreator<
       },
       {
         onSuccess: (data) => {
-          console.log('remote server config:', data);
-          set({ isInitRemoteServerConfig: true, remoteServerConfig: data });
-
-          if (data.active) {
-            get().refreshUserData();
-          }
+          set({ dataSyncConfig: data, isInitRemoteServerConfig: true });
         },
       },
     ),
+  useRefreshDataWhenActive: (active) =>
+    useSWR(['refreshDataWhenActive', active], async () => {
+      if (!active) return;
+
+      await get().refreshUserData();
+    }),
 });