@lobehub/chat 1.98.2 → 1.99.1

package/src/server/services/file/impls/local.test.ts

@@ -17,6 +17,7 @@ vi.mock('@/server/modules/ElectronIPCClient', () => ({
   electronIpcClient: {
     getFilePathById: vi.fn(),
     deleteFiles: vi.fn(),
+    createFile: vi.fn(),
   },
 }));
 
@@ -40,58 +41,7 @@ describe('DesktopLocalFileImpl', () => {
   });
 
   describe('getLocalFileUrl', () => {
-    it.skip('应该正确获取本地文件URL并转换为data URL', async () => {
-      // 准备: readFileSync在第一次被调用时返回文件内容
-      vi.mocked(readFileSync).mockReturnValueOnce(testFileBuffer);
-
-      // 使用私有方法进行测试，通过原型访问
-      const result = await (service as any).getLocalFileUrl(testFileKey);
-
-      // 验证
-      expect(electronIpcClient.getFilePathById).toHaveBeenCalledWith(testFileKey);
-      expect(existsSync).toHaveBeenCalledWith(testFilePath);
-      expect(readFileSync).toHaveBeenCalledWith(testFilePath);
-
-      // 验证返回的data URL格式正确
-      expect(result).toContain('data:text/plain;base64,');
-      expect(result).toContain(testFileBuffer.toString('base64'));
-    });
-
-    it('当文件不存在时应返回原始键', async () => {
-      // 准备: 文件不存在
-      vi.mocked(existsSync).mockReturnValueOnce(false);
-
-      // 使用私有方法进行测试
-      const result = await (service as any).getLocalFileUrl(testFileKey);
-
-      // 验证
-      expect(result).toBe(testFileKey);
-    });
-
-    it('当发生错误时应返回空字符串', async () => {
-      // 准备: 模拟错误
-      vi.mocked(electronIpcClient.getFilePathById).mockRejectedValueOnce(new Error('测试错误'));
-
-      // 使用私有方法进行测试
-      const result = await (service as any).getLocalFileUrl(testFileKey);
-
-      // 验证
-      expect(result).toBe('');
-    });
-  });
-
-  describe('getMimeTypeFromPath', () => {
-    it('应该返回正确的MIME类型', () => {
-      // 使用私有方法进行测试
-      const jpgResult = (service as any).getMimeTypeFromPath('test.jpg');
-      const pngResult = (service as any).getMimeTypeFromPath('test.png');
-      const unknownResult = (service as any).getMimeTypeFromPath('test.unknown');
-
-      // 验证
-      expect(jpgResult).toBe('image/jpeg');
-      expect(pngResult).toBe('image/png');
-      expect(unknownResult).toBe('application/octet-stream');
-    });
+    it.skip('应该返回 localhost 的 http url', async () => {});
   });
 
   describe('createPreSignedUrl', () => {
@@ -293,6 +243,157 @@ describe('DesktopLocalFileImpl', () => {
 
       await service.uploadContent('path/to/file', 'content');
 
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'uploadContent not implemented for Desktop local file service',
+        'path/to/file',
+        'content',
+      );
+    });
+  });
+
+  describe('getKeyFromFullUrl', () => {
+    it('应该从HTTP URL中正确提取desktop://路径', () => {
+      // 准备
+      const url = 'http://localhost:3000/desktop-file/documents/test.txt';
+
+      // 执行
+      const result = service.getKeyFromFullUrl(url);
+
+      // 验证
+      expect(result).toBe('desktop://documents/test.txt');
+    });
+
+    it('应该处理复杂的文件路径', () => {
+      // 准备
+      const url = 'http://localhost:3000/desktop-file/folder/subfolder/image.png';
+
+      // 执行
+      const result = service.getKeyFromFullUrl(url);
+
+      // 验证
+      expect(result).toBe('desktop://folder/subfolder/image.png');
+    });
+
+    it('应该处理根目录下的文件', () => {
+      // 准备
+      const url = 'http://localhost:3000/desktop-file/test.pdf';
+
+      // 执行
+      const result = service.getKeyFromFullUrl(url);
+
+      // 验证
+      expect(result).toBe('desktop://test.pdf');
+    });
+
+    it('当URL格式不正确时应返回空字符串', () => {
+      // 准备
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const invalidUrl = 'not-a-valid-url';
+
+      // 执行
+      const result = service.getKeyFromFullUrl(invalidUrl);
+
+      // 验证
+      expect(result).toBe('');
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('uploadMedia', () => {
+    it('应该成功上传媒体文件', async () => {
+      // 准备
+      const testKey = 'desktop://images/test.jpg';
+      const testBuffer = Buffer.from('fake image data');
+      const mockResult = {
+        success: true,
+        metadata: {
+          path: testKey,
+          filename: 'test.jpg',
+          dirname: 'desktop://images',
+          date: new Date().toISOString(),
+        },
+      };
+
+      vi.mocked(electronIpcClient.createFile).mockResolvedValueOnce(mockResult);
+
+      // 执行
+      const result = await service.uploadMedia(testKey, testBuffer);
+
+      // 验证
+      expect(electronIpcClient.createFile).toHaveBeenCalledWith({
+        content: testBuffer.toString('base64'),
+        filename: 'test.jpg',
+        hash: expect.any(String), // SHA256 hash
+        path: testKey,
+        type: 'image/jpeg',
+      });
+      expect(result).toEqual({ key: testKey });
+    });
+
+    it('应该正确处理PNG文件', async () => {
+      // 准备
+      const testKey = 'desktop://images/test.png';
+      const testBuffer = Buffer.from('fake png data');
+      const mockResult = {
+        success: true,
+        metadata: {
+          path: testKey,
+          filename: 'test.png',
+          dirname: 'desktop://images',
+          date: new Date().toISOString(),
+        },
+      };
+
+      vi.mocked(electronIpcClient.createFile).mockResolvedValueOnce(mockResult);
+
+      // 执行
+      const result = await service.uploadMedia(testKey, testBuffer);
+
+      // 验证
+      expect(electronIpcClient.createFile).toHaveBeenCalledWith(
+        expect.objectContaining({
+          filename: 'test.png',
+          type: 'image/png',
+        }),
+      );
+      expect(result).toEqual({ key: testKey });
+    });
+
+    it('当上传失败时应抛出错误', async () => {
+      // 准备
+      const testKey = 'desktop://images/test.jpg';
+      const testBuffer = Buffer.from('fake image data');
+      const mockResult = {
+        success: false,
+        metadata: {
+          path: testKey,
+          filename: 'test.jpg',
+          dirname: 'desktop://images',
+          date: new Date().toISOString(),
+        },
+        error: 'Upload failed',
+      };
+
+      vi.mocked(electronIpcClient.createFile).mockResolvedValueOnce(mockResult);
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      // 执行和验证
+      await expect(service.uploadMedia(testKey, testBuffer)).rejects.toThrow(
+        'Failed to upload file via Electron IPC',
+      );
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('当IPC调用失败时应抛出错误', async () => {
+      // 准备
+      const testKey = 'desktop://images/test.jpg';
+      const testBuffer = Buffer.from('fake image data');
+
+      vi.mocked(electronIpcClient.createFile).mockRejectedValueOnce(new Error('IPC error'));
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+      // 执行和验证
+      await expect(service.uploadMedia(testKey, testBuffer)).rejects.toThrow('IPC error');
       expect(consoleSpy).toHaveBeenCalled();
     });
   });

package/src/server/services/file/impls/local.ts

@@ -1,7 +1,9 @@
+import { sha256 } from 'js-sha256';
 import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 
 import { electronIpcClient } from '@/server/modules/ElectronIPCClient';
+import { inferContentTypeFromImageUrl } from '@/utils/url';
 
 import { FileServiceImpl } from './type';
 
@@ -11,59 +13,17 @@ import { FileServiceImpl } from './type';
 export class DesktopLocalFileImpl implements FileServiceImpl {
   /**
    * 获取本地文件的URL
-   * Electron返回文件的绝对路径，然后在服务端将文件转为base64
+   * 通过 IPC 从主进程获取 HTTP URL
    */
   private async getLocalFileUrl(key: string): Promise<string> {
     try {
-      // 从Electron获取文件的绝对路径
-      const filePath = await electronIpcClient.getFilePathById(key);
-
-      // 检查文件是否存在
-      if (!existsSync(filePath)) {
-        console.error(`File not found: ${filePath}`);
-        return key;
-      }
-
-      // 读取文件内容
-      const fileContent = readFileSync(filePath);
-
-      // 确定文件的MIME类型
-      const mimeType = this.getMimeTypeFromPath(filePath);
-
-      // 转换为base64并返回data URL
-      const base64 = fileContent.toString('base64');
-      return `data:${mimeType};base64,${base64}`;
+      return await electronIpcClient.getFileHTTPURL(key);
     } catch (e) {
-      console.error('[DesktopLocalFileImpl] Failed to process file from Electron IPC:', e);
+      console.error('[DesktopLocalFileImpl] Failed to get file HTTP URL via IPC:', e);
       return '';
     }
   }
 
-  /**
-   * 根据文件路径获取MIME类型
-   */
-  private getMimeTypeFromPath(filePath: string): string {
-    const extension = path.extname(filePath).toLowerCase();
-
-    // 常见文件类型的MIME映射
-    const mimeTypes: Record<string, string> = {
-      '.css': 'text/css',
-      '.gif': 'image/gif',
-      '.html': 'text/html',
-      '.jpeg': 'image/jpeg',
-      '.jpg': 'image/jpeg',
-      '.js': 'application/javascript',
-      '.json': 'application/json',
-      '.pdf': 'application/pdf',
-      '.png': 'image/png',
-      '.svg': 'image/svg+xml',
-      '.txt': 'text/plain',
-      '.webp': 'image/webp',
-    };
-
-    return mimeTypes[extension] || 'application/octet-stream';
-  }
-
   /**
    * 创建预签名上传URL（本地版实际上是直接返回文件路径，可能需要进一步扩展）
    */
@@ -74,7 +34,7 @@ export class DesktopLocalFileImpl implements FileServiceImpl {
   }
 
   /**
-   * 创建预签名预览URL（本地版是通过Electron获取本地文件URL）
+   * 创建预签名预览URL（本地版是通过HTTP路径访问本地文件）
    */
   async createPreSignedUrlForPreview(key: string): Promise<string> {
     return this.getLocalFileUrl(key);
@@ -180,4 +140,68 @@ export class DesktopLocalFileImpl implements FileServiceImpl {
     console.warn('uploadContent not implemented for Desktop local file service', filePath, content);
     return;
   }
+
+  /**
+   * 从完整URL中提取key
+   * 从 HTTP URL 中提取 desktop:// 格式的路径
+   */
+  getKeyFromFullUrl(url: string): string {
+    try {
+      const urlObj = new URL(url);
+      const pathSegments = urlObj.pathname.split('/').filter((segment) => segment !== '');
+
+      // 移除第一个路径段（desktop-file）
+      pathSegments.shift();
+
+      // 重新组合剩余的路径段
+      const filePath = pathSegments.join('/');
+
+      // 返回 desktop:// 格式的路径
+      return `desktop://${filePath}`;
+    } catch (e) {
+      console.error('[DesktopLocalFileImpl] Failed to extract key from URL:', e);
+      return '';
+    }
+  }
+
+  /**
+   * 上传媒体文件
+   */
+  async uploadMedia(key: string, buffer: Buffer): Promise<{ key: string }> {
+    try {
+      // 将 Buffer 转换为 Base64 字符串
+      const content = buffer.toString('base64');
+
+      // 从 key 中提取文件名
+      const filename = path.basename(key);
+
+      // 计算文件的 SHA256 hash
+      const hash = sha256(buffer);
+
+      // 根据文件URL推断 MIME 类型
+      const type = inferContentTypeFromImageUrl(key)!;
+
+      // 构造上传参数
+      const uploadParams = {
+        content,
+        filename,
+        hash,
+        path: key,
+        type,
+      };
+
+      // 调用 electronIpcClient 上传文件
+      const result = await electronIpcClient.createFile(uploadParams);
+
+      if (!result.success) {
+        throw new Error('Failed to upload file via Electron IPC');
+      }
+
+      console.log('[DesktopLocalFileImpl] File uploaded successfully:', result.metadata);
+      return { key: result.metadata.path };
+    } catch (error) {
+      console.error('[DesktopLocalFileImpl] Failed to upload media file:', error);
+      throw error;
+    }
+  }
 }

package/src/server/services/file/impls/s3.test.ts

@@ -28,6 +28,7 @@ vi.mock('@/server/modules/S3', () => ({
     deleteFiles: vi.fn().mockResolvedValue({}),
     createPreSignedUrl: vi.fn().mockResolvedValue('https://upload.example.com/test.jpg'),
     uploadContent: vi.fn().mockResolvedValue({}),
+    uploadMedia: vi.fn().mockResolvedValue({}),
   })),
 }));
 
@@ -107,4 +108,117 @@ describe('S3StaticFileImpl', () => {
       expect(fileService['s3'].uploadContent).toHaveBeenCalledWith('test.jpg', 'content');
     });
   });
+
+  describe('getKeyFromFullUrl', () => {
+    it('当S3_ENABLE_PATH_STYLE为false时应该正确提取key', () => {
+      config.S3_ENABLE_PATH_STYLE = false;
+      const url = 'https://example.com/path/to/file.jpg';
+
+      const result = fileService.getKeyFromFullUrl(url);
+
+      expect(result).toBe('path/to/file.jpg');
+      config.S3_ENABLE_PATH_STYLE = false; // reset
+    });
+
+    it('当S3_ENABLE_PATH_STYLE为true时应该正确提取key', () => {
+      config.S3_ENABLE_PATH_STYLE = true;
+      const url = 'https://example.com/my-bucket/path/to/file.jpg';
+
+      const result = fileService.getKeyFromFullUrl(url);
+
+      expect(result).toBe('path/to/file.jpg');
+      config.S3_ENABLE_PATH_STYLE = false; // reset
+    });
+
+    it('当S3_ENABLE_PATH_STYLE为true但缺少bucket名称时应该返回pathname', () => {
+      config.S3_ENABLE_PATH_STYLE = true;
+      config.S3_BUCKET = '';
+      const url = 'https://example.com/path/to/file.jpg';
+
+      const result = fileService.getKeyFromFullUrl(url);
+
+      expect(result).toBe('path/to/file.jpg');
+      config.S3_ENABLE_PATH_STYLE = false; // reset
+      config.S3_BUCKET = 'my-bucket'; // reset
+    });
+
+    it('当URL格式不正确时应该返回原始字符串', () => {
+      const invalidUrl = 'not-a-valid-url';
+
+      const result = fileService.getKeyFromFullUrl(invalidUrl);
+
+      expect(result).toBe('not-a-valid-url');
+    });
+
+    it('应该处理根路径文件', () => {
+      config.S3_ENABLE_PATH_STYLE = false;
+      const url = 'https://example.com/file.jpg';
+
+      const result = fileService.getKeyFromFullUrl(url);
+
+      expect(result).toBe('file.jpg');
+    });
+
+    it('当path-style URL路径格式不符合预期时应该使用fallback', () => {
+      config.S3_ENABLE_PATH_STYLE = true;
+      const url = 'https://example.com/unexpected/path/file.jpg';
+
+      const result = fileService.getKeyFromFullUrl(url);
+
+      expect(result).toBe('unexpected/path/file.jpg');
+      config.S3_ENABLE_PATH_STYLE = false; // reset
+    });
+  });
+
+  describe('uploadMedia', () => {
+    beforeEach(() => {
+      // 重置 S3 mock
+      vi.clearAllMocks();
+    });
+
+    it('应该调用S3的uploadMedia方法并返回key', async () => {
+      // 准备
+      const testKey = 'images/test.jpg';
+      const testBuffer = Buffer.from('fake image data');
+
+      fileService['s3'].uploadMedia = vi.fn().mockResolvedValue(undefined);
+
+      // 执行
+      const result = await fileService.uploadMedia(testKey, testBuffer);
+
+      // 验证
+      expect(fileService['s3'].uploadMedia).toHaveBeenCalledWith(testKey, testBuffer);
+      expect(result).toEqual({ key: testKey });
+    });
+
+    it('应该正确处理不同类型的媒体文件', async () => {
+      // 准备
+      const testKey = 'videos/test.mp4';
+      const testBuffer = Buffer.from('fake video data');
+
+      fileService['s3'].uploadMedia = vi.fn().mockResolvedValue(undefined);
+
+      // 执行
+      const result = await fileService.uploadMedia(testKey, testBuffer);
+
+      // 验证
+      expect(fileService['s3'].uploadMedia).toHaveBeenCalledWith(testKey, testBuffer);
+      expect(result).toEqual({ key: testKey });
+    });
+
+    it('当S3上传失败时应该抛出错误', async () => {
+      // 准备
+      const testKey = 'images/test.jpg';
+      const testBuffer = Buffer.from('fake image data');
+      const uploadError = new Error('S3 upload failed');
+
+      fileService['s3'].uploadMedia = vi.fn().mockRejectedValue(uploadError);
+
+      // 执行和验证
+      await expect(fileService.uploadMedia(testKey, testBuffer)).rejects.toThrow(
+        'S3 upload failed',
+      );
+      expect(fileService['s3'].uploadMedia).toHaveBeenCalledWith(testKey, testBuffer);
+    });
+  });
 });

package/src/server/services/file/impls/s3.ts

@@ -57,4 +57,44 @@ export class S3StaticFileImpl implements FileServiceImpl {
 
     return urlJoin(fileEnv.S3_PUBLIC_DOMAIN!, url);
   }
+
+  getKeyFromFullUrl(url: string): string {
+    try {
+      const urlObject = new URL(url);
+      const { pathname } = urlObject;
+
+      let key: string;
+
+      if (fileEnv.S3_ENABLE_PATH_STYLE) {
+        if (!fileEnv.S3_BUCKET) {
+          // In path-style, we need bucket name to extract key
+          // but if not provided, we can only guess the key is the pathname
+          return pathname.startsWith('/') ? pathname.slice(1) : pathname;
+        }
+        // For path-style URLs, the path is /<bucket>/<key>
+        // We need to remove the leading slash and the bucket name.
+        const bucketPrefix = `/${fileEnv.S3_BUCKET}/`;
+        if (pathname.startsWith(bucketPrefix)) {
+          key = pathname.slice(bucketPrefix.length);
+        } else {
+          // Fallback for unexpected path format
+          key = pathname.startsWith('/') ? pathname.slice(1) : pathname;
+        }
+      } else {
+        // For virtual-hosted-style URLs, the path is /<key>
+        // We just need to remove the leading slash.
+        key = pathname.slice(1);
+      }
+
+      return key;
+    } catch {
+      // if url is not a valid URL, it may be a key itself
+      return url;
+    }
+  }
+
+  async uploadMedia(key: string, buffer: Buffer): Promise<{ key: string }> {
+    await this.s3.uploadMedia(key, buffer);
+    return { key };
+  }
 }

package/src/server/services/file/impls/type.ts

@@ -37,8 +37,18 @@ export interface FileServiceImpl {
    */
   getFullFileUrl(url?: string | null, expiresIn?: number): Promise<string>;
 
+  /**
+   * 从完整URL中提取key
+   */
+  getKeyFromFullUrl(url: string): string;
+
   /**
    * 上传内容
    */
   uploadContent(path: string, content: string): Promise<any>;
+
+  /**
+   * 上传媒体文件
+   */
+  uploadMedia(key: string, buffer: Buffer): Promise<{ key: string }>;
 }

package/src/server/services/file/index.ts

@@ -80,6 +80,20 @@ export class FileService {
     return this.impl.getFullFileUrl(url, expiresIn);
   }
 
+  /**
+   * 从完整 URL中 提取 key
+   */
+  public getKeyFromFullUrl(url: string): string {
+    return this.impl.getKeyFromFullUrl(url);
+  }
+
+  /**
+   * 上传媒体文件
+   */
+  public async uploadMedia(key: string, buffer: Buffer): Promise<{ key: string }> {
+    return this.impl.uploadMedia(key, buffer);
+  }
+
   async downloadFileToLocal(
     fileId: string,
   ): Promise<{ cleanup: () => void; file: FileItem; filePath: string }> {