@mcpcn/mcp-image-compressor 1.0.1 → 1.0.3

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,11 +158,12 @@ 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 outputFilePath = overwrite
+                ? imagePath
+                : generateOutputPath(imagePath, outputPath, `_${targetSize.toLowerCase()}`);
             const image = sharp.default(imagePath);
             const metadata = await image.metadata();
             const stats = fs.statSync(imagePath);
@@ -171,9 +181,7 @@ async function compressToSize(inputPaths, targetSize, overwrite = false, outputP
             let bestBuffer = null;
             while (left <= right) {
                 const quality = Math.floor((left + right) / 2);
-                const buffer = await image
-                    .jpeg({ quality })
-                    .toBuffer();
+                const buffer = await image.jpeg({ quality }).toBuffer();
                 if (buffer.length <= targetBytes) {
                     bestQuality = quality;
                     bestBuffer = buffer;
@@ -188,14 +196,16 @@ async function compressToSize(inputPaths, targetSize, overwrite = false, outputP
                 results.push(outputFilePath);
             }
             else {
-                throw new Error('Could not achieve target size while maintaining acceptable quality');
+                throw new Error("Could not achieve target size while maintaining acceptable quality");
             }
         }
         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,11 +214,12 @@ 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);
@@ -220,9 +231,7 @@ async function compressToPercent(inputPaths, percent, overwrite = false, outputP
             let bestBuffer = null;
             while (left <= right) {
                 const quality = Math.floor((left + right) / 2);
-                const buffer = await image
-                    .jpeg({ quality })
-                    .toBuffer();
+                const buffer = await image.jpeg({ quality }).toBuffer();
                 if (buffer.length <= targetBytes) {
                     bestQuality = quality;
                     bestBuffer = buffer;
@@ -237,14 +246,16 @@ async function compressToPercent(inputPaths, percent, overwrite = false, outputP
                 results.push(outputFilePath);
             }
             else {
-                throw new Error('Could not achieve target size while maintaining acceptable quality');
+                throw new Error("Could not achieve target size while maintaining acceptable quality");
             }
         }
         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 +266,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 +293,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 +340,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 +381,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,6 +1,6 @@
 {
   "name": "@mcpcn/mcp-image-compressor",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "MCP server for image compression",
   "main": "dist/index.js",
   "scripts": {