@lobehub/chat 1.133.6 → 1.134.0

package/src/server/featureFlags/index.ts

@@ -0,0 +1,56 @@
+import createDebug from 'debug';
+
+import {
+  DEFAULT_FEATURE_FLAGS,
+  getServerFeatureFlagsValue,
+  mapFeatureFlagsEnvToState,
+} from '@/config/featureFlags';
+import { merge } from '@/utils/merge';
+
+import { EdgeConfig } from '../modules/EdgeConfig';
+
+const debug = createDebug('lobe:featureFlags');
+
+/**
+ * Get feature flags from EdgeConfig with fallback to environment variables
+ * @param userId - Optional user ID for user-specific feature flag evaluation
+ */
+export const getServerFeatureFlagsFromEdgeConfig = async (userId?: string) => {
+  // Try to get feature flags from EdgeConfig first
+  if (EdgeConfig.isEnabled()) {
+    try {
+      const edgeConfig = new EdgeConfig();
+      const edgeFeatureFlags = await edgeConfig.getFeatureFlags();
+
+      if (edgeFeatureFlags && Object.keys(edgeFeatureFlags).length > 0) {
+        // Merge EdgeConfig flags with defaults
+        const mergedFlags = merge(DEFAULT_FEATURE_FLAGS, edgeFeatureFlags);
+        debug('Using EdgeConfig flags for user: %s', userId || 'anonymous');
+        return mergedFlags;
+      } else {
+        debug('EdgeConfig returned empty/null/undefined, falling back to environment variables');
+      }
+    } catch (error) {
+      console.error(
+        '[FeatureFlags] Failed to fetch feature flags from EdgeConfig, falling back to environment variables:',
+        error,
+      );
+    }
+  } else {
+    debug('EdgeConfig not enabled, using environment variables');
+  }
+
+  // Fallback to environment variable-based feature flags
+  const envFlags = getServerFeatureFlagsValue();
+  debug('Using environment variable flags for user: %s', userId || 'anonymous');
+  return envFlags;
+};
+
+/**
+ * Get server feature flags from EdgeConfig and map them to state with user ID
+ * @param userId - Optional user ID for user-specific feature flag evaluation
+ */
+export const getServerFeatureFlagsStateFromEdgeConfig = async (userId?: string) => {
+  const flags = await getServerFeatureFlagsFromEdgeConfig(userId);
+  return mapFeatureFlagsEnvToState(flags, userId);
+};

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

@@ -1,8 +1,24 @@
 import { EdgeConfigClient, createClient } from '@vercel/edge-config';
+import createDebug from 'debug';
 
 import { appEnv } from '@/envs/app';
 
-import type { EdgeConfigData } from './types';
+const debug = createDebug('lobe-server:edge-config');
+
+const EdgeConfigKeys = {
+  /**
+   * Assistant whitelist
+   */
+  AssistantBlacklist: 'assistant_blacklist',
+  /**
+   * Assistant whitelist
+   */
+  AssistantWhitelist: 'assistant_whitelist',
+  /**
+   * Feature flags configuration
+   */
+  FeatureFlags: 'feature_flags',
+};
 
 export class EdgeConfig {
   get client(): EdgeConfigClient {
@@ -16,12 +32,35 @@ export class EdgeConfig {
    * Check if Edge Config is enabled
    */
   static isEnabled() {
-    return !!appEnv.VERCEL_EDGE_CONFIG;
+    const isEnabled = !!appEnv.VERCEL_EDGE_CONFIG;
+    debug('VERCEL_EDGE_CONFIG env var: %s', appEnv.VERCEL_EDGE_CONFIG ? 'SET' : 'NOT SET');
+    debug('EdgeConfig enabled: %s', isEnabled);
+    return isEnabled;
   }
 
   getAgentRestrictions = async () => {
     const { assistant_blacklist: blacklist, assistant_whitelist: whitelist } =
-      await this.client.getAll<EdgeConfigData>(['assistant_whitelist', 'assistant_blacklist']);
-    return { blacklist, whitelist };
+      await this.client.getAll([
+        EdgeConfigKeys.AssistantWhitelist,
+        EdgeConfigKeys.AssistantBlacklist,
+      ]);
+
+    return { blacklist, whitelist } as {
+      blacklist: string[] | undefined;
+      whitelist: string[] | undefined;
+    };
+  };
+
+  getFlagByKey = async (key: string) => {
+    const value = await this.client.get(key);
+    return value;
+  };
+
+  getFeatureFlags = async () => {
+    const featureFlags = await this.client.get(EdgeConfigKeys.FeatureFlags);
+    debug('Feature flags retrieved: %O', featureFlags);
+    return featureFlags as Record<string, boolean | string[]> | undefined;
   };
 }
+
+export { EdgeConfigKeys };

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

@@ -20,6 +20,8 @@ import type { GlobalStore } from '../store';
 const n = setNamespace('g');
 
 export interface GlobalGeneralAction {
+  openSessionInNewWindow: (sessionId: string) => Promise<void>;
+  openTopicInNewWindow: (sessionId: string, topicId: string) => Promise<void>;
   switchLocale: (locale: LocaleMode) => void;
   switchThemeMode: (themeMode: ThemeMode, params?: { skipBroadcast?: boolean }) => void;
   updateSystemStatus: (status: Partial<SystemStatus>, action?: any) => void;
@@ -33,6 +35,50 @@ export const generalActionSlice: StateCreator<
   [],
   GlobalGeneralAction
 > = (set, get) => ({
+  openSessionInNewWindow: async (sessionId: string) => {
+    if (!isDesktop) return;
+
+    try {
+      const { dispatch } = await import('@lobechat/electron-client-ipc');
+
+      const url = `/chat?session=${sessionId}&mode=single`;
+
+      const result = await dispatch('createMultiInstanceWindow', {
+        path: url,
+        templateId: 'chatSingle',
+        uniqueId: `chat_${sessionId}`,
+      });
+
+      if (!result.success) {
+        console.error('Failed to open session in new window:', result.error);
+      }
+    } catch (error) {
+      console.error('Error opening session in new window:', error);
+    }
+  },
+
+  openTopicInNewWindow: async (sessionId: string, topicId: string) => {
+    if (!isDesktop) return;
+
+    try {
+      const { dispatch } = await import('@lobechat/electron-client-ipc');
+
+      const url = `/chat?session=${sessionId}&topic=${topicId}&mode=single`;
+
+      const result = await dispatch('createMultiInstanceWindow', {
+        path: url,
+        templateId: 'chatSingle',
+        uniqueId: `chat_${sessionId}_${topicId}`,
+      });
+
+      if (!result.success) {
+        console.error('Failed to open topic in new window:', result.error);
+      }
+    } catch (error) {
+      console.error('Error opening topic in new window:', error);
+    }
+  },
+
   switchLocale: (locale) => {
     get().updateSystemStatus({ language: locale });