@lobehub/chat 1.98.2 → 1.99.1

package/apps/desktop/src/main/core/App.ts

@@ -9,6 +9,7 @@ import { buildDir, nextStandaloneDir } from '@/const/dir';
 import { isDev } from '@/const/env';
 import { IControlModule } from '@/controllers';
 import { IServiceModule } from '@/services';
+import FileService from '@/services/fileSrv';
 import { IpcClientEventSender } from '@/types/ipcClientEvent';
 import { createLogger } from '@/utils/logger';
 import { CustomRequestHandler, createHandler } from '@/utils/next-electron-rsc';
@@ -18,6 +19,7 @@ import { I18nManager } from './I18nManager';
 import { IoCContainer } from './IoCContainer';
 import MenuManager from './MenuManager';
 import { ShortcutManager } from './ShortcutManager';
+import { StaticFileServerManager } from './StaticFileServerManager';
 import { StoreManager } from './StoreManager';
 import TrayManager from './TrayManager';
 import { UpdaterManager } from './UpdaterManager';
@@ -41,6 +43,7 @@ export class App {
   updaterManager: UpdaterManager;
   shortcutManager: ShortcutManager;
   trayManager: TrayManager;
+  staticFileServerManager: StaticFileServerManager;
   chromeFlags: string[] = ['OverlayScrollbar', 'FluentOverlayScrollbar', 'FluentScrollbar'];
 
   /**
@@ -97,6 +100,7 @@ export class App {
     this.updaterManager = new UpdaterManager(this);
     this.shortcutManager = new ShortcutManager(this);
     this.trayManager = new TrayManager(this);
+    this.staticFileServerManager = new StaticFileServerManager(this);
 
     // register the schema to interceptor url
     // it should register before app ready
@@ -130,6 +134,9 @@ export class App {
     await this.i18n.init();
     this.menuManager.initialize();
 
+    // Initialize static file manager
+    await this.staticFileServerManager.initialize();
+
     // Initialize global shortcuts: globalShortcut must be called after app.whenReady()
     this.shortcutManager.initialize();
 
@@ -399,6 +406,7 @@ export class App {
     }
 
     // 执行清理操作
+    this.staticFileServerManager.destroy();
     this.unregisterAllRequestHandlers();
   };
 }

package/apps/desktop/src/main/core/BrowserManager.ts

@@ -128,9 +128,12 @@ export default class BrowserManager {
    */
   initializeBrowsers() {
     logger.info('Initializing all browsers');
-    Object.values(appBrowsers).forEach((browser) => {
+    Object.values(appBrowsers).forEach((browser: BrowserWindowOpts) => {
       logger.debug(`Initializing browser: ${browser.identifier}`);
-      this.retrieveOrInitialize(browser);
+
+      if (browser.keepAlive) {
+        this.retrieveOrInitialize(browser);
+      }
     });
   }
 

package/apps/desktop/src/main/core/StaticFileServerManager.ts

@@ -0,0 +1,221 @@
+import { getPort } from 'get-port-please';
+import { createServer } from 'node:http';
+
+import { LOCAL_STORAGE_URL_PREFIX } from '@/const/dir';
+import FileService from '@/services/fileSrv';
+import { createLogger } from '@/utils/logger';
+
+import type { App } from './App';
+
+const logger = createLogger('core:StaticFileServerManager');
+
+export class StaticFileServerManager {
+  private app: App;
+  private fileService: FileService;
+  private httpServer: any = null;
+  private serverPort: number = 0;
+  private isInitialized = false;
+
+  constructor(app: App) {
+    this.app = app;
+    this.fileService = app.getService(FileService);
+    logger.debug('StaticFileServerManager initialized');
+  }
+
+  /**
+   * 初始化静态文件管理器
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) {
+      logger.warn('StaticFileServerManager already initialized');
+      return;
+    }
+
+    logger.info('Initializing StaticFileServerManager');
+
+    try {
+      // 启动 HTTP 文件服务器
+      await this.startHttpServer();
+
+      this.isInitialized = true;
+      logger.info(
+        `StaticFileServerManager initialization completed, server running on port ${this.serverPort}`,
+      );
+    } catch (error) {
+      logger.error('Failed to initialize StaticFileServerManager:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 启动 HTTP 文件服务器
+   */
+  private async startHttpServer(): Promise<void> {
+    try {
+      // 使用 get-port-please 获取可用端口
+      this.serverPort = await getPort({
+        port: 33250, // 首选端口
+        ports: [33251, 33252, 33253, 33254, 33255], // 备用端口
+        host: '127.0.0.1',
+      });
+
+      logger.debug(`Found available port: ${this.serverPort}`);
+
+      return new Promise((resolve, reject) => {
+        const server = createServer(async (req, res) => {
+          // 设置请求超时
+          req.setTimeout(30000, () => {
+            logger.warn('Request timeout, closing connection');
+            if (!res.destroyed && !res.headersSent) {
+              res.writeHead(408, { 'Content-Type': 'text/plain' });
+              res.end('Request Timeout');
+            }
+          });
+
+          // 监听客户端断开连接
+          req.on('close', () => {
+            logger.debug('Client disconnected during request processing');
+          });
+
+          try {
+            await this.handleHttpRequest(req, res);
+          } catch (error) {
+            logger.error('Unhandled error in HTTP request handler:', error);
+
+            // 尝试发送错误响应，但确保不会导致进一步错误
+            try {
+              if (!res.destroyed && !res.headersSent) {
+                res.writeHead(500, { 'Content-Type': 'text/plain' });
+                res.end('Internal Server Error');
+              }
+            } catch (responseError) {
+              logger.error('Failed to send error response:', responseError);
+            }
+          }
+        });
+
+        // 监听指定端口
+        server.listen(this.serverPort, '127.0.0.1', () => {
+          this.httpServer = server;
+          logger.info(`HTTP file server started on port ${this.serverPort}`);
+          resolve();
+        });
+
+        server.on('error', (error) => {
+          logger.error('HTTP server error:', error);
+          reject(error);
+        });
+      });
+    } catch (error) {
+      logger.error('Failed to get available port:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 处理 HTTP 请求
+   */
+  private async handleHttpRequest(req: any, res: any): Promise<void> {
+    try {
+      // 检查响应是否已经结束
+      if (res.destroyed || res.headersSent) {
+        logger.warn('Response already ended, skipping request processing');
+        return;
+      }
+
+      const url = new URL(req.url, `http://127.0.0.1:${this.serverPort}`);
+      logger.debug(`Processing HTTP file request: ${req.url}`);
+
+      // 提取文件路径：从 /desktop-file/path/to/file.png 中提取相对路径
+      let filePath = decodeURIComponent(url.pathname.slice(1)); // 移除开头的 /
+
+      // 如果路径以 desktop-file/ 开头，则移除该前缀
+      const prefixWithoutSlash = LOCAL_STORAGE_URL_PREFIX.slice(1) + '/'; // 移除开头的 / 并添加结尾的 /
+      if (filePath.startsWith(prefixWithoutSlash)) {
+        filePath = filePath.slice(prefixWithoutSlash.length);
+      }
+
+      if (!filePath) {
+        logger.warn(`Empty file path in HTTP request: ${req.url}`);
+        if (!res.headersSent) {
+          res.writeHead(400, { 'Content-Type': 'text/plain' });
+          res.end('Bad Request: Empty file path');
+        }
+        return;
+      }
+
+      // 使用 FileService 获取文件
+      const fileResult = await this.fileService.getFile(`desktop://${filePath}`);
+
+      // 再次检查响应状态
+      if (res.destroyed || res.headersSent) {
+        logger.warn('Response ended during file processing');
+        return;
+      }
+
+      // 设置响应头
+      res.writeHead(200, {
+        'Content-Type': fileResult.mimeType,
+        'Cache-Control': 'public, max-age=31536000', // 缓存一年
+        'Access-Control-Allow-Origin': 'http://localhost:*', // 允许 localhost 的任意端口
+        'Content-Length': Buffer.byteLength(fileResult.content),
+      });
+
+      // 发送文件内容
+      res.end(Buffer.from(fileResult.content));
+
+      logger.debug(`HTTP file served successfully: desktop://${filePath}`);
+    } catch (error) {
+      logger.error(`Error serving HTTP file: ${error}`);
+
+      // 检查响应是否仍然可写
+      if (!res.destroyed && !res.headersSent) {
+        try {
+          // 判断是否是文件未找到错误
+          if (error.name === 'FileNotFoundError') {
+            res.writeHead(404, { 'Content-Type': 'text/plain' });
+            res.end('File Not Found');
+          } else {
+            res.writeHead(500, { 'Content-Type': 'text/plain' });
+            res.end('Internal Server Error');
+          }
+        } catch (writeError) {
+          logger.error('Failed to write error response:', writeError);
+        }
+      } else {
+        logger.warn('Cannot write error response: connection already closed');
+      }
+    }
+  }
+
+  /**
+   * 获取文件服务器域名
+   */
+  getFileServerDomain(): string {
+    if (!this.isInitialized || !this.serverPort) {
+      throw new Error('StaticFileServerManager not initialized or server not started');
+    }
+
+    const serverDomain = `http://127.0.0.1:${this.serverPort}`;
+    return serverDomain;
+  }
+
+  /**
+   * 销毁静态文件管理器
+   */
+  destroy() {
+    logger.info('Destroying StaticFileServerManager');
+
+    if (this.httpServer) {
+      logger.debug('Closing HTTP file server');
+      this.httpServer.close(() => {
+        logger.debug('HTTP file server closed');
+      });
+      this.httpServer = null;
+      this.serverPort = 0;
+    }
+
+    this.isInitialized = false;
+    logger.info('StaticFileServerManager destroyed');
+  }
+}

package/apps/desktop/src/main/services/fileSrv.ts

@@ -1,15 +1,28 @@
 import { DeleteFilesResponse } from '@lobechat/electron-server-ipc';
 import * as fs from 'node:fs';
 import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import path, { join } from 'node:path';
 import { promisify } from 'node:util';
 
-import { FILE_STORAGE_DIR } from '@/const/dir';
+import { FILE_STORAGE_DIR, LOCAL_STORAGE_URL_PREFIX } from '@/const/dir';
 import { makeSureDirExist } from '@/utils/file-system';
 import { createLogger } from '@/utils/logger';
 
 import { ServiceModule } from './index';
 
+/**
+ * 文件未找到错误类
+ */
+export class FileNotFoundError extends Error {
+  constructor(
+    message: string,
+    public path: string,
+  ) {
+    super(message);
+    this.name = 'FileNotFoundError';
+  }
+}
+
 const readFilePromise = promisify(fs.readFile);
 const unlinkPromise = promisify(fs.unlink);
 
@@ -17,7 +30,7 @@ const unlinkPromise = promisify(fs.unlink);
 const logger = createLogger('services:FileService');
 
 interface UploadFileParams {
-  content: ArrayBuffer;
+  content: ArrayBuffer | string; // ArrayBuffer from browser or Base64 string from server
   filename: string;
   hash: string;
   path: string;
@@ -32,17 +45,16 @@ interface FileMetadata {
 }
 
 export default class FileService extends ServiceModule {
+  /**
+   * 获取旧版上传目录路径
+   * @deprecated 仅用于向后兼容旧版文件访问，新文件应存储在 FILE_STORAGE_DIR 的自定义路径下
+   */
   get UPLOADS_DIR() {
     return join(this.app.appStoragePath, FILE_STORAGE_DIR, 'uploads');
   }
 
   constructor(app) {
     super(app);
-
-    // Initialize file storage directory
-    logger.info('Initializing file storage directory');
-    makeSureDirExist(this.UPLOADS_DIR);
-    logger.debug(`Upload directory created: ${this.UPLOADS_DIR}`);
   }
 
   /**
@@ -52,31 +64,44 @@ export default class FileService extends ServiceModule {
     content,
     filename,
     hash,
+    path: filePath,
     type,
   }: UploadFileParams): Promise<{ metadata: FileMetadata; success: boolean }> {
-    logger.info(`Starting to upload file: ${filename}, hash: ${hash}`);
+    logger.info(`Starting to upload file: ${filename}, hash: ${hash}, path: ${filePath}`);
     try {
-      // 创建时间戳目录
-      const date = (Date.now() / 1000 / 60 / 60).toFixed(0);
-      const dirname = join(this.UPLOADS_DIR, date);
-      logger.debug(`Creating timestamp directory: ${dirname}`);
-      makeSureDirExist(dirname);
-
-      // 生成文件保存路径
-      const fileExt = filename.split('.').pop() || '';
-      const savedFilename = `${hash}${fileExt ? `.${fileExt}` : ''}`;
-      const savedPath = join(dirname, savedFilename);
-      logger.debug(`Generated file save path: ${savedPath}`);
-
-      // 写入文件内容
-      const buffer = Buffer.from(content);
-      logger.debug(`Writing file content, size: ${buffer.length} bytes`);
+      // 获取当前时间戳，避免重复调用 Date.now()
+      const now = Date.now();
+      const date = (now / 1000 / 60 / 60).toFixed(0);
+
+      // 使用传入的 filePath 作为文件的存储路径
+      const fullStoragePath = join(this.app.appStoragePath, FILE_STORAGE_DIR, filePath);
+      logger.debug(`Target file storage path: ${fullStoragePath}`);
+
+      // 确保目标目录存在
+      const targetDir = path.dirname(fullStoragePath);
+      logger.debug(`Ensuring target directory exists: ${targetDir}`);
+      makeSureDirExist(targetDir);
+
+      const savedPath = fullStoragePath;
+      logger.debug(`Final file save path: ${savedPath}`);
+
+      // 根据 content 类型创建 Buffer
+      let buffer: Buffer;
+      if (typeof content === 'string') {
+        // 来自服务端的 Base64 字符串
+        buffer = Buffer.from(content, 'base64');
+        logger.debug(`Creating buffer from Base64 string, size: ${buffer.length} bytes`);
+      } else {
+        // 来自浏览器端的 ArrayBuffer
+        buffer = Buffer.from(content);
+        logger.debug(`Creating buffer from ArrayBuffer, size: ${buffer.length} bytes`);
+      }
       await writeFile(savedPath, buffer);
 
       // 写入元数据文件
       const metaFilePath = `${savedPath}.meta`;
       const metadata = {
-        createdAt: Date.now(),
+        createdAt: now, // 使用统一的时间戳
         filename,
         hash,
         size: buffer.length,
@@ -86,13 +111,18 @@ export default class FileService extends ServiceModule {
       await writeFile(metaFilePath, JSON.stringify(metadata, null, 2));
 
       // 返回与S3兼容的元数据格式
-      const desktopPath = `desktop://${date}/${savedFilename}`;
+      const desktopPath = `desktop://${filePath}`;
       logger.info(`File upload successful: ${desktopPath}`);
 
+      // 从路径中提取文件名和目录信息
+      const parsedPath = path.parse(filePath);
+      const dirname = parsedPath.dir || '';
+      const savedFilename = parsedPath.base;
+
       return {
         metadata: {
-          date,
-          dirname: date,
+          date, // 保持时间戳格式，用于兼容性和时间追踪
+          dirname,
           filename: savedFilename,
           path: desktopPath,
         },
@@ -104,6 +134,24 @@ export default class FileService extends ServiceModule {
     }
   }
 
+  /**
+   * 判断路径是否为旧版格式（时间戳目录）
+   *
+   * 旧版路径格式: {timestamp}/{hash}.{ext} (例如: 1234567890/abc123.png)
+   * 新版路径格式: 任意自定义路径 (例如: user_uploads/images/photo.png, ai_generations/image.jpg)
+   *
+   * @param path - 相对路径，不包含 desktop:// 前缀
+   * @returns true 如果是旧版格式，false 如果是新版格式
+   */
+  private isLegacyPath(path: string): boolean {
+    const parts = path.split('/');
+    if (parts.length < 2) return false;
+
+    // 如果第一部分是纯数字（时间戳），则认为是旧版格式
+    // 时间戳格式：精确到小时的 Unix 时间戳，通常是 10 位数字
+    return /^\d+$/.test(parts[0]);
+  }
+
   /**
    * 获取文件内容
    */
@@ -123,13 +171,49 @@ export default class FileService extends ServiceModule {
 
       // 解析路径
       const relativePath = normalizedPath.replace('desktop://', '');
-      const filePath = join(this.UPLOADS_DIR, relativePath);
-      logger.debug(`Reading file from path: ${filePath}`);
 
-      // 读取文件内容
+      // 智能路由：根据路径格式决定从哪个目录读取文件
+      let filePath: string;
+      let isLegacyAttempt = false;
+
+      if (this.isLegacyPath(relativePath)) {
+        // 旧版路径：从 uploads 目录读取（向后兼容）
+        filePath = join(this.UPLOADS_DIR, relativePath);
+        isLegacyAttempt = true;
+        logger.debug(`Legacy path detected, reading from uploads directory: ${filePath}`);
+      } else {
+        // 新版路径：从 FILE_STORAGE_DIR 根目录读取
+        filePath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
+        logger.debug(`New path format, reading from storage root: ${filePath}`);
+      }
+
+      // 读取文件内容，如果第一次尝试失败且是 legacy 路径，则尝试新路径
       logger.debug(`Starting to read file content`);
-      const content = await readFilePromise(filePath);
-      logger.debug(`File content read complete, size: ${content.length} bytes`);
+      let content: Buffer;
+      try {
+        content = await readFilePromise(filePath);
+        logger.debug(`File content read complete, size: ${content.length} bytes`);
+      } catch (firstError) {
+        if (isLegacyAttempt) {
+          // 如果是 legacy 路径读取失败，尝试从新路径读取
+          const fallbackPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
+          logger.debug(
+            `Legacy path read failed, attempting fallback to storage root: ${fallbackPath}`,
+          );
+          try {
+            content = await readFilePromise(fallbackPath);
+            filePath = fallbackPath; // 更新 filePath 用于后续的元数据读取
+            logger.debug(`Fallback read successful, size: ${content.length} bytes`);
+          } catch (fallbackError) {
+            logger.error(
+              `Both legacy and fallback paths failed. Legacy error: ${(firstError as Error).message}, Fallback error: ${(fallbackError as Error).message}`,
+            );
+            throw firstError; // 抛出原始错误
+          }
+        } else {
+          throw firstError;
+        }
+      }
 
       // 读取元数据获取MIME类型
       const metaFilePath = `${filePath}.meta`;
@@ -142,7 +226,9 @@ export default class FileService extends ServiceModule {
         mimeType = metadata.type || mimeType;
         logger.debug(`Got MIME type from metadata: ${mimeType}`);
       } catch (metaError) {
-        logger.warn(`Failed to read metadata file: ${(metaError as Error).message}, using default MIME type`);
+        logger.warn(
+          `Failed to read metadata file: ${(metaError as Error).message}, using default MIME type`,
+        );
         // 如果元数据文件不存在，尝试从文件扩展名猜测MIME类型
         const ext = path.split('.').pop()?.toLowerCase();
         if (ext) {
@@ -184,6 +270,12 @@ export default class FileService extends ServiceModule {
       };
     } catch (error) {
       logger.error(`File retrieval failed:`, error);
+
+      // 如果是文件不存在错误，抛出自定义的 FileNotFoundError
+      if (error instanceof Error && error.message.includes('ENOENT')) {
+        throw new FileNotFoundError(`File not found: ${path}`, path);
+      }
+
       throw new Error(`File retrieval failed: ${(error as Error).message}`);
     }
   }
@@ -200,15 +292,53 @@ export default class FileService extends ServiceModule {
         throw new Error(`Invalid desktop file path: ${path}`);
       }
 
+      // 标准化路径格式
+      const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
+
       // 解析路径
-      const relativePath = path.replace('desktop://', '');
-      const filePath = join(this.UPLOADS_DIR, relativePath);
-      logger.debug(`File deletion path: ${filePath}`);
+      const relativePath = normalizedPath.replace('desktop://', '');
 
-      // 删除文件及其元数据
+      // 智能路由：根据路径格式决定从哪个目录删除文件
+      let filePath: string;
+      let isLegacyAttempt = false;
+
+      if (this.isLegacyPath(relativePath)) {
+        // 旧版路径：从 uploads 目录删除（向后兼容）
+        filePath = join(this.UPLOADS_DIR, relativePath);
+        isLegacyAttempt = true;
+        logger.debug(`Legacy path detected, deleting from uploads directory: ${filePath}`);
+      } else {
+        // 新版路径：从 FILE_STORAGE_DIR 根目录删除
+        filePath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
+        logger.debug(`New path format, deleting from storage root: ${filePath}`);
+      }
+
+      // 删除文件及其元数据，如果第一次尝试失败且是 legacy 路径，则尝试新路径
       logger.debug(`Starting file deletion`);
-      await unlinkPromise(filePath);
-      logger.debug(`File deletion successful`);
+      try {
+        await unlinkPromise(filePath);
+        logger.debug(`File deletion successful`);
+      } catch (firstError) {
+        if (isLegacyAttempt) {
+          // 如果是 legacy 路径删除失败，尝试从新路径删除
+          const fallbackPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
+          logger.debug(
+            `Legacy path deletion failed, attempting fallback to storage root: ${fallbackPath}`,
+          );
+          try {
+            await unlinkPromise(fallbackPath);
+            filePath = fallbackPath; // 更新 filePath 用于后续的元数据删除
+            logger.debug(`Fallback deletion successful`);
+          } catch (fallbackError) {
+            logger.error(
+              `Both legacy and fallback deletion failed. Legacy error: ${(firstError as Error).message}, Fallback error: ${(fallbackError as Error).message}`,
+            );
+            throw firstError; // 抛出原始错误
+          }
+        } else {
+          throw firstError;
+        }
+      }
 
       // 尝试删除元数据文件，但不强制要求存在
       try {
@@ -270,7 +400,9 @@ export default class FileService extends ServiceModule {
     });
 
     const success = errors.length === 0;
-    logger.info(`Batch deletion operation complete, success: ${success}, error count: ${errors.length}`);
+    logger.info(
+      `Batch deletion operation complete, success: ${success}, error count: ${errors.length}`,
+    );
     return {
       success,
       ...(errors.length > 0 && { errors }),
@@ -285,10 +417,65 @@ export default class FileService extends ServiceModule {
       throw new Error(`Invalid desktop file path: ${path}`);
     }
 
+    // 标准化路径格式
+    const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
+
     // 解析路径
-    const relativePath = path.replace('desktop://', '');
-    const fullPath = join(this.UPLOADS_DIR, relativePath);
-    logger.debug(`Resolved filesystem path: ${fullPath}`);
+    const relativePath = normalizedPath.replace('desktop://', '');
+
+    // 智能路由：根据路径格式决定从哪个目录获取文件路径
+    let fullPath: string;
+    if (this.isLegacyPath(relativePath)) {
+      // 旧版路径：从 uploads 目录获取（向后兼容）
+      fullPath = join(this.UPLOADS_DIR, relativePath);
+      logger.debug(`Legacy path detected, resolved to uploads directory: ${fullPath}`);
+
+      // 检查文件是否存在，如果不存在则尝试新路径
+      try {
+        await fs.promises.access(fullPath, fs.constants.F_OK);
+        logger.debug(`Legacy path file exists: ${fullPath}`);
+      } catch {
+        // 如果 legacy 路径文件不存在，尝试新路径
+        const fallbackPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
+        logger.debug(`Legacy path file not found, trying fallback path: ${fallbackPath}`);
+        try {
+          await fs.promises.access(fallbackPath, fs.constants.F_OK);
+          fullPath = fallbackPath;
+          logger.debug(`Fallback path file exists: ${fullPath}`);
+        } catch {
+          // 两个路径都不存在，返回原始的 legacy 路径（保持原有行为）
+          logger.debug(
+            `Neither legacy nor fallback path exists, returning legacy path: ${fullPath}`,
+          );
+        }
+      }
+    } else {
+      // 新版路径：从 FILE_STORAGE_DIR 根目录获取
+      fullPath = join(this.app.appStoragePath, FILE_STORAGE_DIR, relativePath);
+      logger.debug(`New path format, resolved to storage root: ${fullPath}`);
+    }
+
     return fullPath;
   }
+
+  async getFileHTTPURL(path: string): Promise<string> {
+    logger.debug(`Getting file HTTP URL: ${path}`);
+    // 处理desktop://路径
+    if (!path.startsWith('desktop://')) {
+      logger.error(`Invalid desktop file path: ${path}`);
+      throw new Error(`Invalid desktop file path: ${path}`);
+    }
+
+    // 标准化路径格式
+    const normalizedPath = path.replace(/^desktop:\/+/, 'desktop://');
+
+    // 解析路径：从 desktop://path/to/file.png 中提取 path/to/file.png
+    const relativePath = normalizedPath.replace('desktop://', '');
+
+    // 使用 StaticFileServerManager 获取文件服务器域名，然后构建完整 URL
+    const serverDomain = this.app.staticFileServerManager.getFileServerDomain();
+    const httpURL = `${serverDomain}${LOCAL_STORAGE_URL_PREFIX}/${relativePath}`;
+    logger.debug(`Generated HTTP URL: ${httpURL}`);
+    return httpURL;
+  }
 }