minify-pic-cli 1.1.1 → 1.2.0-beta.2

package/index.js

@@ -1,13 +1,16 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 const fs = require("fs");
 const path = require("path");
 const sharp = require("sharp");
 const readline = require("readline");
 const { Command } = require("commander");
+const os = require("os");
+const WorkerPool = require("./lib/worker-pool");
+const ProgressDisplay = require("./lib/progress-display");
 
 // 默认配置参数
 const DEFAULT_CONFIG = {
-  targetDir: process.cwd(), // 需要压缩的目录(可包含子目录)
+  targetDirs: [process.cwd()], // 需要压缩的目录数组(可包含子目录)
   outputDir: path.join(process.cwd(), "output"), // 输出目录
   quality: 80, // 压缩质量 0 - 100
   gifColours: 128, // GIF调色板最大数量
@@ -15,20 +18,68 @@ const DEFAULT_CONFIG = {
 };
 
 // 询问用户是否继续
-function askUserToContinue() {
+function askUserToContinue(dirStats) {
   return new Promise((resolve) => {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
     });
-    console.log(`当前目录路径为: ${process.cwd()}`);
-    rl.question("是否需要压缩当前目录的所有图片？Y/N：", (answer) => {
+    
+    if (dirStats && dirStats.length > 0) {
+      console.log("\n检测到以下目录待压缩:");
+      dirStats.forEach((stat, index) => {
+        console.log(`  ${index + 1}. ${stat.dir} (${stat.count} 张图片)`);
+      });
+      const totalCount = dirStats.reduce((sum, stat) => sum + stat.count, 0);
+      console.log(`总计: ${dirStats.length} 个目录, ${totalCount} 张图片\n`);
+    } else {
+      console.log(`当前目录路径为: ${process.cwd()}`);
+    }
+    
+    rl.question("是否继续压缩? Y/N：", (answer) => {
       rl.close();
       resolve(answer.trim().toLowerCase() === "y");
     });
   });
 }
 
+// 验证目录有效性
+function validateDirectories(dirs) {
+  const validDirs = [];
+  const invalidDirs = [];
+
+  for (const dir of dirs) {
+    try {
+      if (!fs.existsSync(dir)) {
+        console.warn(`警告: 目录不存在,跳过: ${dir}`);
+        invalidDirs.push({ dir, reason: '目录不存在' });
+        continue;
+      }
+      
+      const stat = fs.statSync(dir);
+      if (!stat.isDirectory()) {
+        console.warn(`警告: 路径不是目录,跳过: ${dir}`);
+        invalidDirs.push({ dir, reason: '不是目录' });
+        continue;
+      }
+      
+      // 检查读取权限
+      try {
+        fs.accessSync(dir, fs.constants.R_OK);
+        validDirs.push(dir);
+      } catch (err) {
+        console.error(`错误: 目录无读取权限,跳过: ${dir}`);
+        invalidDirs.push({ dir, reason: '无读取权限' });
+      }
+    } catch (err) {
+      console.error(`错误: 验证目录失败,跳过: ${dir}`, err.message);
+      invalidDirs.push({ dir, reason: err.message });
+    }
+  }
+
+  return { validDirs, invalidDirs };
+}
+
 // 获取文件大小（带单位，自动转换MB/KB）
 function getFileSizeWithUnit(filePath) {
   const stats = fs.statSync(filePath);
@@ -46,7 +97,7 @@ function getFileSizeWithUnit(filePath) {
 }
 
 // 压缩单张图片
-async function compressImage(filePath, config, baseDir = config.targetDir) {
+async function compressImage(filePath, config, sourceDir) {
   const beforeSize = getFileSizeWithUnit(filePath);
   sharp.cache(false);
 
@@ -81,8 +132,10 @@ async function compressImage(filePath, config, baseDir = config.targetDir) {
     outputFileDir = path.dirname(outputFilePath);
   } else {
     // 保持目录结构输出到新目录
-    const relativePath = path.relative(baseDir, filePath);
-    outputFilePath = path.join(config.outputDir, relativePath);
+    // 多目录支持: 使用sourceDir的basename作为一级子目录
+    const relativePath = path.relative(sourceDir, filePath);
+    const sourceDirBasename = path.basename(sourceDir);
+    outputFilePath = path.join(config.outputDir, sourceDirBasename, relativePath);
     outputFileDir = path.dirname(outputFilePath);
   }
 
@@ -117,9 +170,10 @@ async function compressImage(filePath, config, baseDir = config.targetDir) {
   }
 }
 
-// 递归压缩目录下所有图片
-async function compressFiles(dir, config, baseDir = config.targetDir) {
+// 递归扫描目录，收集所有图片文件
+function collectImageFiles(dir, config, sourceDir) {
   const files = fs.readdirSync(dir);
+  const imageFiles = [];
 
   for (const file of files) {
     const filePath = path.join(dir, file);
@@ -133,13 +187,180 @@ async function compressFiles(dir, config, baseDir = config.targetDir) {
 
     if (stat.isDirectory()) {
       if (!config.blackDirs.includes(file)) {
-        await compressFiles(filePath, config, baseDir);
+        const subFiles = collectImageFiles(filePath, config, sourceDir);
+        imageFiles.push(...subFiles);
       } else {
         console.log(`跳过的目录: ${filePath}`);
       }
     } else if (/\.(png|jpe?g|gif)$/i.test(filePath)) {
-      await compressImage(filePath, config, baseDir);
+      imageFiles.push({
+        filePath,
+        size: stat.size,
+        sourceDir: sourceDir  // 记录所属源目录
+      });
+    }
+  }
+
+  return imageFiles;
+}
+
+// 收集多个目录的图片文件
+function collectImageFilesFromMultipleDirs(dirs, config) {
+  const allImageFiles = [];
+  const dirStats = [];
+
+  for (const dir of dirs) {
+    console.log(`正在扫描目录: ${dir}`);
+    
+    // 如果是非原地替换模式，跳过与输出目录相同的源目录
+    if (!config.replace && path.resolve(dir) === path.resolve(config.outputDir)) {
+      console.warn(`警告: 源目录与输出目录相同,跳过: ${dir}`);
+      continue;
+    }
+    
+    const imageFiles = collectImageFiles(dir, config, dir);
+    allImageFiles.push(...imageFiles);
+    dirStats.push({
+      dir: dir,
+      count: imageFiles.length
+    });
+    console.log(`  找到 ${imageFiles.length} 张图片`);
+  }
+
+  return { allImageFiles, dirStats };
+}
+
+// 递归压缩目录下所有图片（单进程模式）
+async function compressFiles(dir, config, sourceDir) {
+  const files = fs.readdirSync(dir);
+
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+
+    // 跳过 output 目录（非原地替换模式）
+    if (!config.replace && filePath === config.outputDir) {
+      console.log(`跳过的目录: ${filePath}（为输出目录）`);
+      continue;
+    }
+
+    if (stat.isDirectory()) {
+      if (!config.blackDirs.includes(file)) {
+        await compressFiles(filePath, config, sourceDir);
+      } else {
+        console.log(`跳过的目录: ${filePath}`);
+      }
+    } else if (/\.(png|jpe?g|gif)$/i.test(filePath)) {
+      await compressImage(filePath, config, sourceDir);
+    }
+  }
+}
+
+// 多进程压缩
+async function compressFilesParallel(imageFiles, config, setGlobalPool) {
+  const workerCount = WorkerPool.calculateWorkerCount(
+    imageFiles.length,
+    config.workers
+  );
+
+  // 如果计算结果是0或用户指定不使用并行，使用单进程模式
+  if (workerCount === 0 || config.noParallel) {
+    console.log(`使用单进程模式压缩 ${imageFiles.length} 张图片`);
+    const progress = new ProgressDisplay(imageFiles.length);
+    progress.setMultiProcess(false);
+    
+    const startTime = Date.now();
+    let completed = 0;
+    let failed = 0;
+    let totalBeforeSize = 0;
+    let totalAfterSize = 0;
+
+    for (const fileInfo of imageFiles) {
+      try {
+        const beforeSize = fileInfo.size;
+        await compressImage(fileInfo.filePath, config, fileInfo.sourceDir);
+        const afterSize = fs.statSync(
+          config.replace ? fileInfo.filePath : 
+          path.join(config.outputDir, path.basename(fileInfo.sourceDir), path.relative(fileInfo.sourceDir, fileInfo.filePath))
+        ).size;
+        
+        completed++;
+        totalBeforeSize += beforeSize;
+        totalAfterSize += afterSize;
+      } catch (error) {
+        failed++;
+        console.error(`压缩出错: ${fileInfo.filePath}`, error.message);
+      }
     }
+
+    const duration = (Date.now() - startTime) / 1000;
+    const speed = completed / duration;
+    const savedSize = totalBeforeSize - totalAfterSize;
+    const compressionRate = totalBeforeSize > 0 
+      ? ((savedSize / totalBeforeSize) * 100).toFixed(1) 
+      : 0;
+
+    progress.showReport({
+      total: imageFiles.length,
+      completed,
+      failed,
+      duration,
+      speed: speed.toFixed(1),
+      totalBeforeSize,
+      totalAfterSize,
+      savedSize,
+      compressionRate,
+      workerCount: 0,
+      failedTasks: []
+    });
+
+    return;
+  }
+
+  // 多进程模式
+  console.log(`检测到 ${imageFiles.length} 张图片需要压缩`);
+  console.log(`将使用 ${workerCount} 个进程并行处理以加快速度`);
+
+  const progress = new ProgressDisplay(imageFiles.length);
+  progress.setMultiProcess(true);
+
+  const pool = new WorkerPool({
+    quality: config.quality,
+    gifColours: config.gifColours,
+    outputDir: config.outputDir,
+    replace: config.replace,
+    onProgress: (data) => {
+      progress.update(data);
+    }
+  });
+  
+  // 设置全局引用，用于优雅退出
+  if (setGlobalPool) {
+    setGlobalPool(pool);
+  }
+
+  try {
+    await pool.initialize(workerCount);
+    pool.addTasks(imageFiles);
+    pool.start();
+    await pool.waitForCompletion();
+    
+    // 获取最终统计数据
+    const report = pool.getReport();
+    
+    // 更新并显示最终进度
+    progress.completed = report.completed;
+    progress.failed = report.failed;
+    progress.totalBeforeSize = report.totalBeforeSize;
+    progress.totalAfterSize = report.totalAfterSize;
+    progress.complete();
+
+    progress.showReport(report);
+  } catch (error) {
+    console.error("多进程压缩失败:", error);
+    throw error;
+  } finally {
+    await pool.shutdown();
   }
 }
 
@@ -149,46 +370,117 @@ const program = new Command();
 program
   .name("mpic")
   .description("图片批量压缩工具")
-  .option("-d, --dir <dir>", "需要压缩的目录", DEFAULT_CONFIG.targetDir)
+  .option("-d, --dir <dir>", "需要压缩的目录(逗号分隔多个目录)", val => val.split(",").map(d => d.trim()), DEFAULT_CONFIG.targetDirs)
   .option("-o, --output <output>", "输出目录", DEFAULT_CONFIG.outputDir)
   .option("-q, --quality <quality>", "压缩质量(0-100)", String(DEFAULT_CONFIG.quality))
   .option("-g, --gif-colours <colours>", "GIF调色板最大数量(2-256)", String(DEFAULT_CONFIG.gifColours))
   .option("-b, --black-dirs <dirs>", "排除的子文件夹名称(逗号分隔)", val => val.split(","), DEFAULT_CONFIG.blackDirs)
   .option("-y, --yes", "跳过确认，直接开始压缩")
   .option("-r, --replace", "原地压缩替换原文件，不输出到新目录")
+  .option("-w, --workers <num>", "指定并发工作进程数")
+  .option("--no-parallel", "禁用多进程，使用单进程模式")
   .version(require('./package.json').version, '-v, --version', '显示版本号')
   .action(async (options) => {
-    // 合并配置
+    // 全局工作进程池引用，用于优雅退出
+    let globalPool = null;
+    
+    // 优雅退出处理
+    const gracefulShutdown = async (signal) => {
+      console.log(`\n\n接收到 ${signal} 信号，正在优雅退出...`);
+      
+      if (globalPool) {
+        console.log("正在等待当前任务完成...");
+        try {
+          await globalPool.shutdown();
+          console.log("已安全关闭所有工作进程");
+        } catch (error) {
+          console.error("关闭工作进程时出错:", error);
+        }
+      }
+      
+      console.log("程序已退出");
+      process.exit(0);
+    };
+    
+    // 注册信号处理
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    
+    // 合并配置 - 处理多目录
+    const inputDirs = Array.isArray(options.dir) 
+      ? options.dir.map(d => path.resolve(process.cwd(), d))
+      : [path.resolve(process.cwd(), options.dir)];
+    
     const config = {
-      targetDir: path.resolve(process.cwd(), options.dir),
+      targetDirs: inputDirs,
       outputDir: options.replace ? null : path.resolve(process.cwd(), options.output),
       quality: parseInt(options.quality, 10),
       gifColours: parseInt(options.gifColours, 10),
       blackDirs: Array.isArray(options.blackDirs) ? options.blackDirs : [options.blackDirs],
       replace: options.replace || false,
+      workers: options.workers,
+      noParallel: options.noParallel || false,
     };
+    
+    // 验证目录
+    console.log("正在验证目录...");
+    const { validDirs, invalidDirs } = validateDirectories(config.targetDirs);
+    
+    if (invalidDirs.length > 0) {
+      console.log(`\n跳过了 ${invalidDirs.length} 个无效目录`);
+    }
+    
+    if (validDirs.length === 0) {
+      console.error("错误: 所有目录都无效，程序退出");
+      process.exit(1);
+    }
+    
+    console.log(`\n有效目录: ${validDirs.length} 个`);
+    
+    // 收集所有图片文件
+    console.log("\n正在扫描图片文件...");
+    const { allImageFiles, dirStats } = collectImageFilesFromMultipleDirs(validDirs, config);
+    
+    if (allImageFiles.length === 0) {
+      console.log("未找到需要压缩的图片文件");
+      process.exit(0);
+    }
 
     let shouldContinue = options.yes;
     if (!shouldContinue) {
-      shouldContinue = await askUserToContinue();
+      shouldContinue = await askUserToContinue(dirStats);
     }
     if (!shouldContinue) {
       console.log("已取消操作。");
       process.exit(0);
     }
 
-    const inputDir = config.targetDir;
-    compressFiles(inputDir, config, inputDir)
-      .then(() => {
-        if (config.replace) {
-          console.log("压缩任务全部完成，已原地替换所有图片");
-        } else {
-          console.log("压缩任务全部完成，已输出至", config.outputDir);
-        }
-      })
-      .catch((err) => {
-        console.error("压缩文件时出错:", err);
+    try {
+      await compressFilesParallel(allImageFiles, config, (pool) => {
+        globalPool = pool;
       });
+      
+      // 解除全局引用
+      globalPool = null;
+      
+      if (config.replace) {
+        console.log("\n压缩任务全部完成，已原地替换所有图片");
+      } else {
+        console.log("\n输出目录:", config.outputDir);
+      }
+      
+      // 正常退出
+      process.exit(0);
+    } catch (err) {
+      console.error("压缩文件时出错:", err);
+      
+      // 确保清理工作进程
+      if (globalPool) {
+        await globalPool.shutdown();
+      }
+      
+      process.exit(1);
+    }
   });
 
 program.parse(process.argv);

package/lib/progress-display.js

@@ -0,0 +1,182 @@
+const readline = require("readline");
+
+class ProgressDisplay {
+  constructor(total) {
+    this.total = total;
+    this.completed = 0;
+    this.failed = 0;
+    this.startTime = Date.now();
+    this.totalBeforeSize = 0;
+    this.totalAfterSize = 0;
+    this.lastUpdateTime = Date.now();
+    this.isMultiProcess = false;
+  }
+
+  // 设置是否多进程模式
+  setMultiProcess(isMultiProcess) {
+    this.isMultiProcess = isMultiProcess;
+  }
+
+  // 格式化文件大小
+  formatSize(bytes) {
+    if (bytes === 0) return "0B";
+    const mb = bytes / 1024 / 1024;
+    if (mb >= 1) {
+      return mb.toFixed(2) + "MB";
+    }
+    const kb = bytes / 1024;
+    if (kb < 0.01 && bytes > 0) {
+      return "<0.01KB";
+    }
+    return kb.toFixed(2) + "KB";
+  }
+
+  // 格式化时间
+  formatTime(seconds) {
+    if (seconds < 60) {
+      return Math.round(seconds) + " 秒";
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainSeconds = Math.round(seconds % 60);
+    return `${minutes} 分 ${remainSeconds} 秒`;
+  }
+
+  // 生成进度条
+  generateProgressBar(percent, length = 30) {
+    const filled = Math.round((percent / 100) * length);
+    const empty = length - filled;
+    return "█".repeat(filled) + "░".repeat(empty);
+  }
+
+  // 更新进度（多进程模式）
+  updateMultiProcess(data) {
+    if (data.completed !== undefined) {
+      this.completed = data.completed;
+    }
+    if (data.failed !== undefined) {
+      this.failed = data.failed;
+    }
+    if (data.beforeSize) {
+      this.totalBeforeSize += data.beforeSize;
+    }
+    if (data.afterSize) {
+      this.totalAfterSize += data.afterSize;
+    }
+
+    // 限制更新频率（每200ms更新一次）
+    const now = Date.now();
+    if (now - this.lastUpdateTime < 200) {
+      return;
+    }
+    this.lastUpdateTime = now;
+
+    const percent = ((this.completed + this.failed) / this.total * 100).toFixed(1);
+    const elapsed = (now - this.startTime) / 1000;
+    const speed = this.completed / elapsed;
+    const remaining = this.total - this.completed - this.failed;
+    const eta = remaining > 0 ? remaining / speed : 0;
+
+    const progressBar = this.generateProgressBar(parseFloat(percent));
+    const savedSize = this.formatSize(this.totalBeforeSize - this.totalAfterSize);
+
+    // 使用 \r 实现同行刷新
+    process.stdout.write(
+      `\r[${progressBar}] ${this.completed + this.failed}/${this.total} (${percent}%) | ` +
+      `速度: ${speed.toFixed(1)} 张/秒 | ` +
+      `剩余: ${this.formatTime(eta)} | ` +
+      `已节省: ${savedSize}`
+    );
+  }
+
+  // 更新进度（单进程模式）
+  updateSingleProcess(data) {
+    this.completed++;
+    if (data.beforeSize) {
+      this.totalBeforeSize += data.beforeSize;
+    }
+    if (data.afterSize) {
+      this.totalAfterSize += data.afterSize;
+    }
+
+    const beforeSize = this.formatSize(data.beforeSize);
+    const afterSize = this.formatSize(data.afterSize);
+    
+    console.log(
+      `压缩完成 [大小变化: ${beforeSize} ---->>>> ${afterSize}] ${data.outputPath}`
+    );
+  }
+
+  // 更新进度
+  update(data) {
+    if (this.isMultiProcess) {
+      this.updateMultiProcess(data);
+    } else {
+      this.updateSingleProcess(data);
+    }
+  }
+
+  // 完成进度显示
+  complete() {
+    if (this.isMultiProcess) {
+      // 强制显示最终进度（100%）
+      const percent = ((this.completed + this.failed) / this.total * 100).toFixed(1);
+      const elapsed = (Date.now() - this.startTime) / 1000;
+      const speed = this.completed / elapsed;
+      const progressBar = this.generateProgressBar(parseFloat(percent));
+      const savedSize = this.formatSize(this.totalBeforeSize - this.totalAfterSize);
+
+      // 最终进度输出
+      process.stdout.write(
+        `\r[${progressBar}] ${this.completed + this.failed}/${this.total} (${percent}%) | ` +
+        `速度: ${speed.toFixed(1)} 张/秒 | ` +
+        `完成 | ` +
+        `已节省: ${savedSize}`
+      );
+      
+      // 多进程模式：换行，准备输出报告
+      console.log("\n");
+    }
+  }
+
+  // 显示错误
+  showError(filePath, error) {
+    if (!this.isMultiProcess) {
+      console.error(`压缩出错: ${filePath}`, error);
+    }
+  }
+
+  // 显示最终报告
+  showReport(report) {
+    console.log("========================================");
+    console.log("压缩任务完成报告");
+    console.log("========================================");
+    console.log(`总处理图片: ${report.total} 张`);
+    console.log(`成功: ${report.completed} 张`);
+    console.log(`失败: ${report.failed} 张`);
+    console.log(`总耗时: ${this.formatTime(report.duration)}`);
+    console.log(`平均速度: ${report.speed} 张/秒`);
+    
+    const beforeSize = this.formatSize(report.totalBeforeSize);
+    const afterSize = this.formatSize(report.totalAfterSize);
+    const savedSize = this.formatSize(report.savedSize);
+    
+    console.log(`总节省空间: ${savedSize} (原始 ${beforeSize} → 压缩后 ${afterSize})`);
+    console.log(`压缩率: ${report.compressionRate}%`);
+    
+    if (report.workerCount > 0) {
+      console.log(`使用进程数: ${report.workerCount}`);
+    }
+    
+    console.log("========================================");
+    
+    if (report.failedTasks && report.failedTasks.length > 0) {
+      console.log("失败文件列表:");
+      for (const task of report.failedTasks) {
+        console.log(`  - ${task.filePath} (${task.error})`);
+      }
+      console.log("========================================");
+    }
+  }
+}
+
+module.exports = ProgressDisplay;

package/lib/worker-pool.js

@@ -0,0 +1,336 @@
+const { fork } = require("child_process");
+const os = require("os");
+const path = require("path");
+
+class WorkerPool {
+  constructor(config) {
+    this.config = config;
+    this.workers = [];
+    this.taskQueue = [];
+    this.activeTasks = new Map(); // taskId -> task info
+    this.completedTasks = [];
+    this.failedTasks = [];
+    this.nextTaskId = 0;
+    this.startTime = null;
+    this.isShuttingDown = false;
+    
+    // 统计信息
+    this.stats = {
+      total: 0,
+      completed: 0,
+      failed: 0,
+      totalBeforeSize: 0,
+      totalAfterSize: 0,
+      workerCount: 0
+    };
+  }
+
+  // 计算最优进程数
+  static calculateWorkerCount(imageCount, userSpecified) {
+    const cpuCount = os.cpus().length;
+    
+    // 用户指定进程数
+    if (userSpecified) {
+      const count = parseInt(userSpecified, 10);
+      if (count >= 1 && count <= cpuCount) {
+        return count;
+      }
+      console.log(`警告: 指定的进程数 ${userSpecified} 不合理，将使用自动计算值`);
+    }
+    
+    // 自动计算
+    if (imageCount <= 20) {
+      return 0; // 使用单进程模式
+    } else if (imageCount <= cpuCount) {
+      return imageCount;
+    } else {
+      return Math.max(1, cpuCount - 1);
+    }
+  }
+
+  // 初始化工作进程池
+  async initialize(workerCount) {
+    this.stats.workerCount = workerCount;
+    this.startTime = Date.now();
+    
+    const workerPath = path.join(__dirname, "worker.js");
+    const promises = [];
+
+    for (let i = 0; i < workerCount; i++) {
+      const promise = new Promise((resolve, reject) => {
+        const worker = fork(workerPath);
+        
+        worker.on("message", (message) => {
+          if (message.type === "ready") {
+            this.workers.push(worker);
+            resolve();
+          } else {
+            this.handleWorkerMessage(worker, message);
+          }
+        });
+
+        worker.on("error", (error) => {
+          console.error(`工作进程错误:`, error);
+          reject(error);
+        });
+
+        worker.on("exit", (code) => {
+          if (!this.isShuttingDown && code !== 0) {
+            console.error(`工作进程异常退出，退出码: ${code}`);
+            this.handleWorkerExit(worker);
+          }
+        });
+
+        // 超时处理
+        setTimeout(() => reject(new Error("工作进程启动超时")), 10000);
+      });
+
+      promises.push(promise);
+    }
+
+    await Promise.all(promises);
+    console.log(`已启动 ${workerCount} 个工作进程`);
+  }
+
+  // 处理工作进程消息
+  handleWorkerMessage(worker, message) {
+    if (message.type === "success") {
+      const task = this.activeTasks.get(message.taskId);
+      if (task) {
+        this.activeTasks.delete(message.taskId);
+        this.completedTasks.push({
+          ...message,
+          task
+        });
+        this.stats.completed++;
+        this.stats.totalBeforeSize += message.beforeSize;
+        this.stats.totalAfterSize += message.afterSize;
+        
+        // 触发进度更新回调
+        if (this.config.onProgress) {
+          this.config.onProgress({
+            completed: this.stats.completed,
+            failed: this.stats.failed,
+            total: this.stats.total,
+            beforeSize: message.beforeSize,
+            afterSize: message.afterSize,
+            filePath: message.filePath,
+            outputPath: message.outputPath
+          });
+        }
+      }
+      
+      // 处理下一个任务
+      this.assignNextTask(worker);
+    } else if (message.type === "error") {
+      const task = this.activeTasks.get(message.taskId);
+      if (task) {
+        this.activeTasks.delete(message.taskId);
+        
+        // 检查是否需要重试
+        if (!task.retried) {
+          task.retried = true;
+          this.taskQueue.unshift(task); // 重新加入队列头部
+        } else {
+          this.failedTasks.push({
+            ...message,
+            task
+          });
+          this.stats.failed++;
+          
+          if (this.config.onProgress) {
+            this.config.onProgress({
+              completed: this.stats.completed,
+              failed: this.stats.failed,
+              total: this.stats.total,
+              error: message.error,
+              filePath: message.filePath
+            });
+          }
+        }
+      }
+      
+      // 处理下一个任务
+      this.assignNextTask(worker);
+    }
+  }
+
+  // 处理工作进程异常退出
+  handleWorkerExit(worker) {
+    // 移除已退出的进程
+    const index = this.workers.indexOf(worker);
+    if (index > -1) {
+      this.workers.splice(index, 1);
+    }
+
+    // 将该进程的未完成任务重新加入队列
+    for (const [taskId, task] of this.activeTasks.entries()) {
+      if (task.workerId === worker.pid) {
+        this.activeTasks.delete(taskId);
+        this.taskQueue.unshift(task);
+      }
+    }
+
+    // 启动新的替代进程
+    if (!this.isShuttingDown) {
+      this.startReplacementWorker();
+    }
+  }
+
+  // 启动替代进程
+  async startReplacementWorker() {
+    try {
+      const workerPath = path.join(__dirname, "worker.js");
+      const worker = fork(workerPath);
+
+      await new Promise((resolve, reject) => {
+        worker.on("message", (message) => {
+          if (message.type === "ready") {
+            this.workers.push(worker);
+            resolve();
+            
+            // 为新进程分配任务
+            this.assignNextTask(worker);
+          } else {
+            this.handleWorkerMessage(worker, message);
+          }
+        });
+
+        worker.on("error", reject);
+        worker.on("exit", (code) => {
+          if (!this.isShuttingDown && code !== 0) {
+            this.handleWorkerExit(worker);
+          }
+        });
+
+        setTimeout(() => reject(new Error("替代进程启动超时")), 10000);
+      });
+
+      console.log(`已启动替代进程`);
+    } catch (error) {
+      console.error(`启动替代进程失败:`, error);
+    }
+  }
+
+  // 添加任务到队列
+  addTasks(tasks) {
+    this.stats.total = tasks.length;
+    
+    // 按文件大小降序排序（大文件优先）
+    tasks.sort((a, b) => b.size - a.size);
+    
+    this.taskQueue.push(...tasks);
+  }
+
+  // 开始处理任务
+  start() {
+    // 为每个工作进程分配初始任务
+    for (const worker of this.workers) {
+      this.assignNextTask(worker);
+    }
+  }
+
+  // 为工作进程分配下一个任务
+  assignNextTask(worker) {
+    if (this.isShuttingDown || this.taskQueue.length === 0) {
+      return;
+    }
+
+    const task = this.taskQueue.shift();
+    if (!task) {
+      return;
+    }
+
+    const taskId = this.nextTaskId++;
+    task.taskId = taskId;
+    task.workerId = worker.pid;
+    this.activeTasks.set(taskId, task);
+
+    worker.send({
+      type: "task",
+      taskId,
+      filePath: task.filePath,
+      sourceDir: task.sourceDir,
+      config: {
+        quality: this.config.quality,
+        gifColours: this.config.gifColours,
+        outputDir: this.config.outputDir,
+        replace: this.config.replace
+      }
+    });
+  }
+
+  // 等待所有任务完成
+  async waitForCompletion() {
+    return new Promise((resolve) => {
+      const checkInterval = setInterval(() => {
+        if (this.activeTasks.size === 0 && this.taskQueue.length === 0) {
+          clearInterval(checkInterval);
+          resolve();
+        }
+      }, 100);
+    });
+  }
+
+  // 获取统计报告
+  getReport() {
+    const duration = Date.now() - this.startTime;
+    const durationSeconds = duration / 1000;
+    const speed = this.stats.completed / durationSeconds;
+    
+    const savedSize = this.stats.totalBeforeSize - this.stats.totalAfterSize;
+    const compressionRate = this.stats.totalBeforeSize > 0
+      ? ((savedSize / this.stats.totalBeforeSize) * 100).toFixed(1)
+      : 0;
+
+    return {
+      total: this.stats.total,
+      completed: this.stats.completed,
+      failed: this.stats.failed,
+      duration: durationSeconds,
+      speed: speed.toFixed(1),
+      totalBeforeSize: this.stats.totalBeforeSize,
+      totalAfterSize: this.stats.totalAfterSize,
+      savedSize,
+      compressionRate,
+      workerCount: this.stats.workerCount,
+      failedTasks: this.failedTasks
+    };
+  }
+
+  // 优雅关闭所有工作进程
+  async shutdown() {
+    this.isShuttingDown = true;
+
+    // 等待当前任务完成（最多30秒）
+    const timeout = new Promise((resolve) => setTimeout(resolve, 30000));
+    const completion = this.waitForCompletion();
+    
+    await Promise.race([completion, timeout]);
+
+    // 发送关闭信号
+    for (const worker of this.workers) {
+      try {
+        worker.send({ type: "shutdown" });
+      } catch (error) {
+        // 忽略发送失败的错误
+      }
+    }
+
+    // 等待进程退出
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // 强制终止仍未退出的进程
+    for (const worker of this.workers) {
+      try {
+        worker.kill();
+      } catch (error) {
+        // 忽略终止失败的错误
+      }
+    }
+
+    this.workers = [];
+  }
+}
+
+module.exports = WorkerPool;

package/lib/worker.js

@@ -0,0 +1,118 @@
+const fs = require("fs");
+const path = require("path");
+const sharp = require("sharp");
+
+// 获取文件大小（字节）
+function getFileSize(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    return stats.size;
+  } catch (error) {
+    return 0;
+  }
+}
+
+// 压缩单张图片
+async function compressImage(filePath, config, sourceDir) {
+  const beforeSize = getFileSize(filePath);
+  const startTime = Date.now();
+  
+  sharp.cache(false);
+
+  const ext = path.extname(filePath).toLowerCase();
+  let sharpInstance;
+
+  switch (ext) {
+    case ".png":
+      sharpInstance = sharp(filePath).png({ quality: config.quality });
+      break;
+    case ".jpg":
+    case ".jpeg":
+      sharpInstance = sharp(filePath).jpeg({ quality: config.quality });
+      break;
+    case ".gif":
+      sharpInstance = sharp(filePath, {
+        animated: true,
+        limitInputPixels: false,
+      }).gif({ colours: config.gifColours });
+      break;
+    default:
+      throw new Error(`不支持的文件类型: ${ext}`);
+  }
+
+  // 原地替换模式或输出到新目录
+  let outputFilePath;
+  let outputFileDir;
+  
+  if (config.replace) {
+    // 原地替换：使用临时文件，包含进程ID避免冲突
+    outputFilePath = filePath + `.tmp.${process.pid}`;
+    outputFileDir = path.dirname(outputFilePath);
+  } else {
+    // 保持目录结构输出到新目录
+    // 多目录支持: 使用sourceDir的basename作为一级子目录
+    const relativePath = path.relative(sourceDir, filePath);
+    const sourceDirBasename = path.basename(sourceDir);
+    outputFilePath = path.join(config.outputDir, sourceDirBasename, relativePath);
+    outputFileDir = path.dirname(outputFilePath);
+  }
+
+  if (!fs.existsSync(outputFileDir)) {
+    fs.mkdirSync(outputFileDir, { recursive: true });
+  }
+  
+  const buffer = await sharpInstance.toBuffer();
+  fs.writeFileSync(outputFilePath, buffer);
+  fs.chmodSync(outputFilePath, 0o646);
+  
+  // 如果是原地替换模式，将临时文件重命名为原文件
+  if (config.replace) {
+    fs.unlinkSync(filePath);
+    fs.renameSync(outputFilePath, filePath);
+    outputFilePath = filePath;
+  }
+  
+  const afterSize = getFileSize(outputFilePath);
+  const duration = Date.now() - startTime;
+
+  return {
+    filePath,
+    outputPath: outputFilePath,
+    beforeSize,
+    afterSize,
+    duration
+  };
+}
+
+// 工作进程消息处理
+process.on("message", async (message) => {
+  if (message.type === "task") {
+    const { taskId, filePath, config, sourceDir } = message;
+    
+    try {
+      const result = await compressImage(filePath, config, sourceDir);
+      
+      process.send({
+        type: "success",
+        taskId,
+        filePath: result.filePath,
+        outputPath: result.outputPath,
+        beforeSize: result.beforeSize,
+        afterSize: result.afterSize,
+        duration: result.duration
+      });
+    } catch (error) {
+      process.send({
+        type: "error",
+        taskId,
+        filePath,
+        error: error.message
+      });
+    }
+  } else if (message.type === "shutdown") {
+    process.exit(0);
+  }
+});
+
+// 通知主进程工作进程已就绪
+process.send({ type: "ready", workerId: process.pid });

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "minify-pic-cli",
-  "version": "1.1.1",
+  "version": "1.2.0-beta.2",
   "description": "一个简单易用的图片批量压缩命令行工具，支持 PNG、JPEG、GIF 格式，适合前端和设计师快速优化图片体积。",
   "main": "index.js",
+  "files": [
+    "index.js",
+    "lib",
+    "README.md"
+  ],
   "bin": {
     "mpic": "index.js"
   },
   "scripts": {
-    "build": "node ./index.js"
+    "build": "node ./index.js",
+    "test": "mpic -d ./test/src/assets,./test/src/imgs -o ./test/output -y -w 2"
   },
   "keywords": [
     "图片压缩",