@huyooo/file-explorer-core 0.3.0 → 0.4.2

package/dist/index.js

@@ -25,22 +25,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) {
@@ -388,16 +388,16 @@ async function createFile(filePath, content = "") {
       await fs2.writeFile(filePath, content, "utf-8");
       return { success: true, data: { finalPath: filePath } };
     }
-    const dirname = path3.dirname(filePath);
+    const dirname3 = path3.dirname(filePath);
     const ext = path3.extname(filePath);
-    const basename = path3.basename(filePath, ext);
+    const basename2 = path3.basename(filePath, ext);
     let counter = 2;
-    let finalPath = path3.join(dirname, `${basename} ${counter}${ext}`);
+    let finalPath = path3.join(dirname3, `${basename2} ${counter}${ext}`);
     while (true) {
       try {
         await fs2.access(finalPath);
         counter++;
-        finalPath = path3.join(dirname, `${basename} ${counter}${ext}`);
+        finalPath = path3.join(dirname3, `${basename2} ${counter}${ext}`);
       } catch {
         break;
       }
@@ -573,25 +573,487 @@ async function isDirectory(filePath) {
   }
 }
 
+// src/operations/shell.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as path6 from "path";
+var execAsync = promisify(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
+import * as compressing from "compressing";
+import * as path7 from "path";
+import * as fs7 from "fs";
+import { promises as fsPromises } from "fs";
+import { pipeline } from "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 fsPromises.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 fsPromises.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 fsPromises.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 fsPromises.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 pipeline(stream, destStream);
+        break;
+      }
+      case "tar": {
+        const stream = new compressing.tar.Stream();
+        for (const source of sources) {
+          const stats = await fsPromises.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 pipeline(stream, destStream);
+        break;
+      }
+      case "tgz": {
+        const stream = new compressing.tgz.Stream();
+        for (const source of sources) {
+          const stats = await fsPromises.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 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 fsPromises.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 pipeline(tgzStream, destStream);
+        break;
+      }
+    }
+    if (deleteSource) {
+      for (const source of sources) {
+        const stats = await fsPromises.stat(source);
+        if (stats.isDirectory()) {
+          await fsPromises.rm(source, { recursive: true });
+        } else {
+          await fsPromises.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 fsPromises.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 fsPromises.unlink(archivePath);
+    }
+    return { success: true, outputPath: targetDir };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
 // src/system-paths.ts
-import path6 from "path";
+import path8 from "path";
 import os from "os";
 var platform = process.platform;
 function getSystemPath(pathId) {
   const homeDir = os.homedir();
   switch (pathId) {
     case "desktop":
-      return path6.join(homeDir, "Desktop");
+      return path8.join(homeDir, "Desktop");
     case "documents":
-      return path6.join(homeDir, "Documents");
+      return path8.join(homeDir, "Documents");
     case "downloads":
-      return path6.join(homeDir, "Downloads");
+      return path8.join(homeDir, "Downloads");
     case "pictures":
-      return path6.join(homeDir, "Pictures");
+      return path8.join(homeDir, "Pictures");
     case "music":
-      return path6.join(homeDir, "Music");
+      return path8.join(homeDir, "Music");
     case "videos":
-      return platform === "darwin" ? path6.join(homeDir, "Movies") : path6.join(homeDir, "Videos");
+      return platform === "darwin" ? path8.join(homeDir, "Movies") : path8.join(homeDir, "Videos");
     case "applications":
       return platform === "darwin" ? "/Applications" : platform === "win32" ? process.env.ProgramFiles || "C:\\Program Files" : "/usr/share/applications";
     case "home":
@@ -623,14 +1085,14 @@ function getAllSystemPaths() {
 function getHomeDirectory() {
   return os.homedir();
 }
-function getPlatform() {
+function getPlatform2() {
   return process.platform;
 }
 
 // src/search.ts
 import { fdir } from "fdir";
-import path7 from "path";
-import { promises as fs7 } from "fs";
+import path9 from "path";
+import { promises as fs8 } from "fs";
 function patternToRegex(pattern) {
   return new RegExp(pattern.replace(/\*/g, ".*"), "i");
 }
@@ -643,7 +1105,7 @@ async function searchFiles(searchPath, pattern, maxDepth) {
   const files = await api.withPromise();
   if (pattern) {
     const regex = patternToRegex(pattern);
-    return files.filter((file) => regex.test(path7.basename(file)));
+    return files.filter((file) => regex.test(path9.basename(file)));
   }
   return files;
 }
@@ -654,12 +1116,12 @@ async function searchFilesStream(searchPath, pattern, onResults, maxResults = 10
   async function searchDir(dirPath) {
     if (stopped) return;
     try {
-      const entries = await fs7.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs8.readdir(dirPath, { withFileTypes: true });
       const matched = [];
       const subdirs = [];
       for (const entry of entries) {
         if (stopped) return;
-        const fullPath = path7.join(dirPath, entry.name);
+        const fullPath = path9.join(dirPath, entry.name);
         if (regex.test(entry.name)) {
           matched.push(fullPath);
           results.push(fullPath);
@@ -696,44 +1158,29 @@ function searchFilesSync(searchPath, pattern, maxDepth) {
   const files = api.sync();
   if (pattern) {
     const regex = new RegExp(pattern.replace(/\*/g, ".*"), "i");
-    return files.filter((file) => regex.test(path7.basename(file)));
+    return files.filter((file) => regex.test(path9.basename(file)));
   }
   return files;
 }
 
 // src/hash.ts
-import { createHash } from "crypto";
+import { xxhash64 } from "hash-wasm";
 import { stat } from "fs/promises";
-async function getFileHash(filePath) {
-  try {
-    const stats = await stat(filePath);
-    const hashInput = `${filePath}:${stats.size}:${stats.mtime.getTime()}`;
-    return createHash("md5").update(hashInput).digest("hex");
-  } catch (error) {
-    console.error(`Error computing hash for ${filePath}:`, error);
-    return 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;
+async function getFileHash(filePath, stats) {
+  const fileStats = stats || await stat(filePath);
+  const hashInput = `${filePath}:${fileStats.size}:${fileStats.mtime.getTime()}`;
+  return await xxhash64(hashInput);
 }
 
 // src/clipboard.ts
-import { promises as fs8 } from "fs";
-import path8 from "path";
+import { promises as fs9 } from "fs";
+import path10 from "path";
 async function copyFilesToClipboard(filePaths, clipboard) {
   try {
     const cleanPaths = [];
     for (const p of filePaths) {
       try {
-        await fs8.access(p);
+        await fs9.access(p);
         cleanPaths.push(p);
       } catch {
       }
@@ -768,24 +1215,24 @@ async function pasteFiles(targetDir, sourcePaths) {
     }
     const pastedPaths = [];
     for (const sourcePath of sourcePaths) {
-      const fileName = path8.basename(sourcePath);
-      let destPath = path8.join(targetDir, fileName);
+      const fileName = path10.basename(sourcePath);
+      let destPath = path10.join(targetDir, fileName);
       let counter = 1;
       while (true) {
         try {
-          await fs8.access(destPath);
-          const ext = path8.extname(fileName);
-          const baseName = path8.basename(fileName, ext);
-          destPath = path8.join(targetDir, `${baseName} ${++counter}${ext}`);
+          await fs9.access(destPath);
+          const ext = path10.extname(fileName);
+          const baseName = path10.basename(fileName, ext);
+          destPath = path10.join(targetDir, `${baseName} ${++counter}${ext}`);
         } catch {
           break;
         }
       }
-      const stats = await fs8.stat(sourcePath);
+      const stats = await fs9.stat(sourcePath);
       if (stats.isDirectory()) {
         await copyDirectory2(sourcePath, destPath);
       } else {
-        await fs8.copyFile(sourcePath, destPath);
+        await fs9.copyFile(sourcePath, destPath);
       }
       pastedPaths.push(destPath);
     }
@@ -795,28 +1242,28 @@ async function pasteFiles(targetDir, sourcePaths) {
   }
 }
 async function copyDirectory2(source, dest) {
-  await fs8.mkdir(dest, { recursive: true });
-  const entries = await fs8.readdir(source, { withFileTypes: true });
+  await fs9.mkdir(dest, { recursive: true });
+  const entries = await fs9.readdir(source, { withFileTypes: true });
   for (const entry of entries) {
-    const sourcePath = path8.join(source, entry.name);
-    const destPath = path8.join(dest, entry.name);
+    const sourcePath = path10.join(source, entry.name);
+    const destPath = path10.join(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDirectory2(sourcePath, destPath);
     } else {
-      await fs8.copyFile(sourcePath, destPath);
+      await fs9.copyFile(sourcePath, destPath);
     }
   }
 }
 
 // src/application-icon.ts
-import { promises as fs9 } from "fs";
-import path9 from "path";
+import { promises as fs10 } from "fs";
+import path11 from "path";
 import os2 from "os";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
 async function findAppIconPath(appPath) {
-  const resourcesPath = path9.join(appPath, "Contents", "Resources");
+  const resourcesPath = path11.join(appPath, "Contents", "Resources");
   try {
     const commonIconNames = [
       "AppIcon.icns",
@@ -824,18 +1271,18 @@ async function findAppIconPath(appPath) {
       "application.icns",
       "icon.icns"
     ];
-    const infoPlistPath = path9.join(appPath, "Contents", "Info.plist");
+    const infoPlistPath = path11.join(appPath, "Contents", "Info.plist");
     try {
-      const infoPlistContent = await fs9.readFile(infoPlistPath, "utf-8");
+      const infoPlistContent = await fs10.readFile(infoPlistPath, "utf-8");
       const iconFileMatch = infoPlistContent.match(/<key>CFBundleIconFile<\/key>\s*<string>([^<]+)<\/string>/);
       if (iconFileMatch && iconFileMatch[1]) {
         let iconFileName = iconFileMatch[1].trim();
         if (!iconFileName.endsWith(".icns")) {
           iconFileName += ".icns";
         }
-        const iconPath = path9.join(resourcesPath, iconFileName);
+        const iconPath = path11.join(resourcesPath, iconFileName);
         try {
-          await fs9.access(iconPath);
+          await fs10.access(iconPath);
           return iconPath;
         } catch {
         }
@@ -843,19 +1290,19 @@ async function findAppIconPath(appPath) {
     } catch {
     }
     for (const iconName of commonIconNames) {
-      const iconPath = path9.join(resourcesPath, iconName);
+      const iconPath = path11.join(resourcesPath, iconName);
       try {
-        await fs9.access(iconPath);
+        await fs10.access(iconPath);
         return iconPath;
       } catch {
         continue;
       }
     }
     try {
-      const entries = await fs9.readdir(resourcesPath);
+      const entries = await fs10.readdir(resourcesPath);
       const icnsFile = entries.find((entry) => entry.toLowerCase().endsWith(".icns"));
       if (icnsFile) {
-        return path9.join(resourcesPath, icnsFile);
+        return path11.join(resourcesPath, icnsFile);
       }
     } catch {
     }
@@ -869,7 +1316,7 @@ async function getApplicationIcon(appPath) {
     return null;
   }
   try {
-    const stats = await fs9.stat(appPath);
+    const stats = await fs10.stat(appPath);
     if (!stats.isDirectory() || !appPath.endsWith(".app")) {
       return null;
     }
@@ -881,13 +1328,13 @@ async function getApplicationIcon(appPath) {
     return null;
   }
   try {
-    const tempPngPath = path9.join(os2.tmpdir(), `app-icon-${Date.now()}.png`);
-    await execAsync(
+    const tempPngPath = path11.join(os2.tmpdir(), `app-icon-${Date.now()}.png`);
+    await execAsync2(
       `sips -s format png "${iconPath}" --out "${tempPngPath}" --resampleHeightWidthMax 128`
     );
-    const pngBuffer = await fs9.readFile(tempPngPath);
+    const pngBuffer = await fs10.readFile(tempPngPath);
     try {
-      await fs9.unlink(tempPngPath);
+      await fs10.unlink(tempPngPath);
     } catch {
     }
     const base64 = pngBuffer.toString("base64");
@@ -897,11 +1344,150 @@ async function getApplicationIcon(appPath) {
   }
 }
 
+// src/watch.ts
+import * as fs11 from "fs";
+import * as path12 from "path";
+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
-import { promises as fs10 } from "fs";
-import path10 from "path";
-var IMAGE_EXTENSIONS2 = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"];
-var VIDEO_EXTENSIONS2 = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".wmv"];
+import { promises as fs12 } from "fs";
+import path13 from "path";
+function isImageFile(filePath, fileType) {
+  return fileType === "image" /* IMAGE */;
+}
+function isVideoFile(filePath, fileType) {
+  return fileType === "video" /* VIDEO */;
+}
 var ThumbnailService = class {
   database;
   imageProcessor;
@@ -920,7 +1506,7 @@ var ThumbnailService = class {
    */
   async getCachedThumbnailUrl(filePath) {
     try {
-      const stats = await fs10.stat(filePath);
+      const stats = await fs12.stat(filePath);
       const fileType = getFileType(filePath, stats);
       if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
         return await this.getApplicationIcon(filePath);
@@ -933,7 +1519,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(() => {
@@ -948,7 +1534,7 @@ var ThumbnailService = class {
    */
   async getThumbnailUrl(filePath) {
     try {
-      const stats = await fs10.stat(filePath);
+      const stats = await fs12.stat(filePath);
       const fileType = getFileType(filePath, stats);
       if (fileType === "application" /* APPLICATION */ && this.getApplicationIcon) {
         return await this.getApplicationIcon(filePath);
@@ -961,7 +1547,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);
@@ -981,13 +1567,14 @@ var ThumbnailService = class {
       return cachedPath;
     }
     try {
-      const ext = path10.extname(filePath).toLowerCase();
+      const stats = await fs12.stat(filePath);
+      const fileType = getFileType(filePath, stats);
       const hashPrefix = fileHash.substring(0, 16);
       const thumbnailFileName = `${hashPrefix}.jpg`;
-      const thumbnailPath = path10.join(this.database.getCacheDir(), thumbnailFileName);
-      if (IMAGE_EXTENSIONS2.includes(ext) && this.imageProcessor) {
+      const thumbnailPath = path13.join(this.database.getCacheDir(), thumbnailFileName);
+      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;
@@ -1000,12 +1587,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));
+    }
   }
   /**
    * 删除缩略图
@@ -1031,13 +1626,18 @@ function getThumbnailService() {
 
 // src/thumbnail/database.ts
 import Database from "better-sqlite3";
-import path11 from "path";
+import path14 from "path";
 import { existsSync, mkdirSync } from "fs";
 var SqliteThumbnailDatabase = class {
   db = null;
   cacheDir;
-  constructor(userDataPath) {
-    this.cacheDir = path11.join(userDataPath, "cache");
+  dbPath;
+  constructor(userDataPath, options = {}) {
+    const defaultDirName = options.dirName || "thumbnails";
+    const defaultDbFileName = options.dbFileName || "thumbnails.db";
+    const inferredDirFromDbPath = options.dbPath ? path14.dirname(options.dbPath) : null;
+    this.cacheDir = options.thumbnailDir ? options.thumbnailDir : inferredDirFromDbPath || path14.join(userDataPath, defaultDirName);
+    this.dbPath = options.dbPath ? options.dbPath : path14.join(this.cacheDir, defaultDbFileName);
     if (!existsSync(this.cacheDir)) {
       mkdirSync(this.cacheDir, { recursive: true });
     }
@@ -1047,8 +1647,7 @@ var SqliteThumbnailDatabase = class {
    */
   init() {
     if (this.db) return;
-    const dbPath = path11.join(this.cacheDir, "thumbnails.db");
-    this.db = new Database(dbPath, {
+    this.db = new Database(this.dbPath, {
       fileMustExist: false
     });
     this.db.pragma("journal_mode = WAL");
@@ -1120,15 +1719,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;
@@ -1136,58 +1739,698 @@ function createSqliteThumbnailDatabase(userDataPath) {
 function getSqliteThumbnailDatabase() {
   return thumbnailDb;
 }
+function closeThumbnailDatabase() {
+  if (thumbnailDb) {
+    thumbnailDb.close();
+    thumbnailDb = null;
+  }
+}
 
 // src/thumbnail/processors.ts
-import { execFile } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync = promisify2(execFile);
+import { spawn } from "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 = 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
+import { execFile } from "child_process";
+import { promisify as promisify3 } from "util";
+import path15 from "path";
+var execFileAsync = promisify3(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 = path15.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 = path15.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
+import { spawn as spawn2 } from "child_process";
+import fs13 from "fs/promises";
+import path16 from "path";
+import os3 from "os";
+async function getTempOutputPath(sourceFile, targetFormat, tempDir) {
+  const dir = tempDir || path16.join(os3.tmpdir(), "file-explorer-media");
+  await fs13.mkdir(dir, { recursive: true });
+  const baseName = path16.basename(sourceFile, path16.extname(sourceFile));
+  const timestamp = Date.now();
+  const outputName = `${baseName}_${timestamp}.${targetFormat}`;
+  return path16.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 = spawn2(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 = spawn2(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 = spawn2(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 = path16.extname(outputPath).toLowerCase();
+    const isM4a = ext === ".m4a";
+    const args = [
+      "-i",
+      inputPath,
+      "-c:a",
+      isM4a ? "aac" : "libmp3lame",
+      "-b:a",
+      "192k",
+      "-y",
+      outputPath
+    ];
+    const ffmpeg = spawn2(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 fs13.unlink(filePath);
+    }
+  } catch {
+  }
+}
+async function cleanupAllTranscodedFiles(tempDir) {
+  const dir = tempDir || path16.join(os3.tmpdir(), "file-explorer-media");
+  try {
+    const files = await fs13.readdir(dir);
+    await Promise.all(
+      files.map((file) => fs13.unlink(path16.join(dir, file)).catch(() => {
+      }))
+    );
+  } catch {
+  }
+}
+
+// src/media/service.ts
+import path17 from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFileAsync2 = promisify4(execFile2);
+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 || path17.join(path17.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);
+}
 export {
   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,
@@ -1195,28 +2438,39 @@ export {
   getApplicationIcon,
   getClipboardFiles,
   getFileHash,
-  getFileHashes,
   getFileInfo,
   getFileType,
   getHomeDirectory,
-  getPlatform,
+  getMediaFormat,
+  getMediaService,
+  getMediaTypeByExtension,
+  getPlatform2 as 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.js.map