@lobehub/lobehub 2.0.0-next.31 → 2.0.0-next.33

package/packages/conversation-flow/src/types/shared.ts

@@ -0,0 +1,63 @@
+import type { UIChatMessage } from '@lobechat/types';
+
+import type { ContextNode } from './contextTree';
+import type { FlatMessage } from './flatMessageList';
+
+/**
+ * Shared Types
+ *
+ * Common types used across the conversation flow engine.
+ */
+
+/**
+ * Re-export UIChatMessage as Message for convenience
+ */
+export type Message = UIChatMessage;
+
+/**
+ * Message group metadata from database
+ * Used for multi-model parallel conversations and manual grouping
+ */
+export interface MessageGroupMetadata {
+  description?: string;
+  id: string;
+  /** Presentation mode: compare, summary, or manual */
+  mode?: 'compare' | 'summary' | 'manual';
+  /** Parent message that triggered this group */
+  parentMessageId?: string;
+  title?: string;
+}
+
+/**
+ * Internal structure node used during tree building
+ */
+export interface IdNode {
+  children: IdNode[];
+  id: string;
+}
+
+/**
+ * Result of the parse function
+ */
+export interface ParseResult {
+  /** Semantic tree structure for navigation and context understanding */
+  contextTree: ContextNode[];
+  /** Flattened list optimized for virtual list rendering */
+  flatList: FlatMessage[];
+  /** Map for O(1) message access */
+  messageMap: Record<string, Message>;
+}
+
+/**
+ * Internal helper maps used during parsing
+ */
+export interface HelperMaps {
+  /** Maps parent ID to array of child IDs */
+  childrenMap: Map<string | null, string[]>;
+  /** Maps message group ID to its metadata */
+  messageGroupMap: Map<string, MessageGroupMetadata>;
+  /** Maps message ID to message */
+  messageMap: Map<string, Message>;
+  /** Maps thread ID to all messages in that thread */
+  threadMap: Map<string, Message[]>;
+}

package/packages/conversation-flow/src/types.ts

@@ -0,0 +1,36 @@
+/**
+ * Type Index
+ *
+ * Centralized exports for all conversation flow types.
+ * Types are organized into three categories:
+ *
+ * 1. Context Tree (types/contextTree.ts) - Tree structure for navigation
+ * 2. Flat Message List (types/flatMessageList.ts) - Optimized for rendering
+ * 3. Shared (types/shared.ts) - Common types used across modules
+ */
+
+// Context Tree Types
+export type {
+  AssistantGroupNode,
+  BranchNode,
+  CompareNode,
+  ContextNode,
+  MessageNode,
+} from './types/contextTree';
+
+// Flat Message List Types
+export type {
+  BranchMetadata,
+  FlatMessage,
+  FlatMessageExtra,
+  FlatMessageRole,
+} from './types/flatMessageList';
+
+// Shared Types
+export type {
+  HelperMaps,
+  IdNode,
+  Message,
+  MessageGroupMetadata,
+  ParseResult,
+} from './types/shared';

package/packages/conversation-flow/vitest.config.mts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      reporter: ['text', 'json', 'lcov', 'text-summary'],
+    },
+    environment: 'happy-dom',
+  },
+});

package/packages/types/src/message/common/metadata.ts

@@ -103,4 +103,8 @@ export interface ModelPerformance {
   latency?: number;
 }
 
-export interface MessageMetadata extends ModelUsage, ModelPerformance {}
+export interface MessageMetadata extends ModelUsage, ModelPerformance {
+  activeBranchIndex?: number;
+  activeColumn?: boolean;
+  compare?: boolean;
+}

package/src/app/[variants]/(main)/chat/@session/features/SessionListContent/List/Item/index.tsx

@@ -4,9 +4,8 @@ import { Flexbox } from 'react-layout-kit';
 import { shallow } from 'zustand/shallow';
 
 import { DEFAULT_AVATAR } from '@/const/meta';
+import { INBOX_SESSION_ID } from '@/const/session';
 import { isDesktop } from '@/const/version';
-import { useAgentStore } from '@/store/agent';
-import { agentSelectors } from '@/store/agent/selectors';
 import { useChatStore } from '@/store/chat';
 import { messageStateSelectors } from '@/store/chat/selectors';
 import { useGlobalStore } from '@/store/global';
@@ -28,7 +27,6 @@ interface SessionItemProps {
 const SessionItem = memo<SessionItemProps>(({ id }) => {
   const [open, setOpen] = useState(false);
   const [createGroupModalOpen, setCreateGroupModalOpen] = useState(false);
-  const [defaultModel] = useAgentStore((s) => [agentSelectors.inboxAgentModel(s)]);
 
   const openSessionInNewWindow = useGlobalStore((s) => s.openSessionInNewWindow);
 
@@ -55,7 +53,8 @@ const SessionItem = memo<SessionItemProps>(({ id }) => {
       ];
     });
 
-  const showModel = sessionType === 'agent' && model && model !== defaultModel;
+  // Only hide the model tag for the inbox session itself (随便聊聊)
+  const showModel = sessionType === 'agent' && model && id !== INBOX_SESSION_ID;
 
   const handleDoubleClick = () => {
     if (isDesktop) {

package/src/envs/__tests__/app.test.ts

@@ -1,18 +1,10 @@
 // @vitest-environment node
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-import { getAppConfig } from '../app';
-
-// Stub the global process object to safely mock environment variables
-vi.stubGlobal('process', {
-  ...process, // Preserve the original process object
-  env: { ...process.env }, // Clone the environment variables object for modification
-});
-
 describe('getServerConfig', () => {
   beforeEach(() => {
-    // Reset environment variables before each test case
-    vi.restoreAllMocks();
+    // Reset modules to clear the cached config
+    vi.resetModules();
   });
 
   // it('correctly handles values for OPENAI_FUNCTION_REGIONS', () => {
@@ -22,7 +14,8 @@ describe('getServerConfig', () => {
   // });
 
   describe('index url', () => {
-    it('should return default URLs when no environment variables are set', () => {
+    it('should return default URLs when no environment variables are set', async () => {
+      const { getAppConfig } = await import('../app');
       const config = getAppConfig();
       expect(config.AGENTS_INDEX_URL).toBe(
         'https://registry.npmmirror.com/@lobehub/agents-index/v1/files/public',
@@ -32,18 +25,20 @@ describe('getServerConfig', () => {
       );
     });
 
-    it('should return custom URLs when environment variables are set', () => {
+    it('should return custom URLs when environment variables are set', async () => {
       process.env.AGENTS_INDEX_URL = 'https://custom-agents-url.com';
       process.env.PLUGINS_INDEX_URL = 'https://custom-plugins-url.com';
+      const { getAppConfig } = await import('../app');
       const config = getAppConfig();
       expect(config.AGENTS_INDEX_URL).toBe('https://custom-agents-url.com');
       expect(config.PLUGINS_INDEX_URL).toBe('https://custom-plugins-url.com');
     });
 
-    it('should return default URLs when environment variables are empty string', () => {
+    it('should return default URLs when environment variables are empty string', async () => {
       process.env.AGENTS_INDEX_URL = '';
       process.env.PLUGINS_INDEX_URL = '';
 
+      const { getAppConfig } = await import('../app');
       const config = getAppConfig();
       expect(config.AGENTS_INDEX_URL).toBe(
         'https://registry.npmmirror.com/@lobehub/agents-index/v1/files/public',
@@ -53,4 +48,43 @@ describe('getServerConfig', () => {
       );
     });
   });
+
+  describe('INTERNAL_APP_URL', () => {
+    it('should default to APP_URL when INTERNAL_APP_URL is not set', async () => {
+      process.env.APP_URL = 'https://example.com';
+      delete process.env.INTERNAL_APP_URL;
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.INTERNAL_APP_URL).toBe('https://example.com');
+    });
+
+    it('should use INTERNAL_APP_URL when explicitly set', async () => {
+      process.env.APP_URL = 'https://public.example.com';
+      process.env.INTERNAL_APP_URL = 'http://localhost:3210';
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.INTERNAL_APP_URL).toBe('http://localhost:3210');
+    });
+
+    it('should use INTERNAL_APP_URL over APP_URL when both are set', async () => {
+      process.env.APP_URL = 'https://public.example.com';
+      process.env.INTERNAL_APP_URL = 'http://internal-service:3210';
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.APP_URL).toBe('https://public.example.com');
+      expect(config.INTERNAL_APP_URL).toBe('http://internal-service:3210');
+    });
+
+    it('should handle localhost INTERNAL_APP_URL for bypassing CDN', async () => {
+      process.env.APP_URL = 'https://cloudflare-proxied.com';
+      process.env.INTERNAL_APP_URL = 'http://127.0.0.1:3210';
+
+      const { getAppConfig } = await import('../app');
+      const config = getAppConfig();
+      expect(config.INTERNAL_APP_URL).toBe('http://127.0.0.1:3210');
+    });
+  });
 });

package/src/envs/app.ts

@@ -20,6 +20,10 @@ const APP_URL = process.env.APP_URL
     ? vercelUrl
     : 'http://localhost:3010';
 
+// INTERNAL_APP_URL is used for server-to-server calls to bypass CDN/proxy
+// Falls back to APP_URL if not set
+const INTERNAL_APP_URL = process.env.INTERNAL_APP_URL || APP_URL;
+
 const ASSISTANT_INDEX_URL = 'https://registry.npmmirror.com/@lobehub/agents-index/v1/files/public';
 
 const PLUGINS_INDEX_URL = 'https://registry.npmmirror.com/@lobehub/plugins-index/v1/files/public';
@@ -43,6 +47,7 @@ export const getAppConfig = () => {
       PLUGIN_SETTINGS: z.string().optional(),
 
       APP_URL: z.string().optional(),
+      INTERNAL_APP_URL: z.string().optional(),
       VERCEL_EDGE_CONFIG: z.string().optional(),
       MIDDLEWARE_REWRITE_THROUGH_LOCAL: z.boolean().optional(),
       ENABLE_AUTH_PROTECTION: z.boolean().optional(),
@@ -77,6 +82,7 @@ export const getAppConfig = () => {
       VERCEL_EDGE_CONFIG: process.env.VERCEL_EDGE_CONFIG,
 
       APP_URL,
+      INTERNAL_APP_URL,
       MIDDLEWARE_REWRITE_THROUGH_LOCAL: process.env.MIDDLEWARE_REWRITE_THROUGH_LOCAL === '1',
       ENABLE_AUTH_PROTECTION: process.env.ENABLE_AUTH_PROTECTION === '1',
 

package/src/server/modules/S3/index.test.ts

@@ -0,0 +1,379 @@
+// @vitest-environment node
+import {
+  DeleteObjectCommand,
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { S3 } from './index';
+
+// Mock AWS SDK
+vi.mock('@aws-sdk/client-s3');
+vi.mock('@aws-sdk/s3-request-presigner');
+
+// Mock environment variables
+vi.mock('@/envs/file', () => ({
+  fileEnv: {
+    S3_ACCESS_KEY_ID: 'test-access-key',
+    S3_BUCKET: 'test-bucket',
+    S3_ENABLE_PATH_STYLE: false,
+    S3_ENDPOINT: 'https://s3.amazonaws.com',
+    S3_PREVIEW_URL_EXPIRE_IN: 7200,
+    S3_REGION: 'us-east-1',
+    S3_SECRET_ACCESS_KEY: 'test-secret-key',
+    S3_SET_ACL: true,
+  },
+}));
+
+// Mock utilities
+vi.mock('@/utils/url', () => ({
+  inferContentTypeFromImageUrl: vi.fn((key: string) => {
+    if (key.endsWith('.jpg') || key.endsWith('.jpeg')) return 'image/jpeg';
+    if (key.endsWith('.png')) return 'image/png';
+    if (key.endsWith('.gif')) return 'image/gif';
+    return 'application/octet-stream';
+  }),
+}));
+
+describe('S3', () => {
+  let mockS3ClientSend: ReturnType<typeof vi.fn>;
+  let mockGetSignedUrl: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Setup S3Client mock
+    mockS3ClientSend = vi.fn();
+    (S3Client as unknown as ReturnType<typeof vi.fn>).mockImplementation(() => ({
+      send: mockS3ClientSend,
+    }));
+
+    // Setup getSignedUrl mock
+    mockGetSignedUrl = vi.fn().mockResolvedValue('https://presigned-url.example.com');
+    (getSignedUrl as unknown as ReturnType<typeof vi.fn>).mockImplementation(mockGetSignedUrl);
+  });
+
+  describe('constructor', () => {
+    it('should initialize S3 client with correct configuration', () => {
+      new S3();
+
+      expect(S3Client).toHaveBeenCalledWith({
+        credentials: {
+          accessKeyId: 'test-access-key',
+          secretAccessKey: 'test-secret-key',
+        },
+        endpoint: 'https://s3.amazonaws.com',
+        forcePathStyle: false,
+        region: 'us-east-1',
+        requestChecksumCalculation: 'WHEN_REQUIRED',
+        responseChecksumValidation: 'WHEN_REQUIRED',
+      });
+    });
+
+    it('should use default region when S3_REGION is not set', () => {
+      vi.doMock('@/envs/file', () => ({
+        fileEnv: {
+          S3_ACCESS_KEY_ID: 'test-access-key',
+          S3_BUCKET: 'test-bucket',
+          S3_ENABLE_PATH_STYLE: false,
+          S3_ENDPOINT: 'https://s3.amazonaws.com',
+          S3_PREVIEW_URL_EXPIRE_IN: 7200,
+          S3_REGION: '',
+          S3_SECRET_ACCESS_KEY: 'test-secret-key',
+          S3_SET_ACL: true,
+        },
+      }));
+
+      new S3();
+
+      expect(S3Client).toHaveBeenCalledWith(
+        expect.objectContaining({
+          region: 'us-east-1',
+        }),
+      );
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('should delete a file with the correct parameters', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      await s3.deleteFile('test-key.txt');
+
+      expect(DeleteObjectCommand).toHaveBeenCalledWith({
+        Bucket: 'test-bucket',
+        Key: 'test-key.txt',
+      });
+      expect(mockS3ClientSend).toHaveBeenCalled();
+    });
+
+    it('should handle deletion errors', async () => {
+      const s3 = new S3();
+      const error = new Error('Delete failed');
+      mockS3ClientSend.mockRejectedValue(error);
+
+      await expect(s3.deleteFile('test-key.txt')).rejects.toThrow('Delete failed');
+    });
+  });
+
+  describe('deleteFiles', () => {
+    it('should delete multiple files with correct parameters', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      const keys = ['file1.txt', 'file2.txt', 'file3.txt'];
+      await s3.deleteFiles(keys);
+
+      expect(DeleteObjectsCommand).toHaveBeenCalledWith({
+        Bucket: 'test-bucket',
+        Delete: {
+          Objects: [{ Key: 'file1.txt' }, { Key: 'file2.txt' }, { Key: 'file3.txt' }],
+        },
+      });
+      expect(mockS3ClientSend).toHaveBeenCalled();
+    });
+
+    it('should handle empty array', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      await s3.deleteFiles([]);
+
+      expect(DeleteObjectsCommand).toHaveBeenCalledWith({
+        Bucket: 'test-bucket',
+        Delete: {
+          Objects: [],
+        },
+      });
+    });
+  });
+
+  describe('getFileContent', () => {
+    it('should retrieve file content as string', async () => {
+      const s3 = new S3();
+      const mockContent = 'Hello, World!';
+      mockS3ClientSend.mockResolvedValue({
+        Body: {
+          transformToString: vi.fn().mockResolvedValue(mockContent),
+        },
+      });
+
+      const result = await s3.getFileContent('test-file.txt');
+
+      expect(GetObjectCommand).toHaveBeenCalledWith({
+        Bucket: 'test-bucket',
+        Key: 'test-file.txt',
+      });
+      expect(result).toBe(mockContent);
+    });
+
+    it('should throw error when response body is missing', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({
+        Body: undefined,
+      });
+
+      await expect(s3.getFileContent('test-file.txt')).rejects.toThrow(
+        'No body in response with test-file.txt',
+      );
+    });
+  });
+
+  describe('getFileByteArray', () => {
+    it('should retrieve file content as byte array', async () => {
+      const s3 = new S3();
+      const mockBytes = new Uint8Array([1, 2, 3, 4, 5]);
+      mockS3ClientSend.mockResolvedValue({
+        Body: {
+          transformToByteArray: vi.fn().mockResolvedValue(mockBytes),
+        },
+      });
+
+      const result = await s3.getFileByteArray('test-file.bin');
+
+      expect(GetObjectCommand).toHaveBeenCalledWith({
+        Bucket: 'test-bucket',
+        Key: 'test-file.bin',
+      });
+      expect(result).toEqual(mockBytes);
+    });
+
+    it('should throw error when response body is missing', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({
+        Body: undefined,
+      });
+
+      await expect(s3.getFileByteArray('test-file.bin')).rejects.toThrow(
+        'No body in response with test-file.bin',
+      );
+    });
+  });
+
+  describe('createPreSignedUrl', () => {
+    it('should create presigned URL for upload with ACL', async () => {
+      const s3 = new S3();
+
+      const result = await s3.createPreSignedUrl('upload-file.txt');
+
+      expect(PutObjectCommand).toHaveBeenCalledWith({
+        ACL: 'public-read',
+        Bucket: 'test-bucket',
+        Key: 'upload-file.txt',
+      });
+      expect(mockGetSignedUrl).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
+        expiresIn: 3600,
+      });
+      expect(result).toBe('https://presigned-url.example.com');
+    });
+  });
+
+  describe('createPreSignedUrlForPreview', () => {
+    it('should create presigned URL for preview with default expiration', async () => {
+      const s3 = new S3();
+
+      const result = await s3.createPreSignedUrlForPreview('preview-file.jpg');
+
+      expect(GetObjectCommand).toHaveBeenCalledWith({
+        Bucket: 'test-bucket',
+        Key: 'preview-file.jpg',
+      });
+      expect(mockGetSignedUrl).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
+        expiresIn: 7200,
+      });
+      expect(result).toBe('https://presigned-url.example.com');
+    });
+
+    it('should create presigned URL for preview with custom expiration', async () => {
+      const s3 = new S3();
+
+      await s3.createPreSignedUrlForPreview('preview-file.jpg', 1800);
+
+      expect(mockGetSignedUrl).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
+        expiresIn: 1800,
+      });
+    });
+  });
+
+  describe('uploadBuffer', () => {
+    it('should upload buffer with correct parameters', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      const buffer = Buffer.from('test data');
+      await s3.uploadBuffer('test-file.bin', buffer, 'application/octet-stream');
+
+      expect(PutObjectCommand).toHaveBeenCalledWith({
+        ACL: 'public-read',
+        Body: buffer,
+        Bucket: 'test-bucket',
+        ContentType: 'application/octet-stream',
+        Key: 'test-file.bin',
+      });
+      expect(mockS3ClientSend).toHaveBeenCalled();
+    });
+
+    it('should upload buffer without content type', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      const buffer = Buffer.from('test data');
+      await s3.uploadBuffer('test-file.bin', buffer);
+
+      expect(PutObjectCommand).toHaveBeenCalledWith({
+        ACL: 'public-read',
+        Body: buffer,
+        Bucket: 'test-bucket',
+        ContentType: undefined,
+        Key: 'test-file.bin',
+      });
+    });
+  });
+
+  describe('uploadContent', () => {
+    it('should upload string content with correct parameters', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      const content = 'Hello, World!';
+      await s3.uploadContent('test-file.txt', content);
+
+      expect(PutObjectCommand).toHaveBeenCalledWith({
+        ACL: 'public-read',
+        Body: content,
+        Bucket: 'test-bucket',
+        Key: 'test-file.txt',
+      });
+      expect(mockS3ClientSend).toHaveBeenCalled();
+    });
+
+    it('should handle empty content', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      await s3.uploadContent('empty.txt', '');
+
+      expect(PutObjectCommand).toHaveBeenCalledWith({
+        ACL: 'public-read',
+        Body: '',
+        Bucket: 'test-bucket',
+        Key: 'empty.txt',
+      });
+    });
+  });
+
+  describe('uploadMedia', () => {
+    it('should upload media with correct content type and cache control for JPEG', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      const buffer = Buffer.from('fake image data');
+      await s3.uploadMedia('image.jpg', buffer);
+
+      expect(PutObjectCommand).toHaveBeenCalledWith({
+        ACL: 'public-read',
+        Body: buffer,
+        Bucket: 'test-bucket',
+        CacheControl: expect.stringContaining('public, max-age='),
+        ContentType: 'image/jpeg',
+        Key: 'image.jpg',
+      });
+      expect(mockS3ClientSend).toHaveBeenCalled();
+    });
+
+    it('should upload media with correct content type for PNG', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      const buffer = Buffer.from('fake image data');
+      await s3.uploadMedia('image.png', buffer);
+
+      expect(PutObjectCommand).toHaveBeenCalledWith(
+        expect.objectContaining({
+          ContentType: 'image/png',
+          Key: 'image.png',
+        }),
+      );
+    });
+
+    it('should upload media with correct content type for GIF', async () => {
+      const s3 = new S3();
+      mockS3ClientSend.mockResolvedValue({});
+
+      const buffer = Buffer.from('fake image data');
+      await s3.uploadMedia('animation.gif', buffer);
+
+      expect(PutObjectCommand).toHaveBeenCalledWith(
+        expect.objectContaining({
+          ContentType: 'image/gif',
+          Key: 'animation.gif',
+        }),
+      );
+    });
+  });
+});