mcp-image-uploader 1.0.1

package/src/services/compressor.ts

@@ -0,0 +1,75 @@
+import sharp from 'sharp';
+import type { CompressionResult, CompressionOptions, ImageFormat, ImageMetadata } from '../types/index.js';
+import { compressJpeg } from '../strategies/jpeg.js';
+import { compressPng } from '../strategies/png.js';
+import { compressWebp } from '../strategies/webp.js';
+import { compressAvif } from '../strategies/avif.js';
+
+/**
+ * 获取图片元数据
+ */
+export async function getImageMetadata(buffer: Buffer): Promise<ImageMetadata> {
+    const metadata = await sharp(buffer).metadata();
+
+    return {
+        format: normalizeFormat(metadata.format),
+        width: metadata.width ?? 0,
+        height: metadata.height ?? 0,
+        size: buffer.length,
+    };
+}
+
+/**
+ * 标准化格式名称
+ */
+function normalizeFormat(format: string | undefined): ImageFormat {
+    const formatMap: Record<string, ImageFormat> = {
+        'jpeg': 'jpeg',
+        'jpg': 'jpeg',
+        'png': 'png',
+        'webp': 'webp',
+        'avif': 'avif',
+        'gif': 'gif',
+        'tiff': 'tiff',
+    };
+
+    return formatMap[format?.toLowerCase() ?? ''] ?? 'jpeg';
+}
+
+/**
+ * 压缩图片
+ */
+export async function compressImage(
+    buffer: Buffer,
+    options: CompressionOptions
+): Promise<CompressionResult> {
+    const metadata = await getImageMetadata(buffer);
+    const targetFormat = options.format ?? metadata.format;
+
+    let compressedBuffer: Buffer;
+
+    switch (targetFormat) {
+        case 'jpeg':
+            compressedBuffer = await compressJpeg(buffer, metadata.size, options);
+            break;
+        case 'png':
+            compressedBuffer = await compressPng(buffer, metadata.size, options);
+            break;
+        case 'webp':
+            compressedBuffer = await compressWebp(buffer, options);
+            break;
+        case 'avif':
+            compressedBuffer = await compressAvif(buffer, options);
+            break;
+        default:
+            // 对于不支持的格式，直接返回原始 buffer
+            compressedBuffer = buffer;
+    }
+
+    return {
+        buffer: compressedBuffer,
+        originalSize: metadata.size,
+        compressedSize: compressedBuffer.length,
+        format: targetFormat,
+    };
+}

package/src/services/image-loader.ts

@@ -0,0 +1,49 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { isUrl } from '../utils/index.js';
+
+/**
+ * 加载图片
+ * 支持本地文件路径和远程 URL
+ */
+export async function loadImage(source: string): Promise<Buffer> {
+    if (isUrl(source)) {
+        return loadFromUrl(source);
+    } else {
+        return loadFromFile(source);
+    }
+}
+
+/**
+ * 从本地文件加载
+ */
+async function loadFromFile(filePath: string): Promise<Buffer> {
+    const absolutePath = path.isAbsolute(filePath)
+        ? filePath
+        : path.resolve(process.cwd(), filePath);
+
+    try {
+        const buffer = await fs.readFile(absolutePath);
+        return buffer;
+    } catch (error) {
+        throw new Error(`无法读取文件: ${absolutePath} - ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+
+/**
+ * 从远程 URL 加载
+ */
+async function loadFromUrl(url: string): Promise<Buffer> {
+    try {
+        const response = await fetch(url);
+
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    } catch (error) {
+        throw new Error(`无法下载图片: ${url} - ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/src/services/uploader.ts

@@ -0,0 +1,85 @@
+import type { ImageFormat } from '../types/index.js';
+import { getConfig } from '../config.js';
+
+interface UploadResponse {
+    url?: string;
+    dm_error?: number;
+    error_msg?: string;
+    [key: string]: unknown;
+}
+
+/**
+ * 获取 MIME 类型
+ */
+function getMimeType(format: ImageFormat): string {
+    const mimeTypes: Record<ImageFormat, string> = {
+        'jpeg': 'image/jpeg',
+        'png': 'image/png',
+        'webp': 'image/webp',
+        'avif': 'image/avif',
+        'gif': 'image/gif',
+        'tiff': 'image/tiff',
+    };
+    return mimeTypes[format] ?? 'application/octet-stream';
+}
+
+/**
+ * 生成文件名
+ */
+function generateFilename(format: ImageFormat): string {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    const extension = format === 'jpeg' ? 'jpg' : format;
+    return `image_${timestamp}_${random}.${extension}`;
+}
+
+/**
+ * 上传图片到图床
+ */
+export async function uploadImage(
+    buffer: Buffer,
+    format: ImageFormat
+): Promise<string> {
+    const filename = generateFilename(format);
+    const mimeType = getMimeType(format);
+
+    console.error(`[MCP] 准备上传: ${filename}, MIME: ${mimeType}, 大小: ${buffer.length} bytes`);
+
+    // 创建 FormData - 使用 File 对象确保正确的 MIME 类型
+
+    // 在 Node.js/Bun 中使用 File 对象
+    const file = new File([buffer], filename, { type: mimeType });
+
+    try {
+        const { uploadUrl } = getConfig();
+        const response = await fetch(uploadUrl, {
+            method: 'POST',
+            body: file,
+        });
+
+        const responseText = await response.text();
+        console.error(`[MCP] 上传响应: ${responseText}`);
+
+        let result: UploadResponse;
+        try {
+            result = JSON.parse(responseText) as UploadResponse;
+        } catch {
+            throw new Error(`上传响应解析失败: ${responseText}`);
+        }
+
+        if (result.dm_error) {
+            throw new Error(`上传失败 (${result.dm_error}): ${result.error_msg ?? '未知错误'}`);
+        }
+
+        if (!result.url) {
+            throw new Error(`上传响应缺少 url 字段: ${responseText}`);
+        }
+
+        return result.url;
+    } catch (error) {
+        if (error instanceof Error && (error.message.startsWith('上传') || error.message.includes('dm_error'))) {
+            throw error;
+        }
+        throw new Error(`上传请求失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

package/src/strategies/avif.ts

@@ -0,0 +1,32 @@
+import sharp from 'sharp';
+import type { CompressionOptions } from '../types/index.js';
+
+/**
+ * AVIF 压缩策略
+ * 
+ * 自动模式：lossless=true (无损)
+ * 手动模式：使用指定 quality（默认 50）
+ */
+export async function compressAvif(
+    buffer: Buffer,
+    options: CompressionOptions
+): Promise<Buffer> {
+    if (options.autoCompress) {
+        // 自动模式：无损压缩
+        return sharp(buffer)
+            .avif({
+                lossless: true,
+                effort: 6,
+            })
+            .toBuffer();
+    } else {
+        // 手动模式
+        const quality = options.quality ?? 50;
+        return sharp(buffer)
+            .avif({
+                quality,
+                effort: 4,
+            })
+            .toBuffer();
+    }
+}

package/src/strategies/jpeg.ts

@@ -0,0 +1,44 @@
+import sharp from 'sharp';
+import type { CompressionOptions } from '../types/index.js';
+
+/**
+ * JPEG 压缩策略
+ * 
+ * 自动模式：
+ * - < 500KB → quality=78 + mozjpeg 优化
+ * - > 2MB → quality=65 + mozjpeg 优化
+ * - 常规 → quality=72 + mozjpeg 优化
+ * 
+ * 手动模式：使用指定 quality（默认 85）
+ */
+export async function compressJpeg(
+    buffer: Buffer,
+    originalSize: number,
+    options: CompressionOptions
+): Promise<Buffer> {
+    let quality: number;
+
+    if (options.autoCompress) {
+        // 自动模式：根据文件大小选择质量
+        if (originalSize < 500 * 1024) {
+            // < 500KB：较高质量
+            quality = 78;
+        } else if (originalSize > 2 * 1024 * 1024) {
+            // > 2MB：较低质量以获得更好压缩
+            quality = 65;
+        } else {
+            // 常规区间
+            quality = 72;
+        }
+    } else {
+        // 手动模式
+        quality = options.quality ?? 85;
+    }
+
+    return sharp(buffer)
+        .jpeg({
+            quality,
+            mozjpeg: true, // 使用 mozjpeg 高级优化
+        })
+        .toBuffer();
+}

package/src/strategies/png.ts

@@ -0,0 +1,55 @@
+import sharp from 'sharp';
+import type { CompressionOptions } from '../types/index.js';
+
+/**
+ * PNG 压缩策略
+ * 
+ * 自动模式：
+ * - 有损量化: palette=true, quality 65-95
+ * - 压缩等级根据文件大小动态调整
+ * 
+ * 手动模式：无损压缩 + 高压缩等级
+ */
+export async function compressPng(
+    buffer: Buffer,
+    originalSize: number,
+    options: CompressionOptions
+): Promise<Buffer> {
+    if (options.autoCompress) {
+        // 自动模式：使用有损量化
+        // 根据文件大小选择压缩等级
+        let compressionLevel: number;
+        let quality: number;
+
+        if (originalSize > 2 * 1024 * 1024) {
+            // > 2MB：更激进的压缩
+            compressionLevel = 9;
+            quality = 65;
+        } else if (originalSize > 500 * 1024) {
+            // 500KB - 2MB
+            compressionLevel = 8;
+            quality = 75;
+        } else {
+            // < 500KB
+            compressionLevel = 6;
+            quality = 85;
+        }
+
+        return sharp(buffer)
+            .png({
+                palette: true, // 启用量化 (24位 → 8位)
+                quality,       // 量化质量
+                compressionLevel,
+                effort: 7,     // 优化努力程度
+            })
+            .toBuffer();
+    } else {
+        // 手动模式：无损压缩
+        return sharp(buffer)
+            .png({
+                compressionLevel: 9,
+                effort: 10,
+            })
+            .toBuffer();
+    }
+}

package/src/strategies/webp.ts

@@ -0,0 +1,24 @@
+import sharp from 'sharp';
+import type { CompressionOptions } from '../types/index.js';
+
+/**
+ * WebP 压缩策略
+ * 
+ * 自动模式：quality=75, alphaQuality=100, effort=4
+ * 手动模式：使用指定 quality（默认 75）
+ */
+export async function compressWebp(
+    buffer: Buffer,
+    options: CompressionOptions
+): Promise<Buffer> {
+    const quality = options.autoCompress ? 75 : (options.quality ?? 75);
+
+    return sharp(buffer)
+        .webp({
+            quality,
+            alphaQuality: 100, // 保持 alpha 通道质量
+            effort: options.autoCompress ? 4 : 6,
+            smartSubsample: true, // 智能子采样
+        })
+        .toBuffer();
+}

package/src/tools/upload-image.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { loadImage } from '../services/image-loader.js';
+import { compressImage, getImageMetadata } from '../services/compressor.js';
+import { uploadImage } from '../services/uploader.js';
+import { formatBytes, calculateCompressionRatio } from '../utils/index.js';
+import type { ImageFormat, UploadResult } from '../types/index.js';
+
+/**
+ * 上传图片工具的参数 Schema
+ */
+export const uploadImageSchema = z.object({
+    source: z
+        .string()
+        .describe('图片来源：本地文件路径或远程 URL'),
+    skipCompress: z
+        .boolean()
+        .default(false)
+        .describe('是否跳过压缩，直接上传原图（默认关闭）'),
+    autoCompress: z
+        .boolean()
+        .default(true)
+        .describe('是否启用智能自动压缩（默认开启），仅在 skipCompress=false 时生效'),
+    quality: z
+        .number()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe('手动压缩质量 (1-100)，仅在 skipCompress=false 且 autoCompress=false 时生效'),
+    format: z
+        .enum(['jpeg', 'png', 'webp', 'avif'])
+        .optional()
+        .describe('输出格式（可选，默认保持原格式）'),
+});
+
+export type UploadImageParams = z.infer<typeof uploadImageSchema>;
+
+/**
+ * 执行图片上传
+ */
+export async function executeUploadImage(
+    params: UploadImageParams
+): Promise<UploadResult> {
+    const { source, skipCompress, autoCompress, quality, format } = params;
+
+    // 1. 加载图片
+    console.error(`[MCP] 正在加载图片: ${source}`);
+    const imageBuffer = await loadImage(source);
+    console.error(`[MCP] 图片已加载: ${formatBytes(imageBuffer.length)}`);
+
+    let finalBuffer: Buffer;
+    let originalSize: number;
+    let compressedSize: number;
+    let imageFormat: ImageFormat;
+
+    if (skipCompress) {
+        // 跳过压缩，直接使用原图
+        console.error(`[MCP] 跳过压缩，使用原图上传`);
+        const metadata = await getImageMetadata(imageBuffer);
+        finalBuffer = imageBuffer;
+        originalSize = imageBuffer.length;
+        compressedSize = imageBuffer.length;
+        imageFormat = format as ImageFormat ?? metadata.format;
+    } else {
+        // 2. 压缩图片
+        console.error(`[MCP] 正在压缩图片 (autoCompress=${autoCompress})`);
+        const compressionResult = await compressImage(imageBuffer, {
+            autoCompress,
+            quality,
+            format: format as ImageFormat | undefined,
+        });
+
+        const ratio = calculateCompressionRatio(
+            compressionResult.originalSize,
+            compressionResult.compressedSize
+        );
+        console.error(
+            `[MCP] 压缩完成: ${formatBytes(compressionResult.originalSize)} → ${formatBytes(compressionResult.compressedSize)} (${ratio}%)`
+        );
+
+        finalBuffer = compressionResult.buffer;
+        originalSize = compressionResult.originalSize;
+        compressedSize = compressionResult.compressedSize;
+        imageFormat = compressionResult.format;
+    }
+
+    // 3. 上传图片
+    console.error(`[MCP] 正在上传图片...`);
+    const url = await uploadImage(finalBuffer, imageFormat);
+    console.error(`[MCP] 上传成功: ${url}`);
+
+    const ratio = calculateCompressionRatio(originalSize, compressedSize);
+
+    return {
+        url,
+        originalSize,
+        compressedSize,
+        compressionRatio: ratio,
+    };
+}
+

package/src/types/index.ts

@@ -0,0 +1,46 @@
+/**
+ * 支持的图片格式
+ */
+export type ImageFormat = 'jpeg' | 'png' | 'webp' | 'avif' | 'gif' | 'tiff';
+
+/**
+ * 压缩选项
+ */
+export interface CompressionOptions {
+    /** 是否启用自动压缩 */
+    autoCompress: boolean;
+    /** 手动压缩质量 (1-100) */
+    quality?: number;
+    /** 输出格式 */
+    format?: ImageFormat;
+}
+
+/**
+ * 图片元数据
+ */
+export interface ImageMetadata {
+    format: ImageFormat;
+    width: number;
+    height: number;
+    size: number;
+}
+
+/**
+ * 压缩结果
+ */
+export interface CompressionResult {
+    buffer: Buffer;
+    originalSize: number;
+    compressedSize: number;
+    format: ImageFormat;
+}
+
+/**
+ * 上传结果
+ */
+export interface UploadResult {
+    url: string;
+    originalSize: number;
+    compressedSize: number;
+    compressionRatio: number;
+}

package/src/utils/index.ts

@@ -0,0 +1,30 @@
+/**
+ * 判断是否为 URL
+ */
+export function isUrl(input: string): boolean {
+    try {
+        const url = new URL(input);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * 格式化文件大小
+ */
+export function formatBytes(bytes: number): string {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
+}
+
+/**
+ * 计算压缩比
+ */
+export function calculateCompressionRatio(original: number, compressed: number): number {
+    if (original === 0) return 0;
+    return Math.round((1 - compressed / original) * 100);
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "lib": [
+            "ES2022"
+        ],
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "resolveJsonModule": true,
+        "declaration": true,
+        "declarationMap": true,
+        "sourceMap": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}