@huyooo/file-explorer-core 0.3.0 → 0.4.2

package/dist/index.cjs

@@ -34,19 +34,29 @@ __export(index_exports, {
   APP_PROTOCOL_PREFIX: () => APP_PROTOCOL_PREFIX,
   APP_PROTOCOL_SCHEME: () => APP_PROTOCOL_SCHEME,
   FileType: () => FileType,
+  MediaService: () => MediaService,
   SqliteThumbnailDatabase: () => SqliteThumbnailDatabase,
   ThumbnailService: () => ThumbnailService,
+  WatchManager: () => WatchManager,
+  cleanupAllTranscodedFiles: () => cleanupAllTranscodedFiles,
+  cleanupTranscodedFile: () => cleanupTranscodedFile,
+  closeThumbnailDatabase: () => closeThumbnailDatabase,
+  compressFiles: () => compressFiles,
   copyFiles: () => copyFiles,
   copyFilesToClipboard: () => copyFilesToClipboard,
   createFfmpegVideoProcessor: () => createFfmpegVideoProcessor,
   createFile: () => createFile,
   createFolder: () => createFolder,
+  createMediaService: () => createMediaService,
   createSharpImageProcessor: () => createSharpImageProcessor,
   createSqliteThumbnailDatabase: () => createSqliteThumbnailDatabase,
   decodeFileUrl: () => decodeFileUrl,
   deleteFiles: () => deleteFiles,
+  detectArchiveFormat: () => detectArchiveFormat,
+  detectTranscodeNeeds: () => detectTranscodeNeeds,
   encodeFileUrl: () => encodeFileUrl,
   exists: () => exists,
+  extractArchive: () => extractArchive,
   formatDate: () => formatDate,
   formatDateTime: () => formatDateTime,
   formatFileSize: () => formatFileSize,
@@ -54,28 +64,39 @@ __export(index_exports, {
   getApplicationIcon: () => getApplicationIcon,
   getClipboardFiles: () => getClipboardFiles,
   getFileHash: () => getFileHash,
-  getFileHashes: () => getFileHashes,
   getFileInfo: () => getFileInfo,
   getFileType: () => getFileType,
   getHomeDirectory: () => getHomeDirectory,
-  getPlatform: () => getPlatform,
+  getMediaFormat: () => getMediaFormat,
+  getMediaService: () => getMediaService,
+  getMediaTypeByExtension: () => getMediaTypeByExtension,
+  getPlatform: () => getPlatform2,
   getSqliteThumbnailDatabase: () => getSqliteThumbnailDatabase,
   getSystemPath: () => getSystemPath,
   getThumbnailService: () => getThumbnailService,
+  getWatchManager: () => getWatchManager,
+  initMediaService: () => initMediaService,
   initThumbnailService: () => initThumbnailService,
   isAppProtocolUrl: () => isAppProtocolUrl,
+  isArchiveFile: () => isArchiveFile,
   isDirectory: () => isDirectory,
   isMediaFile: () => isMediaFile,
   isPreviewable: () => isPreviewable,
   moveFiles: () => moveFiles,
+  openInEditor: () => openInEditor,
+  openInTerminal: () => openInTerminal,
   pasteFiles: () => pasteFiles,
   readDirectory: () => readDirectory,
   readFileContent: () => readFileContent,
   readImageAsBase64: () => readImageAsBase64,
   renameFile: () => renameFile,
+  revealInFileManager: () => revealInFileManager,
   searchFiles: () => searchFiles,
   searchFilesStream: () => searchFilesStream,
   searchFilesSync: () => searchFilesSync,
+  showFileInfo: () => showFileInfo,
+  transcodeMedia: () => transcodeMedia,
+  watchDirectory: () => watchDirectory,
   writeFileContent: () => writeFileContent
 });
 module.exports = __toCommonJS(index_exports);
@@ -107,22 +128,22 @@ function encodeFileUrl(filePath) {
 }
 function decodeFileUrl(url) {
   if (!url) return "";
-  let path12 = url;
-  if (path12.startsWith(APP_PROTOCOL_PREFIX)) {
-    path12 = path12.slice(APP_PROTOCOL_PREFIX.length);
+  let path18 = url;
+  if (path18.startsWith(APP_PROTOCOL_PREFIX)) {
+    path18 = path18.slice(APP_PROTOCOL_PREFIX.length);
   }
-  const hashIndex = path12.indexOf("#");
+  const hashIndex = path18.indexOf("#");
   if (hashIndex !== -1) {
-    path12 = path12.substring(0, hashIndex);
+    path18 = path18.substring(0, hashIndex);
   }
-  const queryIndex = path12.indexOf("?");
+  const queryIndex = path18.indexOf("?");
   if (queryIndex !== -1) {
-    path12 = path12.substring(0, queryIndex);
+    path18 = path18.substring(0, queryIndex);
   }
   try {
-    return decodeURIComponent(path12);
+    return decodeURIComponent(path18);
   } catch {
-    return path12;
+    return path18;
   }
 }
 function isAppProtocolUrl(url) {
@@ -470,16 +491,16 @@ async function createFile(filePath, content = "") {
       await import_node_fs2.promises.writeFile(filePath, content, "utf-8");
       return { success: true, data: { finalPath: filePath } };
     }
-    const dirname = import_node_path3.default.dirname(filePath);
+    const dirname3 = import_node_path3.default.dirname(filePath);
     const ext = import_node_path3.default.extname(filePath);
-    const basename = import_node_path3.default.basename(filePath, ext);
+    const basename2 = import_node_path3.default.basename(filePath, ext);
     let counter = 2;
-    let finalPath = import_node_path3.default.join(dirname, `${basename} ${counter}${ext}`);
+    let finalPath = import_node_path3.default.join(dirname3, `${basename2} ${counter}${ext}`);
     while (true) {
       try {
         await import_node_fs2.promises.access(finalPath);
         counter++;
-        finalPath = import_node_path3.default.join(dirname, `${basename} ${counter}${ext}`);
+        finalPath = import_node_path3.default.join(dirname3, `${basename2} ${counter}${ext}`);
       } catch {
         break;
       }
@@ -655,6 +676,468 @@ async function isDirectory(filePath) {
   }
 }
 
+// src/operations/shell.ts
+var import_node_child_process = require("child_process");
+var import_node_util = require("util");
+var path6 = __toESM(require("path"), 1);
+var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+function getPlatform() {
+  switch (process.platform) {
+    case "darwin":
+      return "mac";
+    case "win32":
+      return "windows";
+    default:
+      return "linux";
+  }
+}
+async function showFileInfo(filePath) {
+  const platform2 = getPlatform();
+  try {
+    switch (platform2) {
+      case "mac": {
+        const script = `tell application "Finder"
+          activate
+          set theFile to POSIX file "${filePath}" as alias
+          open information window of theFile
+        end tell`;
+        await execAsync(`osascript -e '${script}'`);
+        break;
+      }
+      case "windows": {
+        const escapedPath = filePath.replace(/'/g, "''");
+        const psScript = `
+          $shell = New-Object -ComObject Shell.Application
+          $folder = $shell.Namespace((Split-Path '${escapedPath}'))
+          $item = $folder.ParseName((Split-Path '${escapedPath}' -Leaf))
+          $item.InvokeVerb('properties')
+        `;
+        await execAsync(`powershell -Command "${psScript.replace(/\n/g, " ")}"`);
+        break;
+      }
+      case "linux": {
+        const commands = [
+          `nautilus --select "${filePath}" && nautilus -q`,
+          // GNOME
+          `dolphin --select "${filePath}"`,
+          // KDE
+          `thunar --quit && thunar "${path6.dirname(filePath)}"`,
+          // XFCE
+          `xdg-open "${path6.dirname(filePath)}"`
+          // 通用
+        ];
+        let lastError = null;
+        for (const cmd of commands) {
+          try {
+            await execAsync(cmd);
+            return { success: true };
+          } catch (e) {
+            lastError = e;
+          }
+        }
+        throw lastError || new Error("No file manager found");
+      }
+    }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function revealInFileManager(filePath) {
+  const platform2 = getPlatform();
+  try {
+    switch (platform2) {
+      case "mac": {
+        await execAsync(`open -R "${filePath}"`);
+        break;
+      }
+      case "windows": {
+        await execAsync(`explorer.exe /select,"${filePath}"`);
+        break;
+      }
+      case "linux": {
+        await execAsync(`xdg-open "${path6.dirname(filePath)}"`);
+        break;
+      }
+    }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function openInTerminal(dirPath) {
+  const platform2 = getPlatform();
+  try {
+    switch (platform2) {
+      case "mac": {
+        try {
+          const itermScript = `tell application "iTerm"
+            activate
+            try
+              set newWindow to (create window with default profile)
+              tell current session of newWindow
+                write text "cd '${dirPath}'"
+              end tell
+            on error
+              tell current window
+                create tab with default profile
+                tell current session
+                  write text "cd '${dirPath}'"
+                end tell
+              end tell
+            end try
+          end tell`;
+          await execAsync(`osascript -e '${itermScript}'`);
+        } catch {
+          const terminalScript = `tell application "Terminal"
+            activate
+            do script "cd '${dirPath}'"
+          end tell`;
+          await execAsync(`osascript -e '${terminalScript}'`);
+        }
+        break;
+      }
+      case "windows": {
+        try {
+          await execAsync(`wt -d "${dirPath}"`);
+        } catch {
+          await execAsync(`start cmd /K "cd /d ${dirPath}"`);
+        }
+        break;
+      }
+      case "linux": {
+        const terminals = [
+          `gnome-terminal --working-directory="${dirPath}"`,
+          `konsole --workdir "${dirPath}"`,
+          `xfce4-terminal --working-directory="${dirPath}"`,
+          `xterm -e "cd '${dirPath}' && $SHELL"`
+        ];
+        let lastError = null;
+        for (const cmd of terminals) {
+          try {
+            await execAsync(cmd);
+            return { success: true };
+          } catch (e) {
+            lastError = e;
+          }
+        }
+        throw lastError || new Error("No terminal found");
+      }
+    }
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function openInEditor(targetPath) {
+  const platform2 = getPlatform();
+  try {
+    const editors = platform2 === "mac" ? [
+      // macOS: 优先 Cursor，回退到 VSCode
+      `open -a "Cursor" "${targetPath}"`,
+      `open -a "Visual Studio Code" "${targetPath}"`,
+      `code "${targetPath}"`
+    ] : platform2 === "windows" ? [
+      // Windows
+      `cursor "${targetPath}"`,
+      `code "${targetPath}"`
+    ] : [
+      // Linux
+      `cursor "${targetPath}"`,
+      `code "${targetPath}"`
+    ];
+    let lastError = null;
+    for (const cmd of editors) {
+      try {
+        await execAsync(cmd);
+        return { success: true };
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    throw lastError || new Error("No editor found");
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/operations/compress.ts
+var compressing = __toESM(require("compressing"), 1);
+var path7 = __toESM(require("path"), 1);
+var fs7 = __toESM(require("fs"), 1);
+var import_node_fs7 = require("fs");
+var import_promises = require("stream/promises");
+function getExtension(format) {
+  switch (format) {
+    case "zip":
+      return ".zip";
+    case "tar":
+      return ".tar";
+    case "tgz":
+      return ".tar.gz";
+    case "tarbz2":
+      return ".tar.bz2";
+    default:
+      return ".zip";
+  }
+}
+function detectArchiveFormat(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.endsWith(".zip")) return "zip";
+  if (lowerPath.endsWith(".tar.gz") || lowerPath.endsWith(".tgz")) return "tgz";
+  if (lowerPath.endsWith(".tar.bz2") || lowerPath.endsWith(".tbz2")) return "tarbz2";
+  if (lowerPath.endsWith(".tar")) return "tar";
+  return null;
+}
+function isArchiveFile(filePath) {
+  return detectArchiveFormat(filePath) !== null;
+}
+async function getAllFiles(dirPath) {
+  const files = [];
+  const entries = await import_node_fs7.promises.readdir(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path7.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await getAllFiles(fullPath));
+    } else {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function countFiles(sources) {
+  let count = 0;
+  for (const source of sources) {
+    const stats = await import_node_fs7.promises.stat(source);
+    if (stats.isDirectory()) {
+      const files = await getAllFiles(source);
+      count += files.length;
+    } else {
+      count += 1;
+    }
+  }
+  return count;
+}
+async function compressFiles(sources, options, onProgress) {
+  try {
+    const { format, level = "normal", outputName, outputDir, deleteSource } = options;
+    const ext = getExtension(format);
+    const finalName = outputName.endsWith(ext) ? outputName : outputName + ext;
+    const outputPath = path7.join(outputDir, finalName);
+    await import_node_fs7.promises.mkdir(outputDir, { recursive: true });
+    const totalCount = await countFiles(sources);
+    let processedCount = 0;
+    switch (format) {
+      case "zip": {
+        const stream = new compressing.zip.Stream();
+        for (const source of sources) {
+          const stats = await import_node_fs7.promises.stat(source);
+          const baseName = path7.basename(source);
+          if (stats.isDirectory()) {
+            const files = await getAllFiles(source);
+            for (const file of files) {
+              const relativePath = path7.relative(path7.dirname(source), file);
+              stream.addEntry(file, { relativePath });
+              processedCount++;
+              onProgress?.({
+                currentFile: path7.basename(file),
+                processedCount,
+                totalCount,
+                percent: Math.round(processedCount / totalCount * 100)
+              });
+            }
+          } else {
+            stream.addEntry(source, { relativePath: baseName });
+            processedCount++;
+            onProgress?.({
+              currentFile: baseName,
+              processedCount,
+              totalCount,
+              percent: Math.round(processedCount / totalCount * 100)
+            });
+          }
+        }
+        const destStream = fs7.createWriteStream(outputPath);
+        await (0, import_promises.pipeline)(stream, destStream);
+        break;
+      }
+      case "tar": {
+        const stream = new compressing.tar.Stream();
+        for (const source of sources) {
+          const stats = await import_node_fs7.promises.stat(source);
+          const baseName = path7.basename(source);
+          if (stats.isDirectory()) {
+            const files = await getAllFiles(source);
+            for (const file of files) {
+              const relativePath = path7.relative(path7.dirname(source), file);
+              stream.addEntry(file, { relativePath });
+              processedCount++;
+              onProgress?.({
+                currentFile: path7.basename(file),
+                processedCount,
+                totalCount,
+                percent: Math.round(processedCount / totalCount * 100)
+              });
+            }
+          } else {
+            stream.addEntry(source, { relativePath: baseName });
+            processedCount++;
+            onProgress?.({
+              currentFile: baseName,
+              processedCount,
+              totalCount,
+              percent: Math.round(processedCount / totalCount * 100)
+            });
+          }
+        }
+        const destStream = fs7.createWriteStream(outputPath);
+        await (0, import_promises.pipeline)(stream, destStream);
+        break;
+      }
+      case "tgz": {
+        const stream = new compressing.tgz.Stream();
+        for (const source of sources) {
+          const stats = await import_node_fs7.promises.stat(source);
+          const baseName = path7.basename(source);
+          if (stats.isDirectory()) {
+            const files = await getAllFiles(source);
+            for (const file of files) {
+              const relativePath = path7.relative(path7.dirname(source), file);
+              stream.addEntry(file, { relativePath });
+              processedCount++;
+              onProgress?.({
+                currentFile: path7.basename(file),
+                processedCount,
+                totalCount,
+                percent: Math.round(processedCount / totalCount * 100)
+              });
+            }
+          } else {
+            stream.addEntry(source, { relativePath: baseName });
+            processedCount++;
+            onProgress?.({
+              currentFile: baseName,
+              processedCount,
+              totalCount,
+              percent: Math.round(processedCount / totalCount * 100)
+            });
+          }
+        }
+        const destStream = fs7.createWriteStream(outputPath);
+        await (0, import_promises.pipeline)(stream, destStream);
+        break;
+      }
+      case "tarbz2": {
+        console.warn("tar.bz2 format not fully supported, using tgz instead");
+        const tgzStream = new compressing.tgz.Stream();
+        for (const source of sources) {
+          const stats = await import_node_fs7.promises.stat(source);
+          const baseName = path7.basename(source);
+          if (stats.isDirectory()) {
+            const files = await getAllFiles(source);
+            for (const file of files) {
+              const relativePath = path7.relative(path7.dirname(source), file);
+              tgzStream.addEntry(file, { relativePath });
+              processedCount++;
+              onProgress?.({
+                currentFile: path7.basename(file),
+                processedCount,
+                totalCount,
+                percent: Math.round(processedCount / totalCount * 100)
+              });
+            }
+          } else {
+            tgzStream.addEntry(source, { relativePath: baseName });
+            processedCount++;
+            onProgress?.({
+              currentFile: baseName,
+              processedCount,
+              totalCount,
+              percent: Math.round(processedCount / totalCount * 100)
+            });
+          }
+        }
+        const destStream = fs7.createWriteStream(outputPath.replace(".tar.bz2", ".tar.gz"));
+        await (0, import_promises.pipeline)(tgzStream, destStream);
+        break;
+      }
+    }
+    if (deleteSource) {
+      for (const source of sources) {
+        const stats = await import_node_fs7.promises.stat(source);
+        if (stats.isDirectory()) {
+          await import_node_fs7.promises.rm(source, { recursive: true });
+        } else {
+          await import_node_fs7.promises.unlink(source);
+        }
+      }
+    }
+    return { success: true, outputPath };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function extractArchive(archivePath, options, onProgress) {
+  try {
+    const { targetDir, deleteArchive } = options;
+    const format = detectArchiveFormat(archivePath);
+    if (!format) {
+      return { success: false, error: "\u4E0D\u652F\u6301\u7684\u538B\u7F29\u683C\u5F0F" };
+    }
+    await import_node_fs7.promises.mkdir(targetDir, { recursive: true });
+    onProgress?.({
+      currentFile: path7.basename(archivePath),
+      processedCount: 0,
+      totalCount: 1,
+      percent: 0
+    });
+    switch (format) {
+      case "zip":
+        await compressing.zip.uncompress(archivePath, targetDir);
+        break;
+      case "tar":
+        await compressing.tar.uncompress(archivePath, targetDir);
+        break;
+      case "tgz":
+        await compressing.tgz.uncompress(archivePath, targetDir);
+        break;
+      case "tarbz2":
+        console.warn("tar.bz2 format not fully supported");
+        return { success: false, error: "tar.bz2 \u683C\u5F0F\u6682\u4E0D\u652F\u6301" };
+    }
+    onProgress?.({
+      currentFile: path7.basename(archivePath),
+      processedCount: 1,
+      totalCount: 1,
+      percent: 100
+    });
+    if (deleteArchive) {
+      await import_node_fs7.promises.unlink(archivePath);
+    }
+    return { success: true, outputPath: targetDir };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
 // src/system-paths.ts
 var import_node_path6 = __toESM(require("path"), 1);
 var import_node_os = __toESM(require("os"), 1);
@@ -705,14 +1188,14 @@ function getAllSystemPaths() {
 function getHomeDirectory() {
   return import_node_os.default.homedir();
 }
-function getPlatform() {
+function getPlatform2() {
   return process.platform;
 }
 
 // src/search.ts
 var import_fdir = require("fdir");
 var import_node_path7 = __toESM(require("path"), 1);
-var import_node_fs7 = require("fs");
+var import_node_fs8 = require("fs");
 function patternToRegex(pattern) {
   return new RegExp(pattern.replace(/\*/g, ".*"), "i");
 }
@@ -736,7 +1219,7 @@ async function searchFilesStream(searchPath, pattern, onResults, maxResults = 10
   async function searchDir(dirPath) {
     if (stopped) return;
     try {
-      const entries = await import_node_fs7.promises.readdir(dirPath, { withFileTypes: true });
+      const entries = await import_node_fs8.promises.readdir(dirPath, { withFileTypes: true });
       const matched = [];
       const subdirs = [];
       for (const entry of entries) {
@@ -784,38 +1267,23 @@ function searchFilesSync(searchPath, pattern, maxDepth) {
 }
 
 // src/hash.ts
-var import_node_crypto = require("crypto");
-var import_promises = require("fs/promises");
-async function getFileHash(filePath) {
-  try {
-    const stats = await (0, import_promises.stat)(filePath);
-    const hashInput = `${filePath}:${stats.size}:${stats.mtime.getTime()}`;
-    return (0, import_node_crypto.createHash)("md5").update(hashInput).digest("hex");
-  } catch (error) {
-    console.error(`Error computing hash for ${filePath}:`, error);
-    return (0, import_node_crypto.createHash)("md5").update(filePath).digest("hex");
-  }
-}
-async function getFileHashes(filePaths) {
-  const hashMap = /* @__PURE__ */ new Map();
-  await Promise.allSettled(
-    filePaths.map(async (filePath) => {
-      const hash = await getFileHash(filePath);
-      hashMap.set(filePath, hash);
-    })
-  );
-  return hashMap;
+var import_hash_wasm = require("hash-wasm");
+var import_promises2 = require("fs/promises");
+async function getFileHash(filePath, stats) {
+  const fileStats = stats || await (0, import_promises2.stat)(filePath);
+  const hashInput = `${filePath}:${fileStats.size}:${fileStats.mtime.getTime()}`;
+  return await (0, import_hash_wasm.xxhash64)(hashInput);
 }
 
 // src/clipboard.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path8 = __toESM(require("path"), 1);
 async function copyFilesToClipboard(filePaths, clipboard) {
   try {
     const cleanPaths = [];
     for (const p of filePaths) {
       try {
-        await import_node_fs8.promises.access(p);
+        await import_node_fs9.promises.access(p);
         cleanPaths.push(p);
       } catch {
       }
@@ -855,7 +1323,7 @@ async function pasteFiles(targetDir, sourcePaths) {
       let counter = 1;
       while (true) {
         try {
-          await import_node_fs8.promises.access(destPath);
+          await import_node_fs9.promises.access(destPath);
           const ext = import_node_path8.default.extname(fileName);
           const baseName = import_node_path8.default.basename(fileName, ext);
           destPath = import_node_path8.default.join(targetDir, `${baseName} ${++counter}${ext}`);
@@ -863,11 +1331,11 @@ async function pasteFiles(targetDir, sourcePaths) {
           break;
         }
       }
-      const stats = await import_node_fs8.promises.stat(sourcePath);
+      const stats = await import_node_fs9.promises.stat(sourcePath);
       if (stats.isDirectory()) {
         await copyDirectory2(sourcePath, destPath);
       } else {
-        await import_node_fs8.promises.copyFile(sourcePath, destPath);
+        await import_node_fs9.promises.copyFile(sourcePath, destPath);
       }
       pastedPaths.push(destPath);
     }
@@ -877,26 +1345,26 @@ async function pasteFiles(targetDir, sourcePaths) {
   }
 }
 async function copyDirectory2(source, dest) {
-  await import_node_fs8.promises.mkdir(dest, { recursive: true });
-  const entries = await import_node_fs8.promises.readdir(source, { withFileTypes: true });
+  await import_node_fs9.promises.mkdir(dest, { recursive: true });
+  const entries = await import_node_fs9.promises.readdir(source, { withFileTypes: true });
   for (const entry of entries) {
     const sourcePath = import_node_path8.default.join(source, entry.name);
     const destPath = import_node_path8.default.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory2(sourcePath, destPath);
     } else {
-      await import_node_fs8.promises.copyFile(sourcePath, destPath);
+      await import_node_fs9.promises.copyFile(sourcePath, destPath);
     }
   }
 }
 
 // src/application-icon.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 var import_node_path9 = __toESM(require("path"), 1);
 var import_node_os2 = __toESM(require("os"), 1);
-var import_node_child_process = require("child_process");
-var import_node_util = require("util");
-var execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
+var import_node_child_process2 = require("child_process");
+var import_node_util2 = require("util");
+var execAsync2 = (0, import_node_util2.promisify)(import_node_child_process2.exec);
 async function findAppIconPath(appPath) {
   const resourcesPath = import_node_path9.default.join(appPath, "Contents", "Resources");
   try {
@@ -908,7 +1376,7 @@ async function findAppIconPath(appPath) {
     ];
     const infoPlistPath = import_node_path9.default.join(appPath, "Contents", "Info.plist");
     try {
-      const infoPlistContent = await import_node_fs9.promises.readFile(infoPlistPath, "utf-8");
+      const infoPlistContent = await import_node_fs10.promises.readFile(infoPlistPath, "utf-8");
       const iconFileMatch = infoPlistContent.match(/<key>CFBundleIconFile<\/key>\s*<string>([^<]+)<\/string>/);
       if (iconFileMatch && iconFileMatch[1]) {
         let iconFileName = iconFileMatch[1].trim();
@@ -917,7 +1385,7 @@ async function findAppIconPath(appPath) {
         }
         const iconPath = import_node_path9.default.join(resourcesPath, iconFileName);
         try {
-          await import_node_fs9.promises.access(iconPath);
+          await import_node_fs10.promises.access(iconPath);
           return iconPath;
         } catch {
         }
@@ -927,14 +1395,14 @@ async function findAppIconPath(appPath) {
     for (const iconName of commonIconNames) {
       const iconPath = import_node_path9.default.join(resourcesPath, iconName);
       try {
-        await import_node_fs9.promises.access(iconPath);
+        await import_node_fs10.promises.access(iconPath);
         return iconPath;
       } catch {
         continue;
       }
     }
     try {
-      const entries = await import_node_fs9.promises.readdir(resourcesPath);
+      const entries = await import_node_fs10.promises.readdir(resourcesPath);
       const icnsFile = entries.find((entry) => entry.toLowerCase().endsWith(".icns"));
       if (icnsFile) {
         return import_node_path9.default.join(resourcesPath, icnsFile);
@@ -951,7 +1419,7 @@ async function getApplicationIcon(appPath) {
     return null;
   }
   try {
-    const stats = await import_node_fs9.promises.stat(appPath);
+    const stats = await import_node_fs10.promises.stat(appPath);
     if (!stats.isDirectory() || !appPath.endsWith(".app")) {
       return null;
     }
@@ -964,12 +1432,12 @@ async function getApplicationIcon(appPath) {
   }
   try {
     const tempPngPath = import_node_path9.default.join(import_node_os2.default.tmpdir(), `app-icon-${Date.now()}.png`);
-    await execAsync(
+    await execAsync2(
       `sips -s format png "${iconPath}" --out "${tempPngPath}" --resampleHeightWidthMax 128`
     );
-    const pngBuffer = await import_node_fs9.promises.readFile(tempPngPath);
+    const pngBuffer = await import_node_fs10.promises.readFile(tempPngPath);
     try {
-      await import_node_fs9.promises.unlink(tempPngPath);
+      await import_node_fs10.promises.unlink(tempPngPath);
     } catch {
     }
     const base64 = pngBuffer.toString("base64");
@@ -979,11 +1447,150 @@ async function getApplicationIcon(appPath) {
   }
 }
 
+// src/watch.ts
+var fs11 = __toESM(require("fs"), 1);
+var path12 = __toESM(require("path"), 1);
+var debounceTimers = /* @__PURE__ */ new Map();
+var DEBOUNCE_DELAY = 100;
+function watchDirectory(dirPath, callback) {
+  let watcher = null;
+  try {
+    watcher = fs11.watch(dirPath, { persistent: true }, (eventType, filename) => {
+      if (!filename) return;
+      const fullPath = path12.join(dirPath, filename);
+      const key = `${dirPath}:${filename}`;
+      const existingTimer = debounceTimers.get(key);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const timer = setTimeout(() => {
+        debounceTimers.delete(key);
+        fs11.access(fullPath, fs11.constants.F_OK, (err) => {
+          let type;
+          if (err) {
+            type = "remove";
+          } else if (eventType === "rename") {
+            type = "add";
+          } else {
+            type = "change";
+          }
+          callback({
+            type,
+            path: fullPath,
+            filename
+          });
+        });
+      }, DEBOUNCE_DELAY);
+      debounceTimers.set(key, timer);
+    });
+    watcher.on("error", (error) => {
+      console.error("Watch error:", error);
+    });
+  } catch (error) {
+    console.error("Failed to watch directory:", error);
+  }
+  return {
+    close: () => {
+      if (watcher) {
+        watcher.close();
+        watcher = null;
+      }
+      for (const [key, timer] of debounceTimers.entries()) {
+        if (key.startsWith(`${dirPath}:`)) {
+          clearTimeout(timer);
+          debounceTimers.delete(key);
+        }
+      }
+    },
+    path: dirPath
+  };
+}
+var WatchManager = class {
+  watchers = /* @__PURE__ */ new Map();
+  callbacks = /* @__PURE__ */ new Map();
+  /**
+   * 开始监听目录
+   */
+  watch(dirPath, callback) {
+    const normalizedPath = path12.normalize(dirPath);
+    let callbackSet = this.callbacks.get(normalizedPath);
+    if (!callbackSet) {
+      callbackSet = /* @__PURE__ */ new Set();
+      this.callbacks.set(normalizedPath, callbackSet);
+    }
+    callbackSet.add(callback);
+    let watcherInfo = this.watchers.get(normalizedPath);
+    if (watcherInfo) {
+      watcherInfo.refCount++;
+    } else {
+      const watcher = watchDirectory(normalizedPath, (event) => {
+        const callbacks = this.callbacks.get(normalizedPath);
+        if (callbacks) {
+          for (const cb of callbacks) {
+            try {
+              cb(event);
+            } catch (error) {
+              console.error("Watch callback error:", error);
+            }
+          }
+        }
+      });
+      watcherInfo = { watcher, refCount: 1 };
+      this.watchers.set(normalizedPath, watcherInfo);
+    }
+    return () => {
+      this.unwatch(normalizedPath, callback);
+    };
+  }
+  /**
+   * 停止监听
+   */
+  unwatch(dirPath, callback) {
+    const normalizedPath = path12.normalize(dirPath);
+    const callbackSet = this.callbacks.get(normalizedPath);
+    if (callbackSet) {
+      callbackSet.delete(callback);
+      if (callbackSet.size === 0) {
+        this.callbacks.delete(normalizedPath);
+      }
+    }
+    const watcherInfo = this.watchers.get(normalizedPath);
+    if (watcherInfo) {
+      watcherInfo.refCount--;
+      if (watcherInfo.refCount <= 0) {
+        watcherInfo.watcher.close();
+        this.watchers.delete(normalizedPath);
+      }
+    }
+  }
+  /**
+   * 关闭所有监听器
+   */
+  closeAll() {
+    for (const [, watcherInfo] of this.watchers) {
+      watcherInfo.watcher.close();
+    }
+    this.watchers.clear();
+    this.callbacks.clear();
+  }
+};
+var globalWatchManager = null;
+function getWatchManager() {
+  if (!globalWatchManager) {
+    globalWatchManager = new WatchManager();
+  }
+  return globalWatchManager;
+}
+
 // src/thumbnail/service.ts
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 var import_node_path10 = __toESM(require("path"), 1);
-var IMAGE_EXTENSIONS2 = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"];
-var VIDEO_EXTENSIONS2 = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".wmv"];
+function isImageFile(filePath, fileType) {
+  return fileType === "image" /* IMAGE */;
+}
+function isVideoFile(filePath, fileType) {
+  return fileType === "video" /* VIDEO */;
+}
 var ThumbnailService = class {
   database;
   imageProcessor;
@@ -1002,7 +1609,7 @@ var ThumbnailService = class {
    */
   async getCachedThumbnailUrl(filePath) {
     try {
-      const stats = await import_node_fs10.promises.stat(filePath);
+      const stats = await import_node_fs11.promises.stat(filePath);
       const fileType = getFileType(filePath, stats);
       if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
         return await this.getApplicationIcon(filePath);
@@ -1015,7 +1622,7 @@ var ThumbnailService = class {
       if (cachedPath) {
         return this.urlEncoder(cachedPath);
       }
-      getFileHash(filePath).then((fileHash) => {
+      getFileHash(filePath, stats).then((fileHash) => {
         this.generateThumbnail(filePath, fileHash, mtime).catch(() => {
         });
       }).catch(() => {
@@ -1030,7 +1637,7 @@ var ThumbnailService = class {
    */
   async getThumbnailUrl(filePath) {
     try {
-      const stats = await import_node_fs10.promises.stat(filePath);
+      const stats = await import_node_fs11.promises.stat(filePath);
       const fileType = getFileType(filePath, stats);
       if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
         return await this.getApplicationIcon(filePath);
@@ -1043,7 +1650,7 @@ var ThumbnailService = class {
       if (cachedPath) {
         return this.urlEncoder(cachedPath);
       }
-      const fileHash = await getFileHash(filePath);
+      const fileHash = await getFileHash(filePath, stats);
       const thumbnailPath = await this.generateThumbnail(filePath, fileHash, mtime);
       if (thumbnailPath) {
         return this.urlEncoder(thumbnailPath);
@@ -1063,13 +1670,14 @@ var ThumbnailService = class {
       return cachedPath;
     }
     try {
-      const ext = import_node_path10.default.extname(filePath).toLowerCase();
+      const stats = await import_node_fs11.promises.stat(filePath);
+      const fileType = getFileType(filePath, stats);
       const hashPrefix = fileHash.substring(0, 16);
       const thumbnailFileName = `${hashPrefix}.jpg`;
       const thumbnailPath = import_node_path10.default.join(this.database.getCacheDir(), thumbnailFileName);
-      if (IMAGE_EXTENSIONS2.includes(ext) && this.imageProcessor) {
+      if (isImageFile(filePath, fileType) && this.imageProcessor) {
         await this.imageProcessor.resize(filePath, thumbnailPath, 256);
-      } else if (VIDEO_EXTENSIONS2.includes(ext) && this.videoProcessor) {
+      } else if (isVideoFile(filePath, fileType) && this.videoProcessor) {
         await this.videoProcessor.screenshot(filePath, thumbnailPath, "00:00:01", "256x256");
       } else {
         return null;
@@ -1082,12 +1690,20 @@ var ThumbnailService = class {
     }
   }
   /**
-   * 批量生成缩略图
+   * 批量生成缩略图（带并发限制，避免资源耗尽）
    */
-  async generateThumbnailsBatch(files) {
-    await Promise.allSettled(
-      files.map((file) => this.generateThumbnail(file.path, file.hash, file.mtime))
-    );
+  async generateThumbnailsBatch(files, concurrency = 3) {
+    const execute = async (file) => {
+      try {
+        await this.generateThumbnail(file.path, file.hash, file.mtime);
+      } catch (error) {
+        console.debug(`Failed to generate thumbnail for ${file.path}:`, error);
+      }
+    };
+    for (let i = 0; i < files.length; i += concurrency) {
+      const batch = files.slice(i, i + concurrency);
+      await Promise.allSettled(batch.map(execute));
+    }
   }
   /**
    * 删除缩略图
@@ -1114,14 +1730,19 @@ function getThumbnailService() {
 // src/thumbnail/database.ts
 var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
 var import_node_path11 = __toESM(require("path"), 1);
-var import_node_fs11 = require("fs");
+var import_node_fs12 = require("fs");
 var SqliteThumbnailDatabase = class {
   db = null;
   cacheDir;
-  constructor(userDataPath) {
-    this.cacheDir = import_node_path11.default.join(userDataPath, "cache");
-    if (!(0, import_node_fs11.existsSync)(this.cacheDir)) {
-      (0, import_node_fs11.mkdirSync)(this.cacheDir, { recursive: true });
+  dbPath;
+  constructor(userDataPath, options = {}) {
+    const defaultDirName = options.dirName || "thumbnails";
+    const defaultDbFileName = options.dbFileName || "thumbnails.db";
+    const inferredDirFromDbPath = options.dbPath ? import_node_path11.default.dirname(options.dbPath) : null;
+    this.cacheDir = options.thumbnailDir ? options.thumbnailDir : inferredDirFromDbPath || import_node_path11.default.join(userDataPath, defaultDirName);
+    this.dbPath = options.dbPath ? options.dbPath : import_node_path11.default.join(this.cacheDir, defaultDbFileName);
+    if (!(0, import_node_fs12.existsSync)(this.cacheDir)) {
+      (0, import_node_fs12.mkdirSync)(this.cacheDir, { recursive: true });
     }
   }
   /**
@@ -1129,8 +1750,7 @@ var SqliteThumbnailDatabase = class {
    */
   init() {
     if (this.db) return;
-    const dbPath = import_node_path11.default.join(this.cacheDir, "thumbnails.db");
-    this.db = new import_better_sqlite3.default(dbPath, {
+    this.db = new import_better_sqlite3.default(this.dbPath, {
       fileMustExist: false
     });
     this.db.pragma("journal_mode = WAL");
@@ -1162,7 +1782,7 @@ var SqliteThumbnailDatabase = class {
       WHERE file_path = ? AND mtime = ?
     `);
     const row = stmt.get(filePath, mtime);
-    if (row && (0, import_node_fs11.existsSync)(row.thumbnail_path)) {
+    if (row && (0, import_node_fs12.existsSync)(row.thumbnail_path)) {
       return row.thumbnail_path;
     }
     return null;
@@ -1175,7 +1795,7 @@ var SqliteThumbnailDatabase = class {
       WHERE file_path = ? AND file_hash = ?
     `);
     const row = stmt.get(filePath, fileHash);
-    if (row && row.mtime === mtime && (0, import_node_fs11.existsSync)(row.thumbnail_path)) {
+    if (row && row.mtime === mtime && (0, import_node_fs12.existsSync)(row.thumbnail_path)) {
       return row.thumbnail_path;
     }
     return null;
@@ -1202,15 +1822,19 @@ var SqliteThumbnailDatabase = class {
   }
   close() {
     if (this.db) {
+      try {
+        this.db.pragma("wal_checkpoint(TRUNCATE)");
+      } catch (error) {
+      }
       this.db.close();
       this.db = null;
     }
   }
 };
 var thumbnailDb = null;
-function createSqliteThumbnailDatabase(userDataPath) {
+function createSqliteThumbnailDatabase(options) {
   if (!thumbnailDb) {
-    thumbnailDb = new SqliteThumbnailDatabase(userDataPath);
+    thumbnailDb = new SqliteThumbnailDatabase(options.userDataPath, options);
     thumbnailDb.init();
   }
   return thumbnailDb;
@@ -1218,59 +1842,699 @@ function createSqliteThumbnailDatabase(userDataPath) {
 function getSqliteThumbnailDatabase() {
   return thumbnailDb;
 }
+function closeThumbnailDatabase() {
+  if (thumbnailDb) {
+    thumbnailDb.close();
+    thumbnailDb = null;
+  }
+}
 
 // src/thumbnail/processors.ts
-var import_node_child_process2 = require("child_process");
-var import_node_util2 = require("util");
-var execFileAsync = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var import_node_child_process3 = require("child_process");
 function createSharpImageProcessor(sharp) {
   return {
     async resize(filePath, outputPath, size) {
-      await sharp(filePath).resize(size, size, {
-        fit: "inside",
+      await sharp(filePath).resize({
+        width: size,
         withoutEnlargement: true
-      }).jpeg({ quality: 85 }).toFile(outputPath);
+      }).jpeg({
+        quality: 80,
+        optimiseCoding: true
+        // 优化编码，提升压缩率
+      }).toFile(outputPath);
     }
   };
 }
 function createFfmpegVideoProcessor(ffmpegPath) {
   return {
     async screenshot(filePath, outputPath, timestamp, size) {
-      const scaleSize = size.replace("x", ":");
-      await execFileAsync(ffmpegPath, [
-        "-i",
-        filePath,
-        "-ss",
-        timestamp,
-        "-vframes",
-        "1",
-        "-vf",
-        `scale=${scaleSize}:force_original_aspect_ratio=decrease`,
-        "-y",
-        outputPath
-      ]);
+      const width = size.split("x")[0];
+      return new Promise((resolve, reject) => {
+        const ffmpeg = (0, import_node_child_process3.spawn)(ffmpegPath, [
+          "-y",
+          "-ss",
+          timestamp,
+          "-i",
+          filePath,
+          "-vframes",
+          "1",
+          "-vf",
+          `thumbnail,scale=${width}:-1:force_original_aspect_ratio=decrease`,
+          // 使用 mjpeg 编码器，性能更好（借鉴 pixflow）
+          "-c:v",
+          "mjpeg",
+          "-q:v",
+          "6",
+          // 质量参数，6 表示中等质量（范围 2-31，数值越小质量越高）
+          outputPath
+        ]);
+        const timeout = setTimeout(() => {
+          ffmpeg.kill();
+          reject(new Error("Video thumbnail generation timeout"));
+        }, 3e4);
+        ffmpeg.stderr.on("data", (data) => {
+          const output = data.toString();
+          if (output.includes("Unsupported pixel format")) {
+            return;
+          }
+        });
+        ffmpeg.on("close", (code) => {
+          clearTimeout(timeout);
+          if (code === 0) {
+            resolve();
+          } else {
+            reject(new Error(`ffmpeg exited with code ${code}`));
+          }
+        });
+        ffmpeg.on("error", (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        });
+      });
+    }
+  };
+}
+
+// src/media/format-detector.ts
+var import_node_child_process4 = require("child_process");
+var import_node_util3 = require("util");
+var import_node_path12 = __toESM(require("path"), 1);
+var execFileAsync = (0, import_node_util3.promisify)(import_node_child_process4.execFile);
+var BROWSER_VIDEO_CONTAINERS = /* @__PURE__ */ new Set(["mp4", "webm", "ogg", "ogv"]);
+var BROWSER_VIDEO_CODECS = /* @__PURE__ */ new Set(["h264", "avc1", "vp8", "vp9", "theora", "av1"]);
+var BROWSER_AUDIO_CODECS = /* @__PURE__ */ new Set(["aac", "mp3", "opus", "vorbis", "flac"]);
+var BROWSER_AUDIO_CONTAINERS = /* @__PURE__ */ new Set(["mp3", "wav", "ogg", "oga", "webm", "m4a", "aac", "flac"]);
+var BROWSER_AUDIO_ONLY_CODECS = /* @__PURE__ */ new Set(["mp3", "aac", "opus", "vorbis", "flac", "pcm_s16le", "pcm_s24le"]);
+var REMUXABLE_VIDEO_CODECS = /* @__PURE__ */ new Set(["h264", "avc1", "hevc", "h265"]);
+var REMUXABLE_AUDIO_CODECS = /* @__PURE__ */ new Set(["aac", "alac"]);
+var VIDEO_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  "mp4",
+  "mkv",
+  "avi",
+  "mov",
+  "wmv",
+  "flv",
+  "webm",
+  "ogv",
+  "ogg",
+  "m4v",
+  "mpeg",
+  "mpg",
+  "3gp",
+  "ts",
+  "mts",
+  "m2ts",
+  "vob",
+  "rmvb",
+  "rm"
+]);
+var AUDIO_EXTENSIONS = /* @__PURE__ */ new Set([
+  "mp3",
+  "wav",
+  "flac",
+  "aac",
+  "m4a",
+  "ogg",
+  "oga",
+  "wma",
+  "ape",
+  "alac",
+  "aiff",
+  "aif",
+  "opus",
+  "mid",
+  "midi",
+  "wv",
+  "mka"
+]);
+function getMediaTypeByExtension(filePath) {
+  const ext = import_node_path12.default.extname(filePath).toLowerCase().slice(1);
+  if (VIDEO_EXTENSIONS2.has(ext)) return "video";
+  if (AUDIO_EXTENSIONS.has(ext)) return "audio";
+  return null;
+}
+async function getMediaFormat(filePath, ffprobePath) {
+  try {
+    const { stdout } = await execFileAsync(ffprobePath, [
+      "-v",
+      "quiet",
+      "-print_format",
+      "json",
+      "-show_format",
+      "-show_streams",
+      filePath
+    ]);
+    const data = JSON.parse(stdout);
+    const format = data.format || {};
+    const streams = data.streams || [];
+    const videoStream = streams.find((s) => s.codec_type === "video");
+    const audioStream = streams.find((s) => s.codec_type === "audio");
+    const type = videoStream ? "video" : "audio";
+    const formatName = format.format_name || "";
+    const container = formatName.split(",")[0].toLowerCase();
+    return {
+      type,
+      container,
+      videoCodec: videoStream?.codec_name?.toLowerCase(),
+      audioCodec: audioStream?.codec_name?.toLowerCase(),
+      duration: parseFloat(format.duration) || void 0,
+      width: videoStream?.width,
+      height: videoStream?.height,
+      bitrate: parseInt(format.bit_rate) || void 0
+    };
+  } catch {
+    const type = getMediaTypeByExtension(filePath);
+    if (!type) return null;
+    const ext = import_node_path12.default.extname(filePath).toLowerCase().slice(1);
+    return {
+      type,
+      container: ext
+    };
+  }
+}
+function canPlayVideoDirectly(format) {
+  if (!BROWSER_VIDEO_CONTAINERS.has(format.container)) {
+    return false;
+  }
+  if (format.videoCodec && !BROWSER_VIDEO_CODECS.has(format.videoCodec)) {
+    return false;
+  }
+  if (format.audioCodec && !BROWSER_AUDIO_CODECS.has(format.audioCodec)) {
+    return false;
+  }
+  return true;
+}
+function canPlayAudioDirectly(format) {
+  if (!BROWSER_AUDIO_CONTAINERS.has(format.container)) {
+    return false;
+  }
+  if (format.audioCodec && !BROWSER_AUDIO_ONLY_CODECS.has(format.audioCodec)) {
+    return false;
+  }
+  return true;
+}
+function canRemuxVideo(format) {
+  if (!format.videoCodec || !REMUXABLE_VIDEO_CODECS.has(format.videoCodec)) {
+    return false;
+  }
+  if (format.audioCodec) {
+    const audioOk = BROWSER_AUDIO_CODECS.has(format.audioCodec) || REMUXABLE_AUDIO_CODECS.has(format.audioCodec);
+    if (!audioOk) {
+      return false;
+    }
+  }
+  return true;
+}
+function canRemuxAudio(format) {
+  return format.audioCodec ? REMUXABLE_AUDIO_CODECS.has(format.audioCodec) : false;
+}
+function estimateTranscodeTime(duration, method) {
+  if (!duration || method === "direct") return void 0;
+  if (method === "remux") {
+    return Math.ceil(duration / 50);
+  }
+  return Math.ceil(duration / 3);
+}
+async function detectTranscodeNeeds(filePath, ffprobePath) {
+  const formatInfo = await getMediaFormat(filePath, ffprobePath);
+  if (!formatInfo) {
+    const type2 = getMediaTypeByExtension(filePath) || "video";
+    return {
+      type: type2,
+      needsTranscode: false,
+      method: "direct"
+    };
+  }
+  const { type } = formatInfo;
+  if (type === "video") {
+    if (canPlayVideoDirectly(formatInfo)) {
+      return {
+        type,
+        needsTranscode: false,
+        method: "direct",
+        formatInfo
+      };
+    }
+    if (canRemuxVideo(formatInfo)) {
+      return {
+        type,
+        needsTranscode: true,
+        method: "remux",
+        formatInfo,
+        targetFormat: "mp4",
+        estimatedTime: estimateTranscodeTime(formatInfo.duration, "remux")
+      };
     }
+    return {
+      type,
+      needsTranscode: true,
+      method: "transcode",
+      formatInfo,
+      targetFormat: "mp4",
+      estimatedTime: estimateTranscodeTime(formatInfo.duration, "transcode")
+    };
+  }
+  if (canPlayAudioDirectly(formatInfo)) {
+    return {
+      type,
+      needsTranscode: false,
+      method: "direct",
+      formatInfo
+    };
+  }
+  if (canRemuxAudio(formatInfo)) {
+    return {
+      type,
+      needsTranscode: true,
+      method: "remux",
+      formatInfo,
+      targetFormat: "m4a",
+      estimatedTime: estimateTranscodeTime(formatInfo.duration, "remux")
+    };
+  }
+  return {
+    type,
+    needsTranscode: true,
+    method: "transcode",
+    formatInfo,
+    targetFormat: "mp3",
+    estimatedTime: estimateTranscodeTime(formatInfo.duration, "transcode")
+  };
+}
+
+// src/media/transcoder.ts
+var import_node_child_process5 = require("child_process");
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+async function getTempOutputPath(sourceFile, targetFormat, tempDir) {
+  const dir = tempDir || import_node_path13.default.join(import_node_os3.default.tmpdir(), "file-explorer-media");
+  await import_promises3.default.mkdir(dir, { recursive: true });
+  const baseName = import_node_path13.default.basename(sourceFile, import_node_path13.default.extname(sourceFile));
+  const timestamp = Date.now();
+  const outputName = `${baseName}_${timestamp}.${targetFormat}`;
+  return import_node_path13.default.join(dir, outputName);
+}
+function parseProgress(stderr, duration) {
+  const timeMatch = stderr.match(/time=(\d+):(\d+):(\d+)\.(\d+)/);
+  if (!timeMatch) return null;
+  const hours = parseInt(timeMatch[1]);
+  const minutes = parseInt(timeMatch[2]);
+  const seconds = parseInt(timeMatch[3]);
+  const ms = parseInt(timeMatch[4]);
+  const currentTime = hours * 3600 + minutes * 60 + seconds + ms / 100;
+  const speedMatch = stderr.match(/speed=\s*([\d.]+)x/);
+  const speed = speedMatch ? `${speedMatch[1]}x` : void 0;
+  let percent = 0;
+  if (duration && duration > 0) {
+    percent = Math.min(100, Math.round(currentTime / duration * 100));
+  }
+  return {
+    percent,
+    time: currentTime,
+    duration,
+    speed
   };
 }
+async function remuxVideo(ffmpegPath, inputPath, outputPath, duration, onProgress) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-i",
+      inputPath,
+      "-c",
+      "copy",
+      // 复制流，不重新编码
+      "-movflags",
+      "+faststart",
+      // 优化 MP4 播放
+      "-y",
+      // 覆盖输出文件
+      outputPath
+    ];
+    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
+    let stderrBuffer = "";
+    ffmpeg.stderr.on("data", (data) => {
+      stderrBuffer += data.toString();
+      if (onProgress) {
+        const progress = parseProgress(stderrBuffer, duration);
+        if (progress) {
+          onProgress(progress);
+        }
+      }
+    });
+    ffmpeg.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`ffmpeg exited with code ${code}`));
+      }
+    });
+    ffmpeg.on("error", reject);
+  });
+}
+async function transcodeVideo(ffmpegPath, inputPath, outputPath, duration, onProgress) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-i",
+      inputPath,
+      "-c:v",
+      "libx264",
+      // H.264 编码
+      "-preset",
+      "fast",
+      // 编码速度预设
+      "-crf",
+      "23",
+      // 质量（18-28，越小越好）
+      "-c:a",
+      "aac",
+      // AAC 音频
+      "-b:a",
+      "192k",
+      // 音频比特率
+      "-movflags",
+      "+faststart",
+      "-y",
+      outputPath
+    ];
+    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
+    let stderrBuffer = "";
+    ffmpeg.stderr.on("data", (data) => {
+      stderrBuffer += data.toString();
+      if (onProgress) {
+        const progress = parseProgress(stderrBuffer, duration);
+        if (progress) {
+          onProgress(progress);
+        }
+      }
+    });
+    ffmpeg.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`ffmpeg exited with code ${code}`));
+      }
+    });
+    ffmpeg.on("error", reject);
+  });
+}
+async function remuxAudio(ffmpegPath, inputPath, outputPath, duration, onProgress) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-i",
+      inputPath,
+      "-c",
+      "copy",
+      "-y",
+      outputPath
+    ];
+    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
+    let stderrBuffer = "";
+    ffmpeg.stderr.on("data", (data) => {
+      stderrBuffer += data.toString();
+      if (onProgress) {
+        const progress = parseProgress(stderrBuffer, duration);
+        if (progress) {
+          onProgress(progress);
+        }
+      }
+    });
+    ffmpeg.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`ffmpeg exited with code ${code}`));
+      }
+    });
+    ffmpeg.on("error", reject);
+  });
+}
+async function transcodeAudio(ffmpegPath, inputPath, outputPath, duration, onProgress) {
+  return new Promise((resolve, reject) => {
+    const ext = import_node_path13.default.extname(outputPath).toLowerCase();
+    const isM4a = ext === ".m4a";
+    const args = [
+      "-i",
+      inputPath,
+      "-c:a",
+      isM4a ? "aac" : "libmp3lame",
+      "-b:a",
+      "192k",
+      "-y",
+      outputPath
+    ];
+    const ffmpeg = (0, import_node_child_process5.spawn)(ffmpegPath, args);
+    let stderrBuffer = "";
+    ffmpeg.stderr.on("data", (data) => {
+      stderrBuffer += data.toString();
+      if (onProgress) {
+        const progress = parseProgress(stderrBuffer, duration);
+        if (progress) {
+          onProgress(progress);
+        }
+      }
+    });
+    ffmpeg.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`ffmpeg exited with code ${code}`));
+      }
+    });
+    ffmpeg.on("error", reject);
+  });
+}
+async function transcodeMedia(ffmpegPath, inputPath, transcodeInfo, tempDir, onProgress) {
+  try {
+    if (!transcodeInfo.needsTranscode) {
+      return {
+        success: true,
+        outputPath: inputPath
+      };
+    }
+    const targetFormat = transcodeInfo.targetFormat || (transcodeInfo.type === "video" ? "mp4" : "mp3");
+    const outputPath = await getTempOutputPath(inputPath, targetFormat, tempDir);
+    const duration = transcodeInfo.formatInfo?.duration;
+    if (transcodeInfo.type === "video") {
+      if (transcodeInfo.method === "remux") {
+        await remuxVideo(ffmpegPath, inputPath, outputPath, duration, onProgress);
+      } else {
+        await transcodeVideo(ffmpegPath, inputPath, outputPath, duration, onProgress);
+      }
+    } else {
+      if (transcodeInfo.method === "remux") {
+        await remuxAudio(ffmpegPath, inputPath, outputPath, duration, onProgress);
+      } else {
+        await transcodeAudio(ffmpegPath, inputPath, outputPath, duration, onProgress);
+      }
+    }
+    if (onProgress) {
+      onProgress({ percent: 100, duration });
+    }
+    return {
+      success: true,
+      outputPath
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function cleanupTranscodedFile(filePath) {
+  try {
+    if (filePath.includes("file-explorer-media")) {
+      await import_promises3.default.unlink(filePath);
+    }
+  } catch {
+  }
+}
+async function cleanupAllTranscodedFiles(tempDir) {
+  const dir = tempDir || import_node_path13.default.join(import_node_os3.default.tmpdir(), "file-explorer-media");
+  try {
+    const files = await import_promises3.default.readdir(dir);
+    await Promise.all(
+      files.map((file) => import_promises3.default.unlink(import_node_path13.default.join(dir, file)).catch(() => {
+      }))
+    );
+  } catch {
+  }
+}
+
+// src/media/service.ts
+var import_node_path14 = __toESM(require("path"), 1);
+var import_node_child_process6 = require("child_process");
+var import_node_util4 = require("util");
+var execFileAsync2 = (0, import_node_util4.promisify)(import_node_child_process6.execFile);
+var mediaServiceInstance = null;
+var MediaService = class {
+  ffmpegPath;
+  ffprobePath;
+  tempDir;
+  urlEncoder;
+  // 缓存转码信息，避免重复检测
+  transcodeInfoCache = /* @__PURE__ */ new Map();
+  // 缓存已转码文件路径
+  transcodedFiles = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.ffmpegPath = options.ffmpegPath;
+    this.ffprobePath = options.ffprobePath || import_node_path14.default.join(import_node_path14.default.dirname(options.ffmpegPath), "ffprobe");
+    this.tempDir = options.tempDir;
+    this.urlEncoder = options.urlEncoder;
+  }
+  /**
+   * 检测文件是否需要转码
+   */
+  async needsTranscode(filePath) {
+    const cached = this.transcodeInfoCache.get(filePath);
+    if (cached) {
+      return cached;
+    }
+    const info = await detectTranscodeNeeds(filePath, this.ffprobePath);
+    this.transcodeInfoCache.set(filePath, info);
+    return info;
+  }
+  /**
+   * 执行转码并返回可播放的 URL
+   */
+  async transcode(filePath, onProgress) {
+    const existingOutput = this.transcodedFiles.get(filePath);
+    if (existingOutput) {
+      return {
+        success: true,
+        outputPath: existingOutput,
+        url: this.urlEncoder ? this.urlEncoder(existingOutput) : `file://${existingOutput}`
+      };
+    }
+    const transcodeInfo = await this.needsTranscode(filePath);
+    if (!transcodeInfo.needsTranscode) {
+      const url = this.urlEncoder ? this.urlEncoder(filePath) : `file://${filePath}`;
+      return {
+        success: true,
+        outputPath: filePath,
+        url
+      };
+    }
+    const result = await transcodeMedia(
+      this.ffmpegPath,
+      filePath,
+      transcodeInfo,
+      this.tempDir,
+      onProgress
+    );
+    if (result.success && result.outputPath) {
+      this.transcodedFiles.set(filePath, result.outputPath);
+      result.url = this.urlEncoder ? this.urlEncoder(result.outputPath) : `file://${result.outputPath}`;
+    }
+    return result;
+  }
+  /**
+   * 获取媒体元数据
+   */
+  async getMetadata(filePath) {
+    try {
+      const { stdout } = await execFileAsync2(this.ffprobePath, [
+        "-v",
+        "quiet",
+        "-print_format",
+        "json",
+        "-show_format",
+        "-show_streams",
+        filePath
+      ]);
+      const data = JSON.parse(stdout);
+      const format = data.format || {};
+      const tags = format.tags || {};
+      const formatInfo = await getMediaFormat(filePath, this.ffprobePath);
+      if (!formatInfo) return null;
+      return {
+        filePath,
+        type: formatInfo.type,
+        duration: parseFloat(format.duration) || 0,
+        format: formatInfo,
+        title: tags.title || tags.TITLE,
+        artist: tags.artist || tags.ARTIST,
+        album: tags.album || tags.ALBUM,
+        year: tags.date || tags.DATE || tags.year || tags.YEAR
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 获取可播放的 URL
+   * 如果文件需要转码，则执行转码；否则直接返回文件 URL
+   */
+  async getPlayableUrl(filePath, onProgress) {
+    const result = await this.transcode(filePath, onProgress);
+    return result.success ? result.url || null : null;
+  }
+  /**
+   * 清理指定文件的转码缓存
+   */
+  async cleanupFile(filePath) {
+    const transcodedPath = this.transcodedFiles.get(filePath);
+    if (transcodedPath) {
+      await cleanupTranscodedFile(transcodedPath);
+      this.transcodedFiles.delete(filePath);
+    }
+    this.transcodeInfoCache.delete(filePath);
+  }
+  /**
+   * 清理所有转码缓存
+   */
+  async cleanup() {
+    await cleanupAllTranscodedFiles(this.tempDir);
+    this.transcodedFiles.clear();
+    this.transcodeInfoCache.clear();
+  }
+  /**
+   * 清除缓存（不删除文件）
+   */
+  clearCache() {
+    this.transcodeInfoCache.clear();
+  }
+};
+function initMediaService(options) {
+  mediaServiceInstance = new MediaService(options);
+  return mediaServiceInstance;
+}
+function getMediaService() {
+  return mediaServiceInstance;
+}
+function createMediaService(options) {
+  return new MediaService(options);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   APP_PROTOCOL_HOST,
   APP_PROTOCOL_PREFIX,
   APP_PROTOCOL_SCHEME,
   FileType,
+  MediaService,
   SqliteThumbnailDatabase,
   ThumbnailService,
+  WatchManager,
+  cleanupAllTranscodedFiles,
+  cleanupTranscodedFile,
+  closeThumbnailDatabase,
+  compressFiles,
   copyFiles,
   copyFilesToClipboard,
   createFfmpegVideoProcessor,
   createFile,
   createFolder,
+  createMediaService,
   createSharpImageProcessor,
   createSqliteThumbnailDatabase,
   decodeFileUrl,
   deleteFiles,
+  detectArchiveFormat,
+  detectTranscodeNeeds,
   encodeFileUrl,
   exists,
+  extractArchive,
   formatDate,
   formatDateTime,
   formatFileSize,
@@ -1278,28 +2542,39 @@ function createFfmpegVideoProcessor(ffmpegPath) {
   getApplicationIcon,
   getClipboardFiles,
   getFileHash,
-  getFileHashes,
   getFileInfo,
   getFileType,
   getHomeDirectory,
+  getMediaFormat,
+  getMediaService,
+  getMediaTypeByExtension,
   getPlatform,
   getSqliteThumbnailDatabase,
   getSystemPath,
   getThumbnailService,
+  getWatchManager,
+  initMediaService,
   initThumbnailService,
   isAppProtocolUrl,
+  isArchiveFile,
   isDirectory,
   isMediaFile,
   isPreviewable,
   moveFiles,
+  openInEditor,
+  openInTerminal,
   pasteFiles,
   readDirectory,
   readFileContent,
   readImageAsBase64,
   renameFile,
+  revealInFileManager,
   searchFiles,
   searchFilesStream,
   searchFilesSync,
+  showFileInfo,
+  transcodeMedia,
+  watchDirectory,
   writeFileContent
 });
 //# sourceMappingURL=index.cjs.map