@mcpcn/mcp-image-compressor 1.0.1 → 1.0.4

package/README.md

@@ -1,287 +1,287 @@
-# Image Processor MCP Server
-
-这是一个用于图片处理的 MCP 服务器，提供了多种图片处理功能。
-
-## 功能特性
-
-1. 图片格式转换
-2. 图片压缩到指定大小
-3. 图片压缩到原始大小的指定百分比
-4. 图片尺寸缩放
-5. 读取图片元数据
-6. 图像旋转
-7. 图像翻转
-8. 添加文字水印
-
-## 安装
-
-```bash
-npm install
-```
-
-## 构建
-
-```bash
-npm run build
-```
-
-## 运行服务器
-
-```bash
-npm start
-```
-
-## 开发模式
-
-```bash
-npm run dev
-```
-
-## MCP 工具
-
-### 1. image_convert_format
-
-将图片转换为指定格式。
-
-**参数：**
-
-- `inputPaths`: 原图片路径数组，支持图片文件和目录
-- `targetFormat`: 要转换为的格式（jpg/png/webp/bmp等）
-- `outputPath`: 转换后的保存路径（可选，不指定则和原图片目录相同）
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg", "path/to/images/"],
-  "targetFormat": "png",
-  "outputPath": "path/to/output/"
-}
-```
-
-### 2. image_compress_to_size
-
-将图片压缩到指定的文件大小。
-
-**参数：**
-
-- `inputPaths`: 原图片路径数组，支持图片文件和目录
-- `size`: 要压缩到的的目标大小（如1mb/500kb）
-- `overwrite`: 是否覆盖原图（可选，默认为false）
-- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"],
-  "size": "500kb",
-  "overwrite": false,
-  "outputPath": "path/to/output/"
-}
-```
-
-### 3. image_compress_to_percent
-
-将图片压缩到原始大小的指定百分比。
-
-**参数：**
-
-- `inputPaths`: 原图片路径数组，支持图片文件和目录
-- `percent`: 要压缩到原size的百分之多少（如50或50%）
-- `overwrite`: 是否覆盖原图（可选，默认为false）
-- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"],
-  "percent": "50%",
-  "overwrite": false,
-  "outputPath": "path/to/output/"
-}
-```
-
-### 4. image_resize
-
-调整图片尺寸。
-
-**参数：**
-
-- `inputPaths`: 原图片路径数组，支持图片文件和目录
-- `width`: 宽修改为多少（可选）
-- `height`: 高修改为多少（可选）
-- `overwrite`: 是否覆盖原图（可选，默认为false）
-- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"],
-  "width": 800,
-  "height": 600,
-  "overwrite": false,
-  "outputPath": "path/to/output/"
-}
-```
-
-### 5. image_metadata
-
-读取图片元数据。
-
-**参数：**
-
-- `inputPaths`: 待处理图片路径
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"]
-}
-```
-
-**返回示例：**
-
-```json
-{
-  "success": true,
-  "message": "成功读取了 1 个图片的元数据",
-  "metadata": {
-    "image.jpg": {
-      "format": "jpeg",
-      "width": 1920,
-      "height": 1080,
-      "space": "srgb",
-      "channels": 3,
-      "depth": "uchar",
-      "density": 72,
-      "isProgressive": false,
-      "hasProfile": true,
-      "hasAlpha": false
-    }
-  }
-}
-```
-
-### 6. image_rotate
-
-图像旋转。
-
-**参数：**
-
-- `inputPaths`: 待处理图片路径
-- `angle`: 旋转角度（顺时针为正值，逆时针为负值）
-- `overwrite`: 是否覆盖原图（可选，默认为false）
-- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"],
-  "angle": 90,
-  "overwrite": false,
-  "outputPath": "path/to/output/"
-}
-```
-
-### 7. image_flip
-
-图像翻转。
-
-**参数：**
-
-- `inputPaths`: 待处理图片路径
-- `flipType`: 翻转方式（"horizontal": 水平翻转, "vertical": 垂直翻转）
-- `overwrite`: 是否覆盖原图（可选，默认为false）
-- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"],
-  "flipType": "horizontal",
-  "overwrite": false,
-  "outputPath": "path/to/output/"
-}
-```
-
-### 8. image_watermark
-
-添加文字水印。
-
-**参数：**
-
-- `inputPaths`: 待处理图片路径
-- `text`: 水印内容（文字）
-- `position`: 水印添加方式（必填，可能的取值为：top-left（左上）、top-right（右上）、bottom-left（左下）、bottom-right（右下）、center（中央）、tile（铺满））
-- `density`: 满铺密度（可选参数，在水印添加方式为铺满时有效，取值范围为1-10的整数，1最稀疏，10最密）
-- `fontSize`: 文字尺寸（可选参数，单位为像素，不传则根据图片尺寸自动计算）
-- `overwrite`: 是否覆盖原图（可选，默认为false）
-- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
-
-**示例：**
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"],
-  "text": "版权所有",
-  "position": "bottom-right",
-  "overwrite": false,
-  "outputPath": "path/to/output/"
-}
-```
-
-铺满水印示例：
-
-```json
-{
-  "inputPaths": ["path/to/image.jpg"],
-  "text": "CONFIDENTIAL",
-  "position": "tile",
-  "density": 5,
-  "fontSize": 20,
-  "overwrite": false,
-  "outputPath": "path/to/output/"
-}
-```
-
-## 注意事项
-
-1. 所有功能都支持批量处理多个文件
-2. 支持处理整个目录中的图片（仅处理目录下的图片文件，不处理子目录中的）
-3. 支持的图片格式：jpeg、jpg、png、webp、gif、avif、tiff、bmp
-4. 压缩功能使用二分查找算法来找到最佳的压缩质量
-5. 当指定输出目录时，如果目录不存在会自动创建
-6. 所有错误都会被优雅地处理并记录，不会中断批处理过程
-
-## 使用作为 MCP 服务器
-
-该服务器实现了 Model Context Protocol (MCP) 规范，可以连接到支持 MCP 的客户端。
-
-### 配置环境变量
-
-在使用前，确保已安装所有依赖，并构建项目：
-
-```bash
-npm install
-npm run build
-```
-
-### 启动服务器
-
-```bash
-npm start
-```
-
-
-
-## 依赖
-
-- sharp: 用于图片处理
-- @modelcontextprotocol/sdk: MCP SDK
+# Image Processor MCP Server
+
+这是一个用于图片处理的 MCP 服务器，提供了多种图片处理功能。
+
+## 功能特性
+
+1. 图片格式转换
+2. 图片压缩到指定大小
+3. 图片压缩到原始大小的指定百分比
+4. 图片尺寸缩放
+5. 读取图片元数据
+6. 图像旋转
+7. 图像翻转
+8. 添加文字水印
+
+## 安装
+
+```bash
+npm install
+```
+
+## 构建
+
+```bash
+npm run build
+```
+
+## 运行服务器
+
+```bash
+npm start
+```
+
+## 开发模式
+
+```bash
+npm run dev
+```
+
+## MCP 工具
+
+### 1. image_convert_format
+
+将图片转换为指定格式。
+
+**参数：**
+
+- `inputPaths`: 原图片路径数组，支持图片文件和目录
+- `targetFormat`: 要转换为的格式（jpg/png/webp/bmp等）
+- `outputPath`: 转换后的保存路径（可选，不指定则和原图片目录相同）
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg", "path/to/images/"],
+  "targetFormat": "png",
+  "outputPath": "path/to/output/"
+}
+```
+
+### 2. image_compress_to_size
+
+将图片压缩到指定的文件大小。
+
+**参数：**
+
+- `inputPaths`: 原图片路径数组，支持图片文件和目录
+- `size`: 要压缩到的的目标大小（如1mb/500kb）
+- `overwrite`: 是否覆盖原图（可选，默认为false）
+- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"],
+  "size": "500kb",
+  "overwrite": false,
+  "outputPath": "path/to/output/"
+}
+```
+
+### 3. image_compress_to_percent
+
+将图片压缩到原始大小的指定百分比。
+
+**参数：**
+
+- `inputPaths`: 原图片路径数组，支持图片文件和目录
+- `percent`: 要压缩到原size的百分之多少（如50或50%）
+- `overwrite`: 是否覆盖原图（可选，默认为false）
+- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"],
+  "percent": "50%",
+  "overwrite": false,
+  "outputPath": "path/to/output/"
+}
+```
+
+### 4. image_resize
+
+调整图片尺寸。
+
+**参数：**
+
+- `inputPaths`: 原图片路径数组，支持图片文件和目录
+- `width`: 宽修改为多少（可选）
+- `height`: 高修改为多少（可选）
+- `overwrite`: 是否覆盖原图（可选，默认为false）
+- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"],
+  "width": 800,
+  "height": 600,
+  "overwrite": false,
+  "outputPath": "path/to/output/"
+}
+```
+
+### 5. image_metadata
+
+读取图片元数据。
+
+**参数：**
+
+- `inputPaths`: 待处理图片路径
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"]
+}
+```
+
+**返回示例：**
+
+```json
+{
+  "success": true,
+  "message": "成功读取了 1 个图片的元数据",
+  "metadata": {
+    "image.jpg": {
+      "format": "jpeg",
+      "width": 1920,
+      "height": 1080,
+      "space": "srgb",
+      "channels": 3,
+      "depth": "uchar",
+      "density": 72,
+      "isProgressive": false,
+      "hasProfile": true,
+      "hasAlpha": false
+    }
+  }
+}
+```
+
+### 6. image_rotate
+
+图像旋转。
+
+**参数：**
+
+- `inputPaths`: 待处理图片路径
+- `angle`: 旋转角度（顺时针为正值，逆时针为负值）
+- `overwrite`: 是否覆盖原图（可选，默认为false）
+- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"],
+  "angle": 90,
+  "overwrite": false,
+  "outputPath": "path/to/output/"
+}
+```
+
+### 7. image_flip
+
+图像翻转。
+
+**参数：**
+
+- `inputPaths`: 待处理图片路径
+- `flipType`: 翻转方式（"horizontal": 水平翻转, "vertical": 垂直翻转）
+- `overwrite`: 是否覆盖原图（可选，默认为false）
+- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"],
+  "flipType": "horizontal",
+  "overwrite": false,
+  "outputPath": "path/to/output/"
+}
+```
+
+### 8. image_watermark
+
+添加文字水印。
+
+**参数：**
+
+- `inputPaths`: 待处理图片路径
+- `text`: 水印内容（文字）
+- `position`: 水印添加方式（必填，可能的取值为：top-left（左上）、top-right（右上）、bottom-left（左下）、bottom-right（右下）、center（中央）、tile（铺满））
+- `density`: 满铺密度（可选参数，在水印添加方式为铺满时有效，取值范围为1-10的整数，1最稀疏，10最密）
+- `fontSize`: 文字尺寸（可选参数，单位为像素，不传则根据图片尺寸自动计算）
+- `overwrite`: 是否覆盖原图（可选，默认为false）
+- `outputPath`: 存储路径（可选，不覆盖原图时如果没传则为原图所在目录）
+
+**示例：**
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"],
+  "text": "版权所有",
+  "position": "bottom-right",
+  "overwrite": false,
+  "outputPath": "path/to/output/"
+}
+```
+
+铺满水印示例：
+
+```json
+{
+  "inputPaths": ["path/to/image.jpg"],
+  "text": "CONFIDENTIAL",
+  "position": "tile",
+  "density": 5,
+  "fontSize": 20,
+  "overwrite": false,
+  "outputPath": "path/to/output/"
+}
+```
+
+## 注意事项
+
+1. 所有功能都支持批量处理多个文件
+2. 支持处理整个目录中的图片（仅处理目录下的图片文件，不处理子目录中的）
+3. 支持的图片格式：jpeg、jpg、png、webp、gif、avif、tiff、bmp
+4. 压缩功能使用二分查找算法来找到最佳的压缩质量
+5. 当指定输出目录时，如果目录不存在会自动创建
+6. 所有错误都会被优雅地处理并记录，不会中断批处理过程
+
+## 使用作为 MCP 服务器
+
+该服务器实现了 Model Context Protocol (MCP) 规范，可以连接到支持 MCP 的客户端。
+
+### 配置环境变量
+
+在使用前，确保已安装所有依赖，并构建项目：
+
+```bash
+npm install
+npm run build
+```
+
+### 启动服务器
+
+```bash
+npm start
+```
+
+
+
+## 依赖
+
+- sharp: 用于图片处理
+- @modelcontextprotocol/sdk: MCP SDK
 - TypeScript: 用于类型检查和编译 

package/dist/index.js

@@ -41,7 +41,16 @@ const sharp = __importStar(require("sharp"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 // 支持的图片格式
-const SUPPORTED_FORMATS = ['jpeg', 'jpg', 'png', 'webp', 'gif', 'avif', 'tiff', 'bmp'];
+const SUPPORTED_FORMATS = [
+    "jpeg",
+    "jpg",
+    "png",
+    "webp",
+    "gif",
+    "avif",
+    "tiff",
+    "bmp",
+];
 // 工具函数：检查文件是否是图片
 function isImage(filePath) {
     const ext = path.extname(filePath).toLowerCase().slice(1);
@@ -52,8 +61,8 @@ function getImagesFromDirectory(dirPath) {
     try {
         const files = fs.readdirSync(dirPath);
         return files
-            .map(file => path.join(dirPath, file))
-            .filter(filePath => {
+            .map((file) => path.join(dirPath, file))
+            .filter((filePath) => {
             const stat = fs.statSync(filePath);
             return stat.isFile() && isImage(filePath);
         });
@@ -88,28 +97,28 @@ function parseSize(sizeStr) {
     const s = sizeStr.trim().toLowerCase();
     const match = s.match(/^(\d+(?:\.\d+)?)(b|kb|k|mb|m|gb|g)?$/);
     if (!match) {
-        throw new Error('Invalid size format. Examples: 200k, 500kb, 1m, 1mb, 1g, 1024');
+        throw new Error("Invalid size format. Examples: 200k, 500kb, 1m, 1mb, 1g, 1024");
     }
     const value = parseFloat(match[1]);
-    const unit = (match[2] || 'b');
+    const unit = match[2] || "b";
     if (value <= 0) {
-        throw new Error('Size must be greater than 0');
+        throw new Error("Size must be greater than 0");
     }
     let multiplier = 1;
     switch (unit) {
-        case 'b':
+        case "b":
             multiplier = 1;
             break;
-        case 'kb':
-        case 'k':
+        case "kb":
+        case "k":
             multiplier = 1024;
             break;
-        case 'mb':
-        case 'm':
+        case "mb":
+        case "m":
             multiplier = 1024 * 1024;
             break;
-        case 'gb':
-        case 'g':
+        case "gb":
+        case "g":
             multiplier = 1024 * 1024 * 1024;
             break;
         default:
@@ -126,7 +135,7 @@ function parsePercent(percentStr) {
     }
     const percent = parseFloat(match[1]);
     if (percent <= 0 || percent > 100) {
-        throw new Error('Percent must be between 0 and 100');
+        throw new Error("Percent must be between 0 and 100");
     }
     return percent;
 }
@@ -149,33 +158,48 @@ async function compressToSize(inputPaths, targetSize, overwrite = false, outputP
     const images = processInputPaths(inputPaths);
     const targetBytes = parseSize(targetSize);
     const results = [];
+    const errors = [];
     for (const imagePath of images) {
         try {
-            const outputFilePath = overwrite ?
-                imagePath :
-                generateOutputPath(imagePath, outputPath, `_${targetSize.toLowerCase()}`);
-            const image = sharp.default(imagePath);
-            const metadata = await image.metadata();
+            let outputFilePath = overwrite
+                ? imagePath
+                : generateOutputPath(imagePath, outputPath, `_${targetSize.toLowerCase()}`);
             const stats = fs.statSync(imagePath);
-            if (stats.size <= targetBytes) {
+            const originalSize = stats.size;
+            if (originalSize <= targetBytes) {
                 if (!overwrite) {
                     await fs.promises.copyFile(imagePath, outputFilePath);
                 }
                 results.push(outputFilePath);
                 continue;
             }
+            const ext = path.extname(imagePath).toLowerCase().slice(1);
+            const encodeWithQuality = async (q) => {
+                const img = sharp.default(imagePath);
+                if (ext === "jpg" || ext === "jpeg") {
+                    return img.jpeg({ quality: q, mozjpeg: true }).toBuffer();
+                }
+                if (ext === "png") {
+                    const clamped = Math.max(1, Math.min(q, 100));
+                    return img.png({ quality: clamped, compressionLevel: 9, palette: true }).toBuffer();
+                }
+                if (ext === "webp") {
+                    return img.webp({ quality: q }).toBuffer();
+                }
+                if (ext === "avif") {
+                    return img.avif({ quality: q }).toBuffer();
+                }
+                // 其他统一转jpeg
+                return img.jpeg({ quality: q, mozjpeg: true }).toBuffer();
+            };
             // 使用二分查找找到合适的质量值
-            let left = 1;
-            let right = 100;
-            let bestQuality = 100;
+            let left = 5;
+            let right = 95;
             let bestBuffer = null;
             while (left <= right) {
                 const quality = Math.floor((left + right) / 2);
-                const buffer = await image
-                    .jpeg({ quality })
-                    .toBuffer();
+                const buffer = await encodeWithQuality(quality);
                 if (buffer.length <= targetBytes) {
-                    bestQuality = quality;
                     bestBuffer = buffer;
                     left = quality + 1;
                 }
@@ -183,19 +207,69 @@ async function compressToSize(inputPaths, targetSize, overwrite = false, outputP
                     right = quality - 1;
                 }
             }
-            if (bestBuffer) {
-                await fs.promises.writeFile(outputFilePath, bestBuffer);
-                results.push(outputFilePath);
-            }
-            else {
-                throw new Error('Could not achieve target size while maintaining acceptable quality');
+            let outputBuffer = bestBuffer;
+            let outputExt = path.extname(outputFilePath).toLowerCase();
+            if (!outputBuffer) {
+                const fallback = await encodeWithQuality(Math.max(10, right));
+                if (fallback.length < originalSize) {
+                    outputBuffer = fallback;
+                }
+                else {
+                    // PNG等难以降体积时，尝试有损WebP再二分
+                    const tryWebp = async () => {
+                        let l = 5, r = 95;
+                        let buf = null;
+                        while (l <= r) {
+                            const q = Math.floor((l + r) / 2);
+                            const b = await sharp.default(imagePath).webp({ quality: q }).toBuffer();
+                            if (b.length <= targetBytes) {
+                                buf = b;
+                                l = q + 1;
+                            }
+                            else {
+                                r = q - 1;
+                            }
+                        }
+                        // 兜底：若仍未达到，但比原图小，也接受
+                        if (!buf) {
+                            const b = await sharp.default(imagePath).webp({ quality: Math.max(10, r) }).toBuffer();
+                            if (b.length < originalSize)
+                                return b;
+                        }
+                        return buf;
+                    };
+                    const webpBuf = await tryWebp();
+                    if (webpBuf) {
+                        outputBuffer = webpBuf;
+                        // 将输出后缀改为 .webp
+                        if (!overwrite) {
+                            const parsed = path.parse(outputFilePath);
+                            outputFilePath = path.join(parsed.dir, `${parsed.name}.webp`);
+                            outputExt = '.webp';
+                        }
+                        else {
+                            outputExt = '.webp';
+                        }
+                    }
+                    else {
+                        if (!overwrite) {
+                            await fs.promises.copyFile(imagePath, outputFilePath);
+                        }
+                        results.push(outputFilePath);
+                        continue;
+                    }
+                }
             }
+            await fs.promises.writeFile(outputFilePath, outputBuffer);
+            results.push(outputFilePath);
         }
         catch (error) {
-            console.error(`Error compressing ${imagePath}:`, error);
+            const errorMsg = `Error compressing ${imagePath}: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(errorMsg);
+            errors.push(errorMsg);
         }
     }
-    return results;
+    return { results, errors };
 }
 /**
  * 图片压缩到原始大小的百分比
@@ -204,27 +278,47 @@ async function compressToPercent(inputPaths, percent, overwrite = false, outputP
     const images = processInputPaths(inputPaths);
     const targetPercent = parsePercent(percent);
     const results = [];
+    const errors = [];
     for (const imagePath of images) {
         try {
-            const outputFilePath = overwrite ?
-                imagePath :
-                generateOutputPath(imagePath, outputPath, `_${targetPercent}%`);
+            const outputFilePath = overwrite
+                ? imagePath
+                : generateOutputPath(imagePath, outputPath, `_${targetPercent}%`);
             const stats = fs.statSync(imagePath);
-            const targetBytes = Math.floor(stats.size * (targetPercent / 100));
-            const image = sharp.default(imagePath);
-            const metadata = await image.metadata();
-            // 使用二分查找找到合适的质量值
-            let left = 1;
-            let right = 100;
-            let bestQuality = 100;
+            const originalSize = stats.size;
+            if (targetPercent >= 100) {
+                if (!overwrite) {
+                    await fs.promises.copyFile(imagePath, outputFilePath);
+                }
+                results.push(outputFilePath);
+                continue;
+            }
+            const targetBytes = Math.floor(originalSize * (targetPercent / 100));
+            const ext = path.extname(imagePath).toLowerCase().slice(1);
+            const encodeWithQuality = async (q) => {
+                const img = sharp.default(imagePath);
+                if (ext === "jpg" || ext === "jpeg") {
+                    return img.jpeg({ quality: q, mozjpeg: true }).toBuffer();
+                }
+                if (ext === "png") {
+                    const clamped = Math.max(1, Math.min(q, 100));
+                    return img.png({ quality: clamped, compressionLevel: 9, palette: true }).toBuffer();
+                }
+                if (ext === "webp") {
+                    return img.webp({ quality: q }).toBuffer();
+                }
+                if (ext === "avif") {
+                    return img.avif({ quality: q }).toBuffer();
+                }
+                return img.jpeg({ quality: q, mozjpeg: true }).toBuffer();
+            };
+            let left = 5;
+            let right = 95;
             let bestBuffer = null;
             while (left <= right) {
                 const quality = Math.floor((left + right) / 2);
-                const buffer = await image
-                    .jpeg({ quality })
-                    .toBuffer();
+                const buffer = await encodeWithQuality(quality);
                 if (buffer.length <= targetBytes) {
-                    bestQuality = quality;
                     bestBuffer = buffer;
                     left = quality + 1;
                 }
@@ -232,19 +326,30 @@ async function compressToPercent(inputPaths, percent, overwrite = false, outputP
                     right = quality - 1;
                 }
             }
-            if (bestBuffer) {
-                await fs.promises.writeFile(outputFilePath, bestBuffer);
-                results.push(outputFilePath);
-            }
-            else {
-                throw new Error('Could not achieve target size while maintaining acceptable quality');
+            let outputBuffer = bestBuffer;
+            if (!outputBuffer) {
+                const fallback = await encodeWithQuality(Math.max(10, right));
+                if (fallback.length < originalSize) {
+                    outputBuffer = fallback;
+                }
+                else {
+                    if (!overwrite) {
+                        await fs.promises.copyFile(imagePath, outputFilePath);
+                    }
+                    results.push(outputFilePath);
+                    continue;
+                }
             }
+            await fs.promises.writeFile(outputFilePath, outputBuffer);
+            results.push(outputFilePath);
         }
         catch (error) {
-            console.error(`Error compressing ${imagePath}:`, error);
+            const errorMsg = `Error compressing ${imagePath}: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(errorMsg);
+            errors.push(errorMsg);
         }
     }
-    return results;
+    return { results, errors };
 }
 const COMPRESS_TO_SIZE_TOOL = {
     name: "image_compress_to_size",
@@ -255,23 +360,23 @@ const COMPRESS_TO_SIZE_TOOL = {
             inputPaths: {
                 type: "array",
                 items: { type: "string" },
-                description: "原图片路径数组，支持图片文件和目录"
+                description: "原图片路径数组，支持图片文件和目录",
             },
             size: {
                 type: "string",
-                description: "要压缩到的的目标大小（如1mb/500kb）"
+                description: "要压缩到的的目标大小（如1mb/500kb）",
             },
             overwrite: {
                 type: "boolean",
-                description: "是否覆盖原图（可选，默认为false）"
+                description: "是否覆盖原图（可选，默认为false）",
             },
             outputPath: {
                 type: "string",
-                description: "存储路径（可选，不覆盖原图时如果没传则为原图所在目录）"
-            }
+                description: "存储路径（可选，不覆盖原图时如果没传则为原图所在目录）",
+            },
         },
-        required: ["inputPaths", "size"]
-    }
+        required: ["inputPaths", "size"],
+    },
 };
 const COMPRESS_TO_PERCENT_TOOL = {
     name: "image_compress_to_percent",
@@ -282,41 +387,45 @@ const COMPRESS_TO_PERCENT_TOOL = {
             inputPaths: {
                 type: "array",
                 items: { type: "string" },
-                description: "原图片路径数组，支持图片文件和目录"
+                description: "原图片路径数组，支持图片文件和目录",
             },
             percent: {
                 type: "string",
-                description: "要压缩到原size的百分之多少（如50或50%）"
+                description: "要压缩到原size的百分之多少（如50或50%）",
             },
             overwrite: {
                 type: "boolean",
-                description: "是否覆盖原图（可选，默认为false）"
+                description: "是否覆盖原图（可选，默认为false）",
             },
             outputPath: {
                 type: "string",
-                description: "存储路径（可选，不覆盖原图时如果没传则为原图所在目录）"
-            }
+                description: "存储路径（可选，不覆盖原图时如果没传则为原图所在目录）",
+            },
         },
-        required: ["inputPaths", "percent"]
-    }
+        required: ["inputPaths", "percent"],
+    },
 };
-const IMAGE_TOOLS = [
-    COMPRESS_TO_SIZE_TOOL,
-    COMPRESS_TO_PERCENT_TOOL,
-];
+const IMAGE_TOOLS = [COMPRESS_TO_SIZE_TOOL, COMPRESS_TO_PERCENT_TOOL];
 async function handleCompressToSize(inputPaths, size, overwrite = false, outputPath) {
     try {
-        const results = await compressToSize(inputPaths, size, overwrite, outputPath);
+        const { results, errors } = await compressToSize(inputPaths, size, overwrite, outputPath);
+        const hasErrors = errors.length > 0;
+        const totalProcessed = results.length + errors.length;
         return {
-            content: [{
+            content: [
+                {
                     type: "text",
                     text: JSON.stringify({
-                        success: true,
-                        message: `成功压缩了 ${results.length} 张图片到目标大小 ${size}`,
-                        compressedFiles: results
-                    }, null, 2)
-                }],
-            isError: false
+                        success: !hasErrors,
+                        message: hasErrors
+                            ? `处理了 ${totalProcessed} 张图片，成功压缩 ${results.length} 张，失败 ${errors.length} 张到目标大小 ${size}`
+                            : `成功压缩了 ${results.length} 张图片到目标大小 ${size}`,
+                        compressedFiles: results,
+                        errors: hasErrors ? errors : undefined,
+                    }, null, 2),
+                },
+            ],
+            isError: hasErrors,
         };
     }
     catch (error) {
@@ -325,17 +434,24 @@ async function handleCompressToSize(inputPaths, size, overwrite = false, outputP
 }
 async function handleCompressToPercent(inputPaths, percent, overwrite = false, outputPath) {
     try {
-        const results = await compressToPercent(inputPaths, percent, overwrite, outputPath);
+        const { results, errors } = await compressToPercent(inputPaths, percent, overwrite, outputPath);
+        const hasErrors = errors.length > 0;
+        const totalProcessed = results.length + errors.length;
         return {
-            content: [{
+            content: [
+                {
                     type: "text",
                     text: JSON.stringify({
-                        success: true,
-                        message: `成功压缩了 ${results.length} 张图片到原始大小的 ${parsePercent(percent)}%`,
-                        compressedFiles: results
-                    }, null, 2)
-                }],
-            isError: false
+                        success: !hasErrors,
+                        message: hasErrors
+                            ? `处理了 ${totalProcessed} 张图片，成功压缩 ${results.length} 张，失败 ${errors.length} 张到原始大小的 ${parsePercent(percent)}%`
+                            : `成功压缩了 ${results.length} 张图片到原始大小的 ${parsePercent(percent)}%`,
+                        compressedFiles: results,
+                        errors: hasErrors ? errors : undefined,
+                    }, null, 2),
+                },
+            ],
+            isError: hasErrors,
         };
     }
     catch (error) {
@@ -359,30 +475,36 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     try {
         switch (request.params.name) {
             case "image_compress_to_size": {
-                const { inputPaths, size, overwrite, outputPath } = request.params.arguments;
+                const { inputPaths, size, overwrite, outputPath } = request.params
+                    .arguments;
                 return await handleCompressToSize(inputPaths, size, overwrite, outputPath);
             }
             case "image_compress_to_percent": {
-                const { inputPaths, percent, overwrite, outputPath } = request.params.arguments;
+                const { inputPaths, percent, overwrite, outputPath } = request.params
+                    .arguments;
                 return await handleCompressToPercent(inputPaths, percent, overwrite, outputPath);
             }
             default:
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: "text",
-                            text: `未知工具: ${request.params.name}`
-                        }],
-                    isError: true
+                            text: `未知工具: ${request.params.name}`,
+                        },
+                    ],
+                    isError: true,
                 };
         }
     }
     catch (error) {
         return {
-            content: [{
+            content: [
+                {
                     type: "text",
-                    text: `错误: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            isError: true
+                    text: `错误: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
         };
     }
 });

package/package.json

@@ -1,42 +1,42 @@
-{
-  "name": "@mcpcn/mcp-image-compressor",
-  "version": "1.0.1",
-  "description": "MCP server for image compression",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc && chmod +x dist/index.js",
-    "start": "node dist/index.js",
-    "dev": "ts-node index.ts",
-    "serve": "node dist/index.js"
-  },
-  "bin": {
-    "mcp-image-compressor": "dist/index.js"
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "mcp",
-    "image",
-    "compressor",
-    "sharp",
-    "model-context-protocol"
-  ],
-  "author": "mcpcn",
-  "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "1.12.0",
-    "sharp": "^0.33.5",
-    "semver": "^7.6.3"
-  },
-  "devDependencies": {
-    "@types/node": "^20.0.0",
-    "@types/sharp": "^0.31.1",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.0"
-  }
-}
+{
+  "name": "@mcpcn/mcp-image-compressor",
+  "version": "1.0.4",
+  "description": "MCP server for image compression",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node index.ts",
+    "serve": "node dist/index.js"
+  },
+  "bin": {
+    "mcp-image-compressor": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "mcp",
+    "image",
+    "compressor",
+    "sharp",
+    "model-context-protocol"
+  ],
+  "author": "mcpcn",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.12.0",
+    "sharp": "^0.33.5",
+    "semver": "^7.6.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/sharp": "^0.31.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.0"
+  }
+}