@lobehub/chat 0.140.0 → 0.141.0

package/src/locales/default/common.ts

@@ -10,17 +10,14 @@ export default {
   },
   about: '关于',
   advanceSettings: '高级设置',
-  agentMaxToken: '会话最大长度',
-  agentModel: '模型',
-  agentProfile: '助手信息',
+
   appInitializing: 'LobeChat 启动中，请耐心等待...',
-  archive: '归档',
+
   autoGenerate: '自动补全',
   autoGenerateTooltip: '基于提示词自动补全助手描述',
   cancel: '取消',
   changelog: '更新日志',
   close: '关闭',
-  confirmRemoveSessionItemAlert: '即将删除该助手，删除后该将无法找回，请确认你的操作',
   copy: '复制',
   copyFail: '复制失败',
   copySuccess: '复制成功',
@@ -128,6 +125,31 @@ export default {
   setting: '设置',
   share: '分享',
   stop: '停止',
+  sync: {
+    actions: { settings: '同步设置', sync: '立即同步' },
+    awareness: {
+      current: '当前设备',
+    },
+    channel: '频道',
+    disabled: {
+      actions: { enable: '开启云端同步', settings: '配置同步参数' },
+      desc: '当前会话数据仅存储于此浏览器中。如果你需要在多个设备间同步数据，请配置并开启云端同步。',
+      title: '数据同步未开启',
+    },
+    enabled: {
+      title: '数据同步',
+    },
+    status: {
+      connecting: '连接中',
+      disabled: '同步未开启',
+      ready: '已连接',
+      synced: '已同步',
+      syncing: '同步中',
+      unconnected: '连接失败',
+    },
+    title: '同步状态',
+    unconnected: { tip: '信令服务器连接失败，将无法建立点对点通信频道，请检查网络后重试' },
+  },
   tab: {
     chat: '会话',
     market: '发现',

package/src/locales/default/setting.ts

@@ -442,12 +442,48 @@ export default {
     placeholder: '请输入助手的标识符，需要是唯一的，比如 web-development',
     tooltips: '分享到助手市场',
   },
-
+  sync: {
+    device: {
+      deviceName: {
+        hint: '添加名称以便于识别',
+        placeholder: '请输入设备名称',
+        title: '设备名称',
+      },
+      title: '设备信息',
+      unknownBrowser: '未知浏览器',
+      unknownOS: '未知系统',
+    },
+    warning: {
+      message: '本功能目前仍为实验性功能，可能存在预期外或不稳定的情况，如遇到问题请及时提交反馈。',
+    },
+    webrtc: {
+      channelName: {
+        desc: 'WebRTC 将使用此名创建同步频道，确保频道名称唯一',
+        placeholder: '请输入同步频道名称',
+        shuffle: '随机生成',
+        title: '同步频道名称',
+      },
+      channelPassword: {
+        desc: '添加密码确保频道私密性，只有密码正确时，设备才可加入频道',
+        placeholder: '请输入同步频道密码',
+        title: '同步频道密码',
+      },
+      desc: '实时、点对点的数据通信，需设备同时在线才可同步',
+      enabled: {
+        invalid: '请填写同步频道名称后再开启',
+        // desc: 'WebRTC 将使用此名创建同步频道，确保频道名称唯一',
+        title: '开启同步',
+      },
+      title: 'WebRTC 同步',
+    },
+  },
   tab: {
     about: '关于',
     agent: '默认助手',
     common: '通用设置',
+    experiment: '实验',
     llm: '语言模型',
+    sync: '云端同步',
     tts: '语音服务',
   },
   tools: {

package/src/services/chat.ts

@@ -7,7 +7,11 @@ import { TracePayload, TraceTagMap } from '@/const/trace';
 import { ModelProvider } from '@/libs/agent-runtime';
 import { filesSelectors, useFileStore } from '@/store/file';
 import { useGlobalStore } from '@/store/global';
-import { modelProviderSelectors, preferenceSelectors } from '@/store/global/selectors';
+import {
+  commonSelectors,
+  modelProviderSelectors,
+  preferenceSelectors,
+} from '@/store/global/selectors';
 import { useSessionStore } from '@/store/session';
 import { agentSelectors } from '@/store/session/selectors';
 import { useToolStore } from '@/store/tool';
@@ -310,7 +314,7 @@ class ChatService {
       ...trace,
       enabled: true,
       tags: [tag, ...(trace?.tags || []), ...tags].filter(Boolean) as string[],
-      userId: useGlobalStore.getState().userId,
+      userId: commonSelectors.userId(useGlobalStore.getState()),
     };
   }
 }

package/src/services/config.ts

@@ -42,7 +42,7 @@ class ConfigService {
     return topicService.batchCreateTopics(topics);
   };
   importSessionGroups = async (sessionGroups: SessionGroupItem[]) => {
-    return sessionService.batchCreateSessionGroups(sessionGroups);
+    return sessionService.batchCreateSessionGroups(sessionGroups || []);
   };
 
   importConfigState = async (config: ConfigFile): Promise<ImportResults | undefined> => {

package/src/services/global.ts

@@ -1,4 +1,6 @@
+import { dataSync } from '@/database/core';
 import { GlobalServerConfig } from '@/types/settings';
+import { StartDataSyncParams } from '@/types/sync';
 
 import { API_ENDPOINTS } from './_url';
 
@@ -20,6 +22,19 @@ class GlobalService {
 
     return res.json();
   };
+
+  enabledSync = async (params: StartDataSyncParams) => {
+    if (typeof window === 'undefined') return false;
+
+    await dataSync.startDataSync(params);
+    return true;
+  };
+
+  disableSync = async () => {
+    await dataSync.disconnect();
+
+    return false;
+  };
 }
 
 export const globalService = new GlobalService();

package/src/store/chat/slices/topic/action.test.ts

@@ -148,7 +148,7 @@ describe('topic action', () => {
       });
 
       // Check if mutate has been called with the active session ID
-      expect(mutate).toHaveBeenCalledWith(activeId);
+      expect(mutate).toHaveBeenCalledWith(['SWR_USE_FETCH_TOPIC', activeId]);
     });
 
     it('should handle errors during refreshing topics', async () => {

package/src/store/chat/slices/topic/action.ts

@@ -9,6 +9,7 @@ import { StateCreator } from 'zustand/vanilla';
 import { chainSummaryTitle } from '@/chains/summaryTitle';
 import { LOADING_FLAT } from '@/const/message';
 import { TraceNameMap } from '@/const/trace';
+import { useClientDataSWR } from '@/libs/swr';
 import { chatService } from '@/services/chat';
 import { messageService } from '@/services/message';
 import { topicService } from '@/services/topic';
@@ -22,6 +23,9 @@ import { topicSelectors } from './selectors';
 
 const n = setNamespace('topic');
 
+const SWR_USE_FETCH_TOPIC = 'SWR_USE_FETCH_TOPIC';
+const SWR_USE_SEARCH_TOPIC = 'SWR_USE_SEARCH_TOPIC';
+
 export interface ChatTopicAction {
   favoriteTopic: (id: string, favState: boolean) => Promise<void>;
   openNewTopicOrSaveTopic: () => Promise<void>;
@@ -141,18 +145,25 @@ export const chatTopic: StateCreator<
   },
   // query
   useFetchTopics: (sessionId) =>
-    useSWR<ChatTopic[]>(sessionId, async (sessionId) => topicService.getTopics({ sessionId }), {
-      onSuccess: (topics) => {
-        set({ topics, topicsInit: true }, false, n('useFetchTopics(success)', { sessionId }));
+    useClientDataSWR<ChatTopic[]>(
+      [SWR_USE_FETCH_TOPIC, sessionId],
+      async ([, sessionId]: [string, string]) => topicService.getTopics({ sessionId }),
+      {
+        onSuccess: (topics) => {
+          set({ topics, topicsInit: true }, false, n('useFetchTopics(success)', { sessionId }));
+        },
       },
-      dedupingInterval: 0,
-    }),
+    ),
   useSearchTopics: (keywords) =>
-    useSWR<ChatTopic[]>(keywords, topicService.searchTopics, {
-      onSuccess: (data) => {
-        set({ searchTopics: data }, false, n('useSearchTopics(success)', { keywords }));
+    useSWR<ChatTopic[]>(
+      [SWR_USE_SEARCH_TOPIC, keywords],
+      ([, keywords]: [string, string]) => topicService.searchTopics(keywords),
+      {
+        onSuccess: (data) => {
+          set({ searchTopics: data }, false, n('useSearchTopics(success)', { keywords }));
+        },
       },
-    }),
+    ),
   switchTopic: async (id) => {
     set({ activeTopicId: id }, false, n('toggleTopic'));
 
@@ -213,6 +224,6 @@ export const chatTopic: StateCreator<
     set({ topicLoadingId: id }, false, n('updateTopicLoading'));
   },
   refreshTopic: async () => {
-    await mutate(get().activeId);
+    await mutate([SWR_USE_FETCH_TOPIC, get().activeId]);
   },
 });

package/src/store/global/slices/common/action.ts

@@ -11,12 +11,15 @@ import { messageService } from '@/services/message';
 import { UserConfig, userService } from '@/services/user';
 import type { GlobalStore } from '@/store/global';
 import type { GlobalServerConfig, GlobalSettings } from '@/types/settings';
+import { OnSyncEvent, PeerSyncStatus } from '@/types/sync';
 import { merge } from '@/utils/merge';
+import { browserInfo } from '@/utils/platform';
 import { setNamespace } from '@/utils/storeDebug';
 import { switchLang } from '@/utils/switchLang';
 
 import { preferenceSelectors } from '../preference/selectors';
-import { settingsSelectors } from '../settings/selectors';
+import { settingsSelectors, syncSettingsSelectors } from '../settings/selectors';
+import { commonSelectors } from './selectors';
 
 const n = setNamespace('common');
 
@@ -24,11 +27,18 @@ const n = setNamespace('common');
  * 设置操作
  */
 export interface CommonAction {
+  refreshConnection: (onEvent: OnSyncEvent) => Promise<void>;
   refreshUserConfig: () => Promise<void>;
   switchBackToChat: (sessionId?: string) => void;
+  triggerEnableSync: (userId: string, onEvent: OnSyncEvent) => Promise<boolean>;
   updateAvatar: (avatar: string) => Promise<void>;
   useCheckLatestVersion: () => SWRResponse<string>;
   useCheckTrace: (shouldFetch: boolean) => SWRResponse;
+  useEnabledSync: (
+    userEnableSync: boolean,
+    userId: string | undefined,
+    onEvent: OnSyncEvent,
+  ) => SWRResponse;
   useFetchServerConfig: () => SWRResponse;
   useFetchUserConfig: (initServer: boolean) => SWRResponse<UserConfig | undefined>;
 }
@@ -41,13 +51,53 @@ export const createCommonSlice: StateCreator<
   [],
   CommonAction
 > = (set, get) => ({
+  refreshConnection: async (onEvent) => {
+    const userId = commonSelectors.userId(get());
+
+    if (!userId) return;
+
+    await get().triggerEnableSync(userId, onEvent);
+  },
+
   refreshUserConfig: async () => {
     await mutate([USER_CONFIG_FETCH_KEY, true]);
   },
+
   switchBackToChat: (sessionId) => {
     get().router?.push(SESSION_CHAT_URL(sessionId || INBOX_SESSION_ID, get().isMobile));
   },
+  triggerEnableSync: async (userId: string, onEvent: OnSyncEvent) => {
+    // double-check the sync ability
+    // if there is no channelName, don't start sync
+    const sync = syncSettingsSelectors.webrtcConfig(get());
+    if (!sync.channelName) return false;
+
+    const name = syncSettingsSelectors.deviceName(get());
 
+    const defaultUserName = `My ${browserInfo.browser} (${browserInfo.os})`;
+
+    set({ syncStatus: PeerSyncStatus.Connecting });
+    return globalService.enabledSync({
+      channel: {
+        name: sync.channelName,
+        password: sync.channelPassword,
+      },
+      onAwarenessChange(state) {
+        set({ syncAwareness: state });
+      },
+      onSyncEvent: onEvent,
+      onSyncStatusChange: (status) => {
+        set({ syncStatus: status });
+      },
+      signaling: sync.signaling,
+      user: {
+        id: userId,
+        // if user don't set the name, use default name
+        name: name || defaultUserName,
+        ...browserInfo,
+      },
+    });
+  },
   updateAvatar: async (avatar) => {
     await userService.updateAvatar(avatar);
     await get().refreshUserConfig();
@@ -78,6 +128,26 @@ export const createCommonSlice: StateCreator<
         revalidateOnFocus: false,
       },
     ),
+
+  useEnabledSync: (userEnableSync, userId, onEvent) =>
+    useSWR<boolean>(
+      ['enableSync', userEnableSync, userId],
+      async () => {
+        // if user don't enable sync or no userId ,don't start sync
+        if (!userId) return false;
+
+        // if user don't enable sync, stop sync
+        if (!userEnableSync) return globalService.disableSync();
+
+        return get().triggerEnableSync(userId, onEvent);
+      },
+      {
+        onSuccess: (syncEnabled) => {
+          set({ syncEnabled });
+        },
+        revalidateOnFocus: false,
+      },
+    ),
   useFetchServerConfig: () =>
     useSWR<GlobalServerConfig>('fetchGlobalConfig', globalService.getGlobalConfig, {
       onSuccess: (data) => {

package/src/store/global/slices/common/initialState.ts

@@ -1,5 +1,7 @@
 import { AppRouterInstance } from 'next/dist/shared/lib/app-router-context.shared-runtime';
 
+import { PeerSyncStatus, SyncAwarenessState } from '@/types/sync';
+
 export enum SidebarTabKey {
   Chat = 'chat',
   Market = 'market',
@@ -11,6 +13,7 @@ export enum SettingsTabs {
   Agent = 'agent',
   Common = 'common',
   LLM = 'llm',
+  Sync = 'sync',
   TTS = 'tts',
 }
 
@@ -25,9 +28,15 @@ export interface GlobalCommonState {
   latestVersion?: string;
   router?: AppRouterInstance;
   sidebarKey: SidebarTabKey;
+  syncAwareness: SyncAwarenessState[];
+  syncEnabled: boolean;
+  syncStatus: PeerSyncStatus;
 }
 
 export const initialCommonState: GlobalCommonState = {
   isMobile: false,
   sidebarKey: SidebarTabKey.Chat,
+  syncAwareness: [],
+  syncEnabled: false,
+  syncStatus: PeerSyncStatus.Disabled,
 };

package/src/store/global/slices/common/selectors.ts

@@ -4,4 +4,5 @@ export const commonSelectors = {
   enabledOAuthSSO: (s: GlobalStore) => s.serverConfig.enabledOAuthSSO,
   enabledTelemetryChat: (s: GlobalStore) => s.serverConfig.telemetry.langfuse || false,
   userAvatar: (s: GlobalStore) => s.avatar || '',
+  userId: (s: GlobalStore) => s.userId,
 };

package/src/store/global/slices/preference/initialState.ts

@@ -9,10 +9,11 @@ export interface GlobalPreference {
   // which sessionGroup should expand
   expandSessionGroupKeys: SessionGroupId[];
   guide?: Guide;
+  hideSyncAlert?: boolean;
   inputHeight: number;
   mobileShowTopic?: boolean;
-  sessionsWidth: number;
 
+  sessionsWidth: number;
   showChatSideBar?: boolean;
   showSessionPanel?: boolean;
   showSystemRole?: boolean;

package/src/store/global/slices/preference/selectors.ts

@@ -6,7 +6,10 @@ const useCmdEnterToSend = (s: GlobalStore): boolean => s.preference.useCmdEnterT
 
 const userAllowTrace = (s: GlobalStore) => s.preference.telemetry;
 
+const hideSyncAlert = (s: GlobalStore) => s.preference.hideSyncAlert;
+
 export const preferenceSelectors = {
+  hideSyncAlert,
   sessionGroupKeys,
   useCmdEnterToSend,
   userAllowTrace,

package/src/store/global/slices/settings/selectors/index.ts

@@ -1,2 +1,3 @@
 export { modelProviderSelectors } from './modelProvider';
 export { settingsSelectors } from './settings';
+export { syncSettingsSelectors } from './sync';

package/src/store/global/slices/settings/selectors/sync.ts

@@ -0,0 +1,14 @@
+import { GlobalStore } from '../../../store';
+import { currentSettings } from './settings';
+
+const webrtcConfig = (s: GlobalStore) => currentSettings(s).sync.webrtc;
+const webrtcChannelName = (s: GlobalStore) => webrtcConfig(s).channelName;
+const enableWebRTC = (s: GlobalStore) => webrtcConfig(s).enabled;
+const deviceName = (s: GlobalStore) => currentSettings(s).sync.deviceName;
+
+export const syncSettingsSelectors = {
+  deviceName,
+  enableWebRTC,
+  webrtcChannelName,
+  webrtcConfig,
+};

package/src/types/settings/index.ts

@@ -4,12 +4,14 @@ import type { LobeAgentSession } from '@/types/session';
 
 import { GlobalBaseSettings } from './base';
 import { GlobalLLMConfig } from './modelProvider';
+import { GlobalSyncSettings } from './sync';
 import { GlobalTTSConfig } from './tts';
 
 export type GlobalDefaultAgent = Pick<LobeAgentSession, 'config' | 'meta'>;
 
 export * from './base';
 export * from './modelProvider';
+export * from './sync';
 export * from './tts';
 
 export interface GlobalTool {
@@ -34,6 +36,7 @@ export interface GlobalServerConfig {
 export interface GlobalSettings extends GlobalBaseSettings {
   defaultAgent: GlobalDefaultAgent;
   languageModel: GlobalLLMConfig;
+  sync: GlobalSyncSettings;
   tool: GlobalTool;
   tts: GlobalTTSConfig;
 }

package/src/types/settings/sync.ts

@@ -0,0 +1,10 @@
+export interface WebRTCSyncConfig {
+  channelName?: string;
+  channelPassword?: string;
+  enabled: boolean;
+  signaling?: string;
+}
+export interface GlobalSyncSettings {
+  deviceName?: string;
+  webrtc: WebRTCSyncConfig;
+}

package/src/types/sync.ts

@@ -0,0 +1,41 @@
+import { LobeDBSchemaMap } from '@/database/core/db';
+
+export type OnSyncEvent = (tableKey: keyof LobeDBSchemaMap) => void;
+export type OnSyncStatusChange = (status: PeerSyncStatus) => void;
+export type OnAwarenessChange = (state: SyncAwarenessState[]) => void;
+
+// export type PeerSyncStatus = 'syncing' | 'synced' | 'ready' | 'unconnected';
+
+export enum PeerSyncStatus {
+  Connecting = 'connecting',
+  Disabled = 'disabled',
+  Ready = 'ready',
+  Synced = 'synced',
+  Syncing = 'syncing',
+  Unconnected = 'unconnected',
+}
+
+export interface StartDataSyncParams {
+  channel: {
+    name: string;
+    password?: string;
+  };
+  onAwarenessChange: OnAwarenessChange;
+  onSyncEvent: OnSyncEvent;
+  onSyncStatusChange: OnSyncStatusChange;
+  signaling?: string;
+  user: SyncUserInfo;
+}
+
+export interface SyncUserInfo {
+  browser?: string;
+  id: string;
+  isMobile: boolean;
+  name?: string;
+  os?: string;
+}
+
+export interface SyncAwarenessState extends SyncUserInfo {
+  clientID: number;
+  current: boolean;
+}

package/src/utils/platform.ts

@@ -1,6 +1,6 @@
 import UAParser from 'ua-parser-js';
 
-const getPaser = () => {
+const getParser = () => {
   if (typeof window === 'undefined') return new UAParser('Node');
 
   let ua = navigator.userAgent;
@@ -8,11 +8,17 @@ const getPaser = () => {
 };
 
 export const getPlatform = () => {
-  return getPaser().getOS().name;
+  return getParser().getOS().name;
 };
 
 export const getBrowser = () => {
-  return getPaser().getResult().browser.name;
+  return getParser().getResult().browser.name;
+};
+
+export const browserInfo = {
+  browser: getBrowser(),
+  isMobile: getParser().getDevice().type === 'mobile',
+  os: getParser().getOS().name,
 };
 
 export const isMacOS = () => getPlatform() === 'Mac OS';

package/src/utils/responsive.ts

@@ -17,3 +17,24 @@ export const isMobileDevice = () => {
 
   return device.type === 'mobile';
 };
+
+/**
+ * check mobile device in server
+ */
+export const gerServerDeviceInfo = () => {
+  if (typeof process === 'undefined') {
+    throw new Error('[Server method] you are importing a server-only module outside of server');
+  }
+
+  const { get } = headers();
+  const ua = get('user-agent');
+
+  // console.debug(ua);
+  const parser = new UAParser(ua || '');
+
+  return {
+    browser: parser.getBrowser().name,
+    isMobile: isMobileDevice(),
+    os: parser.getOS().name,
+  };
+};