@huyooo/file-explorer-bridge-electron 0.2.1 → 0.4.2

package/dist/main/index.js

@@ -1,5 +1,5 @@
 // src/main/index.ts
-import { ipcMain, shell } from "electron";
+import { ipcMain, shell, BrowserWindow } from "electron";
 import path from "path";
 import {
   readDirectory,
@@ -21,13 +21,25 @@ import {
   pasteFiles,
   searchFiles,
   searchFilesStream,
+  compressFiles,
+  extractArchive,
+  isArchiveFile,
+  getWatchManager,
+  showFileInfo,
+  openInTerminal,
+  openInEditor,
   getFileType,
   formatFileSize,
-  formatDateTime
+  formatDateTime,
+  encodeFileUrl,
+  getMediaService
 } from "@huyooo/file-explorer-core";
 import { promises as fs } from "fs";
+import { getPreviewHtmlPath } from "@huyooo/file-explorer-preview/path";
 var CHANNEL_PREFIX = "file-explorer";
+var PREVIEW_CHANNEL_PREFIX = "file-explorer-preview";
 var channel = (name) => `${CHANNEL_PREFIX}:${name}`;
+var previewChannel = (name) => `${PREVIEW_CHANNEL_PREFIX}:${name}`;
 var clipboardAdapter = null;
 function setClipboardAdapter(adapter) {
   clipboardAdapter = adapter;
@@ -42,11 +54,11 @@ function createElectronAdapter() {
     }
   };
 }
-function electronUrlEncoder(filePath) {
-  const encodedPath = encodeURIComponent(filePath);
-  return `app://file${encodedPath}`;
-}
-function registerFileExplorerHandlers() {
+var electronUrlEncoder = encodeFileUrl;
+var explorerOptions = {};
+var mediaPreviewWindows = /* @__PURE__ */ new Map();
+function registerFileExplorerHandlers(options = {}) {
+  explorerOptions = options;
   const adapter = createElectronAdapter();
   ipcMain.handle(channel("readDirectory"), async (_event, dirPath) => {
     const thumbnailService = getThumbnailService();
@@ -210,6 +222,282 @@ function registerFileExplorerHandlers() {
     }, 100);
     return { success: true };
   });
+  ipcMain.handle(channel("compressFiles"), async (event, sources, options2) => {
+    try {
+      const result = await compressFiles(sources, options2, (progress) => {
+        event.sender.send(channel("compressProgress"), progress);
+      });
+      return result;
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("extractArchive"), async (event, archivePath, options2) => {
+    try {
+      const result = await extractArchive(archivePath, options2, (progress) => {
+        event.sender.send(channel("extractProgress"), progress);
+      });
+      return result;
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("isArchiveFile"), async (_event, filePath) => {
+    return isArchiveFile(filePath);
+  });
+  const watchUnsubscribers = /* @__PURE__ */ new Map();
+  ipcMain.handle(channel("watchDirectory"), async (event, dirPath, watchId) => {
+    try {
+      const existingUnsubscribe = watchUnsubscribers.get(watchId);
+      if (existingUnsubscribe) {
+        existingUnsubscribe();
+        watchUnsubscribers.delete(watchId);
+      }
+      const watchManager = getWatchManager();
+      const unsubscribe = watchManager.watch(dirPath, (watchEvent) => {
+        event.sender.send(channel("watchEvent"), {
+          watchId,
+          event: watchEvent
+        });
+      });
+      watchUnsubscribers.set(watchId, unsubscribe);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("unwatchDirectory"), async (_event, watchId) => {
+    const unsubscribe = watchUnsubscribers.get(watchId);
+    if (unsubscribe) {
+      unsubscribe();
+      watchUnsubscribers.delete(watchId);
+    }
+    return { success: true };
+  });
+  ipcMain.handle(channel("showFileInfo"), async (_event, filePath) => {
+    return await showFileInfo(filePath);
+  });
+  ipcMain.handle(channel("openInTerminal"), async (_event, dirPath) => {
+    return await openInTerminal(dirPath);
+  });
+  ipcMain.handle(channel("openInEditor"), async (_event, targetPath) => {
+    return await openInEditor(targetPath);
+  });
+  ipcMain.handle(channel("openInNewWindow"), async (_event, folderPath) => {
+    try {
+      if (explorerOptions.onOpenInNewWindow) {
+        explorerOptions.onOpenInNewWindow(folderPath);
+      } else {
+        await shell.openPath(folderPath);
+      }
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.on(channel("requestWindowFocus"), (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win && !win.isFocused()) {
+      win.focus();
+    }
+  });
+  ipcMain.handle(channel("mediaNeedsTranscode"), async (_event, filePath) => {
+    const mediaService = getMediaService();
+    if (!mediaService) {
+      return { success: false, error: "\u5A92\u4F53\u670D\u52A1\u672A\u521D\u59CB\u5316" };
+    }
+    try {
+      const info = await mediaService.needsTranscode(filePath);
+      return { success: true, data: info };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("mediaGetPlayableUrl"), async (event, filePath) => {
+    const mediaService = getMediaService();
+    if (!mediaService) {
+      return { success: false, error: "\u5A92\u4F53\u670D\u52A1\u672A\u521D\u59CB\u5316" };
+    }
+    try {
+      const url = await mediaService.getPlayableUrl(filePath, (progress) => {
+        event.sender.send(channel("mediaTranscodeProgress"), {
+          filePath,
+          progress
+        });
+      });
+      return { success: true, url };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("mediaGetMetadata"), async (_event, filePath) => {
+    const mediaService = getMediaService();
+    if (!mediaService) {
+      return { success: false, error: "\u5A92\u4F53\u670D\u52A1\u672A\u521D\u59CB\u5316" };
+    }
+    try {
+      const metadata = await mediaService.getMetadata(filePath);
+      return { success: true, data: metadata };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("mediaCleanupFile"), async (_event, filePath) => {
+    const mediaService = getMediaService();
+    if (!mediaService) {
+      return { success: false, error: "\u5A92\u4F53\u670D\u52A1\u672A\u521D\u59CB\u5316" };
+    }
+    try {
+      await mediaService.cleanupFile(filePath);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("openMediaPreviewWindow"), async (event, filePath, mediaType) => {
+    try {
+      const fileName = path.basename(filePath);
+      const mediaService = getMediaService();
+      let fileUrl;
+      if (mediaType === "image") {
+        fileUrl = electronUrlEncoder(filePath);
+      } else if (mediaService) {
+        const playableUrl = await mediaService.getPlayableUrl(filePath, (progress) => {
+          event.sender.send(channel("mediaTranscodeProgress"), {
+            filePath,
+            progress
+          });
+        });
+        fileUrl = playableUrl || electronUrlEncoder(filePath);
+      } else {
+        fileUrl = electronUrlEncoder(filePath);
+      }
+      const existingWindow = mediaPreviewWindows.get(filePath);
+      if (existingWindow && !existingWindow.isDestroyed()) {
+        existingWindow.focus();
+        return { success: true };
+      }
+      const isMac = process.platform === "darwin";
+      const isWin = process.platform === "win32";
+      const titleBarHeight = isMac ? 38 : 32;
+      let contentWidth = 720;
+      let contentHeight = 405;
+      let minContentWidth = 720;
+      let minContentHeight = 405;
+      if (mediaType === "audio") {
+        contentWidth = 720;
+        contentHeight = 405;
+        minContentWidth = 720;
+        minContentHeight = 405;
+      } else if (mediaType === "image") {
+        contentWidth = 1e3;
+        contentHeight = 700;
+        minContentWidth = 600;
+        minContentHeight = 400;
+      }
+      const width = contentWidth;
+      const height = contentHeight + titleBarHeight;
+      const minWidth = minContentWidth;
+      const minHeight = minContentHeight + titleBarHeight;
+      const previewPreloadPath = path.join(__dirname, "../preload/preview.cjs");
+      const previewWindow = new BrowserWindow({
+        width,
+        height,
+        minWidth,
+        minHeight,
+        title: fileName,
+        modal: false,
+        show: false,
+        backgroundColor: "#1a1a1a",
+        // 窗口功能
+        resizable: true,
+        maximizable: true,
+        fullscreenable: true,
+        // Windows 和 macOS 都使用无边框样式，自定义标题栏
+        frame: isMac ? true : false,
+        // macOS 用 hiddenInset，Windows 完全无边框
+        titleBarStyle: isMac ? "hiddenInset" : void 0,
+        trafficLightPosition: isMac ? { x: 12, y: 12 } : void 0,
+        webPreferences: {
+          preload: previewPreloadPath,
+          nodeIntegration: false,
+          contextIsolation: true,
+          // 注意：以下设置会触发安全警告，但这是必要的
+          // - sandbox: false - 需要加载本地媒体文件（file:// 协议）
+          // - webSecurity: false - 允许加载本地文件和 Iconify CDN
+          // 这些警告在开发环境中显示，打包后不会显示
+          sandbox: false,
+          webSecurity: false
+        }
+      });
+      const previewHtmlPath = getPreviewHtmlPath();
+      const searchParams = new URLSearchParams({
+        type: mediaType,
+        url: encodeURIComponent(fileUrl),
+        name: encodeURIComponent(fileName),
+        platform: isMac ? "darwin" : isWin ? "win32" : "linux"
+      });
+      previewWindow.loadFile(previewHtmlPath, { search: searchParams.toString() });
+      previewWindow.once("ready-to-show", () => {
+        previewWindow.show();
+      });
+      previewWindow.on("maximize", () => {
+        previewWindow.webContents.send(previewChannel("maximizeChange"), true);
+      });
+      previewWindow.on("unmaximize", () => {
+        previewWindow.webContents.send(previewChannel("maximizeChange"), false);
+      });
+      previewWindow.on("closed", () => {
+        mediaPreviewWindows.delete(filePath);
+      });
+      mediaPreviewWindows.set(filePath, previewWindow);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  });
+  ipcMain.handle(channel("closeMediaPreviewWindow"), async (_event, filePath) => {
+    const window = mediaPreviewWindows.get(filePath);
+    if (window && !window.isDestroyed()) {
+      window.close();
+      mediaPreviewWindows.delete(filePath);
+    }
+    return { success: true };
+  });
+  ipcMain.on(previewChannel("minimize"), (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) {
+      win.minimize();
+    }
+  });
+  ipcMain.on(previewChannel("toggleMaximize"), (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) {
+      if (win.isMaximized()) {
+        win.unmaximize();
+      } else {
+        win.maximize();
+      }
+    }
+  });
+  ipcMain.on(previewChannel("close"), (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) {
+      win.close();
+    }
+  });
+  ipcMain.on(previewChannel("hide"), (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) {
+      win.hide();
+    }
+  });
+  ipcMain.on(previewChannel("show"), (event) => {
+    const win = BrowserWindow.fromWebContents(event.sender);
+    if (win) {
+      win.show();
+    }
+  });
   console.log("\u2705 File Explorer IPC handlers registered");
 }
 export {

package/dist/preload/index.cjs

@@ -56,7 +56,53 @@ function createFileExplorerAPI() {
       };
       import_electron.ipcRenderer.on(channel("searchResults"), handler);
       return () => import_electron.ipcRenderer.removeListener(channel("searchResults"), handler);
-    }
+    },
+    compressFiles: (sources, options) => import_electron.ipcRenderer.invoke(channel("compressFiles"), sources, options),
+    extractArchive: (archivePath, options) => import_electron.ipcRenderer.invoke(channel("extractArchive"), archivePath, options),
+    isArchiveFile: (filePath) => import_electron.ipcRenderer.invoke(channel("isArchiveFile"), filePath),
+    onCompressProgress: (callback) => {
+      const handler = (_event, data) => {
+        callback(data);
+      };
+      import_electron.ipcRenderer.on(channel("compressProgress"), handler);
+      return () => import_electron.ipcRenderer.removeListener(channel("compressProgress"), handler);
+    },
+    onExtractProgress: (callback) => {
+      const handler = (_event, data) => {
+        callback(data);
+      };
+      import_electron.ipcRenderer.on(channel("extractProgress"), handler);
+      return () => import_electron.ipcRenderer.removeListener(channel("extractProgress"), handler);
+    },
+    watchDirectory: (dirPath, watchId) => import_electron.ipcRenderer.invoke(channel("watchDirectory"), dirPath, watchId),
+    unwatchDirectory: (watchId) => import_electron.ipcRenderer.invoke(channel("unwatchDirectory"), watchId),
+    onWatchEvent: (callback) => {
+      const handler = (_event, data) => {
+        callback(data);
+      };
+      import_electron.ipcRenderer.on(channel("watchEvent"), handler);
+      return () => import_electron.ipcRenderer.removeListener(channel("watchEvent"), handler);
+    },
+    showFileInfo: (filePath) => import_electron.ipcRenderer.invoke(channel("showFileInfo"), filePath),
+    openInTerminal: (dirPath) => import_electron.ipcRenderer.invoke(channel("openInTerminal"), dirPath),
+    openInEditor: (targetPath) => import_electron.ipcRenderer.invoke(channel("openInEditor"), targetPath),
+    openInNewWindow: (folderPath) => import_electron.ipcRenderer.invoke(channel("openInNewWindow"), folderPath),
+    requestWindowFocus: () => import_electron.ipcRenderer.send(channel("requestWindowFocus")),
+    // ===== 媒体服务 API =====
+    mediaNeedsTranscode: (filePath) => import_electron.ipcRenderer.invoke(channel("mediaNeedsTranscode"), filePath),
+    mediaGetPlayableUrl: (filePath) => import_electron.ipcRenderer.invoke(channel("mediaGetPlayableUrl"), filePath),
+    mediaGetMetadata: (filePath) => import_electron.ipcRenderer.invoke(channel("mediaGetMetadata"), filePath),
+    onMediaTranscodeProgress: (callback) => {
+      const handler = (_event, data) => {
+        callback(data);
+      };
+      import_electron.ipcRenderer.on(channel("mediaTranscodeProgress"), handler);
+      return () => import_electron.ipcRenderer.removeListener(channel("mediaTranscodeProgress"), handler);
+    },
+    mediaCleanupFile: (filePath) => import_electron.ipcRenderer.invoke(channel("mediaCleanupFile"), filePath),
+    // ===== 媒体预览窗口 API =====
+    openMediaPreviewWindow: (filePath, mediaType) => import_electron.ipcRenderer.invoke(channel("openMediaPreviewWindow"), filePath, mediaType),
+    closeMediaPreviewWindow: (filePath) => import_electron.ipcRenderer.invoke(channel("closeMediaPreviewWindow"), filePath)
   };
 }
 function exposeFileExplorerAPI(apiName = "fileExplorerAPI") {

package/dist/preload/index.d.cts

@@ -126,6 +126,139 @@ interface FileExplorerAPI {
         items: unknown[];
         done: boolean;
     }) => void) => () => void;
+    /** 压缩文件 */
+    compressFiles: (sources: string[], options: {
+        format: 'zip' | 'tar' | 'tgz' | 'tarbz2';
+        level?: 'fast' | 'normal' | 'best';
+        outputName: string;
+        outputDir: string;
+        deleteSource?: boolean;
+    }) => Promise<{
+        success: boolean;
+        outputPath?: string;
+        error?: string;
+    }>;
+    /** 解压文件 */
+    extractArchive: (archivePath: string, options: {
+        targetDir: string;
+        deleteArchive?: boolean;
+    }) => Promise<{
+        success: boolean;
+        outputPath?: string;
+        error?: string;
+    }>;
+    /** 判断是否为压缩文件 */
+    isArchiveFile: (filePath: string) => Promise<boolean>;
+    /** 监听压缩进度 */
+    onCompressProgress: (callback: (data: {
+        currentFile: string;
+        processedCount: number;
+        totalCount: number;
+        percent: number;
+    }) => void) => () => void;
+    /** 监听解压进度 */
+    onExtractProgress: (callback: (data: {
+        currentFile: string;
+        processedCount: number;
+        totalCount: number;
+        percent: number;
+    }) => void) => () => void;
+    /** 监听目录变化 */
+    watchDirectory: (dirPath: string, watchId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 停止监听目录 */
+    unwatchDirectory: (watchId: string) => Promise<{
+        success: boolean;
+    }>;
+    /** 监听文件变化事件 */
+    onWatchEvent: (callback: (data: {
+        watchId: string;
+        event: {
+            type: 'add' | 'change' | 'remove' | 'rename';
+            path: string;
+            filename: string;
+        };
+    }) => void) => () => void;
+    /** 显示文件/文件夹的系统属性窗口 */
+    showFileInfo: (filePath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 在终端中打开目录 */
+    openInTerminal: (dirPath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 通过 Cursor 打开 */
+    openInEditor: (targetPath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 在新窗口中打开文件夹（使用系统文件管理器） */
+    openInNewWindow: (folderPath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 请求窗口聚焦（用于右键打开菜单前激活窗口） */
+    requestWindowFocus: () => void;
+    /** 检测媒体文件是否需要转码 */
+    mediaNeedsTranscode: (filePath: string) => Promise<{
+        success: boolean;
+        data?: {
+            type: 'video' | 'audio';
+            needsTranscode: boolean;
+            method: 'direct' | 'remux' | 'transcode';
+            estimatedTime?: number;
+            targetFormat?: string;
+        };
+        error?: string;
+    }>;
+    /** 获取可播放的媒体 URL（自动转码） */
+    mediaGetPlayableUrl: (filePath: string) => Promise<{
+        success: boolean;
+        url?: string;
+        error?: string;
+    }>;
+    /** 获取媒体元数据 */
+    mediaGetMetadata: (filePath: string) => Promise<{
+        success: boolean;
+        data?: {
+            filePath: string;
+            type: 'video' | 'audio';
+            duration: number;
+            title?: string;
+            artist?: string;
+            album?: string;
+        };
+        error?: string;
+    }>;
+    /** 监听转码进度 */
+    onMediaTranscodeProgress: (callback: (data: {
+        filePath: string;
+        progress: {
+            percent: number;
+            time?: number;
+            duration?: number;
+            speed?: string;
+        };
+    }) => void) => () => void;
+    /** 清理指定文件的转码缓存 */
+    mediaCleanupFile: (filePath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 打开媒体预览窗口 */
+    openMediaPreviewWindow: (filePath: string, mediaType: 'image' | 'video' | 'audio') => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 关闭媒体预览窗口 */
+    closeMediaPreviewWindow: (filePath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
 }
 /**
  * 创建文件操作 API

package/dist/preload/index.d.ts

@@ -126,6 +126,139 @@ interface FileExplorerAPI {
         items: unknown[];
         done: boolean;
     }) => void) => () => void;
+    /** 压缩文件 */
+    compressFiles: (sources: string[], options: {
+        format: 'zip' | 'tar' | 'tgz' | 'tarbz2';
+        level?: 'fast' | 'normal' | 'best';
+        outputName: string;
+        outputDir: string;
+        deleteSource?: boolean;
+    }) => Promise<{
+        success: boolean;
+        outputPath?: string;
+        error?: string;
+    }>;
+    /** 解压文件 */
+    extractArchive: (archivePath: string, options: {
+        targetDir: string;
+        deleteArchive?: boolean;
+    }) => Promise<{
+        success: boolean;
+        outputPath?: string;
+        error?: string;
+    }>;
+    /** 判断是否为压缩文件 */
+    isArchiveFile: (filePath: string) => Promise<boolean>;
+    /** 监听压缩进度 */
+    onCompressProgress: (callback: (data: {
+        currentFile: string;
+        processedCount: number;
+        totalCount: number;
+        percent: number;
+    }) => void) => () => void;
+    /** 监听解压进度 */
+    onExtractProgress: (callback: (data: {
+        currentFile: string;
+        processedCount: number;
+        totalCount: number;
+        percent: number;
+    }) => void) => () => void;
+    /** 监听目录变化 */
+    watchDirectory: (dirPath: string, watchId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 停止监听目录 */
+    unwatchDirectory: (watchId: string) => Promise<{
+        success: boolean;
+    }>;
+    /** 监听文件变化事件 */
+    onWatchEvent: (callback: (data: {
+        watchId: string;
+        event: {
+            type: 'add' | 'change' | 'remove' | 'rename';
+            path: string;
+            filename: string;
+        };
+    }) => void) => () => void;
+    /** 显示文件/文件夹的系统属性窗口 */
+    showFileInfo: (filePath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 在终端中打开目录 */
+    openInTerminal: (dirPath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 通过 Cursor 打开 */
+    openInEditor: (targetPath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 在新窗口中打开文件夹（使用系统文件管理器） */
+    openInNewWindow: (folderPath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 请求窗口聚焦（用于右键打开菜单前激活窗口） */
+    requestWindowFocus: () => void;
+    /** 检测媒体文件是否需要转码 */
+    mediaNeedsTranscode: (filePath: string) => Promise<{
+        success: boolean;
+        data?: {
+            type: 'video' | 'audio';
+            needsTranscode: boolean;
+            method: 'direct' | 'remux' | 'transcode';
+            estimatedTime?: number;
+            targetFormat?: string;
+        };
+        error?: string;
+    }>;
+    /** 获取可播放的媒体 URL（自动转码） */
+    mediaGetPlayableUrl: (filePath: string) => Promise<{
+        success: boolean;
+        url?: string;
+        error?: string;
+    }>;
+    /** 获取媒体元数据 */
+    mediaGetMetadata: (filePath: string) => Promise<{
+        success: boolean;
+        data?: {
+            filePath: string;
+            type: 'video' | 'audio';
+            duration: number;
+            title?: string;
+            artist?: string;
+            album?: string;
+        };
+        error?: string;
+    }>;
+    /** 监听转码进度 */
+    onMediaTranscodeProgress: (callback: (data: {
+        filePath: string;
+        progress: {
+            percent: number;
+            time?: number;
+            duration?: number;
+            speed?: string;
+        };
+    }) => void) => () => void;
+    /** 清理指定文件的转码缓存 */
+    mediaCleanupFile: (filePath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 打开媒体预览窗口 */
+    openMediaPreviewWindow: (filePath: string, mediaType: 'image' | 'video' | 'audio') => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** 关闭媒体预览窗口 */
+    closeMediaPreviewWindow: (filePath: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
 }
 /**
  * 创建文件操作 API