@c5t8fbt-wy/mcp-image-extractor 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ifmelate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,263 @@
+# MCP Image Extractor (Enhanced Fork)
+
+Enhanced MCP server for extracting and converting images to base64 for LLM analysis with **configurable quality settings**.
+
+## What's New in This Fork
+
+- **Configurable Processing** - Control image dimensions and quality via environment variables  
+- **Increased Limits** - 50MB default download limit (vs 10MB in original)  
+- **Better Documentation** - Comprehensive guides for optimization  
+- **Active Maintenance** - Regular updates and improvements
+
+## Features
+
+This MCP server provides tools for AI assistants to:
+- Extract images from local files
+- Extract images from URLs  
+- Process base64-encoded images
+- **NEW**: Configurable dimensions (512×512 to 1568×1568)
+- **NEW**: Adjustable compression quality
+- **NEW**: Environment variable configuration
+
+## Installation
+
+### Recommended: Using npx (Easiest)
+
+```json
+{
+  "mcpServers": {
+    "image-extractor": {
+      "command": "npx",
+      "args": ["-y", "@c5t8fbt-wy/mcp-image-extractor"],
+      "env": {
+        "DEFAULT_MAX_WIDTH": "1024",
+        "DEFAULT_MAX_HEIGHT": "1024",
+        "COMPRESSION_QUALITY": "90"
+      }
+    }
+  }
+}
+```
+
+### Alternative: Local Installation
+
+```bash
+# Clone your fork
+git clone https://github.com/C5T8fBt-WY/mcp-image-extractor_fork.git
+cd mcp-image-extractor_fork
+npm install
+npm run build
+```
+
+Then configure:
+
+```json
+{
+  "mcpServers": {
+    "image-extractor": {
+      "command": "node",
+      "args": ["c:/path/to/mcp-image-extractor_fork/dist/index.js"],
+      "env": {
+        "DEFAULT_MAX_WIDTH": "1024",
+        "COMPRESSION_QUALITY": "90"
+      }
+    }
+  }
+}
+```
+
+## Configuration Options
+
+### Environment Variables
+
+| Variable                | Default    | Description                       |
+| ----------------------- | ---------- | --------------------------------- |
+| `DEFAULT_MAX_WIDTH`     | `512`      | Maximum image width (pixels)      |
+| `DEFAULT_MAX_HEIGHT`    | `512`      | Maximum image height (pixels)     |
+| `COMPRESSION_QUALITY`   | `80`       | JPEG/WebP quality (1-100)         |
+| `PNG_COMPRESSION_LEVEL` | `9`        | PNG compression (0-9, lossless)   |
+| `MAX_IMAGE_SIZE`        | `52428800` | Max download size (50MB in bytes) |
+| `ALLOWED_DOMAINS`       | Empty      | Comma-separated allowed domains   |
+
+### Quality Presets
+
+#### Minimal Context Usage (Default)
+```json
+"env": {
+  "DEFAULT_MAX_WIDTH": "512",
+  "DEFAULT_MAX_HEIGHT": "512",
+  "COMPRESSION_QUALITY": "80"
+}
+```
+**Best for:** Processing many images, limited context
+
+#### Balanced Quality
+```json
+"env": {
+  "DEFAULT_MAX_WIDTH": "768",
+  "DEFAULT_MAX_HEIGHT": "768",
+  "COMPRESSION_QUALITY": "85"
+}
+```
+**Best for:** Reading small text, charts, diagrams
+
+#### Maximum Quality (Claude-compatible)
+```json
+"env": {
+  "DEFAULT_MAX_WIDTH": "1568",
+  "DEFAULT_MAX_HEIGHT": "1568",
+  "COMPRESSION_QUALITY": "90",
+  "MAX_IMAGE_SIZE": "104857600"
+}
+```
+**Best for:** Detailed screenshots, technical documentation
+
+## Available Tools
+
+### extract_image_from_file
+
+Extract and analyze images from local file paths.
+
+**Parameters:**
+- `file_path` (required): Path to the image file
+
+**Example:**
+```
+Analyze the test failure: test-results/checkout-failed.png
+```
+
+### extract_image_from_url
+
+Extract and analyze images from web URLs.
+
+**Parameters:**
+- `url` (required): URL of the image
+
+**Example:**
+```
+What's in this image? https://example.com/chart.png
+```
+
+### extract_image_from_base64
+
+Process base64-encoded images.
+
+**Parameters:**
+- `base64` (required): Base64-encoded image data
+- `mime_type` (optional, default: "image/png"): MIME type
+
+## Use Cases
+
+✅ **Analyzing Playwright Test Results**
+```
+"Analyze this test failure screenshot: ./test-results/login-error.png"
+```
+
+✅ **Processing External Images**
+```
+"Extract the chart from https://reports.company.com/Q4-summary.png"
+```
+
+✅ **High-Resolution Screenshots**
+- Supports large images (up to 50MB by default)
+- Configurable output dimensions for quality control
+- Automatic format detection and optimization
+
+## Context Usage Examples
+
+| Configuration | Dimensions | Approx Tokens | Use Case             |
+| ------------- | ---------- | ------------- | -------------------- |
+| Default       | 512×288    | ~900          | Quick analysis       |
+| Balanced      | 768×432    | ~2,100        | Charts & diagrams    |
+| Maximum       | 1568×882   | ~8,000        | Detailed screenshots |
+
+## Troubleshooting
+
+### "maxContentLength exceeded" Error
+
+Increase the download limit:
+```json
+"env": {
+  "MAX_IMAGE_SIZE": "104857600"
+}
+```
+
+### Images Too Blurry
+
+Increase dimensions:
+```json
+"env": {
+  "DEFAULT_MAX_WIDTH": "1024",
+  "DEFAULT_MAX_HEIGHT": "1024"
+}
+```
+
+### "Unsupported image format" (BMP files)
+
+BMP files with .png extension need conversion:
+```powershell
+# PowerShell
+Add-Type -AssemblyName System.Drawing
+$bmp = [System.Drawing.Image]::FromFile("path/to/file.png")
+$bmp.Save("path/to/file_actual.png", [System.Drawing.Imaging.ImageFormat]::Png)
+$bmp.Dispose()
+```
+
+## Publishing to npm
+
+This fork is published as `@c5t8fbt-wy/mcp-image-extractor` on npm.
+
+To publish updates:
+
+```bash
+# Update version in package.json
+npm version patch  # or minor/major
+
+# Build
+npm run build
+
+# Publish (requires npm login)
+npm publish
+```
+
+## Differences from Original
+
+| Feature                 | Original | This Fork     |
+| ----------------------- | -------- | ------------- |
+| Max download size       | 10MB     | 50MB          |
+| Configurable dimensions | ❌        | ✅             |
+| Configurable quality    | ❌        | ✅             |
+| Environment vars        | Limited  | Full          |
+| Documentation           | Basic    | Comprehensive |
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run in dev mode
+npm run dev
+
+# Build
+npm run build
+
+# Run tests
+npm test
+```
+
+## License
+
+MIT
+
+## Links
+
+- **GitHub**: https://github.com/C5T8fBt-WY/mcp-image-extractor_fork
+- **npm**: https://www.npmjs.com/package/@c5t8fbt-wy/mcp-image-extractor
+- **Original**: https://github.com/ifmelate/mcp-image-extractor
+
+## Credits
+
+Based on [mcp-image-extractor](https://github.com/ifmelate/mcp-image-extractor) by [@ifmelate](https://github.com/ifmelate)
+
+Enhanced with configurable settings and improved documentation by [@C5T8fBt-WY](https://github.com/C5T8fBt-WY)

package/dist/image-utils.js

@@ -0,0 +1,389 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImageFromFile = extractImageFromFile;
+exports.extractImageFromUrl = extractImageFromUrl;
+exports.extractImageFromBase64 = extractImageFromBase64;
+const axios_1 = __importDefault(require("axios"));
+const sharp_1 = __importDefault(require("sharp"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Configuration
+const MAX_IMAGE_SIZE = parseInt(process.env.MAX_IMAGE_SIZE || '52428800', 10); // 50MB default (increased from 10MB)
+const ALLOWED_DOMAINS = process.env.ALLOWED_DOMAINS ? process.env.ALLOWED_DOMAINS.split(',') : [];
+// Default max dimensions for optimal LLM context usage (can be overridden via env vars)
+const DEFAULT_MAX_WIDTH = parseInt(process.env.DEFAULT_MAX_WIDTH || '512', 10);
+const DEFAULT_MAX_HEIGHT = parseInt(process.env.DEFAULT_MAX_HEIGHT || '512', 10);
+// Compression quality (can be overridden via env var, 1-100, higher = better quality but larger file)
+const COMPRESSION_QUALITY = parseInt(process.env.COMPRESSION_QUALITY || '80', 10);
+// PNG compression level (can be overridden via env var, 0-9, higher = smaller file but slower)
+const PNG_COMPRESSION_LEVEL = parseInt(process.env.PNG_COMPRESSION_LEVEL || '9', 10);
+const COMPRESSION_OPTIONS = {
+    jpeg: { quality: COMPRESSION_QUALITY },
+    jpg: { quality: COMPRESSION_QUALITY },
+    png: { quality: COMPRESSION_QUALITY, compressionLevel: PNG_COMPRESSION_LEVEL },
+    webp: { quality: COMPRESSION_QUALITY },
+    gif: {},
+    svg: {},
+    avif: { quality: COMPRESSION_QUALITY },
+    tiff: { quality: COMPRESSION_QUALITY }
+};
+// Helper function to compress image based on format
+async function compressImage(imageBuffer, formatStr) {
+    const sharpInstance = (0, sharp_1.default)(imageBuffer);
+    const format = formatStr.toLowerCase();
+    // Check if format is supported
+    if (format in COMPRESSION_OPTIONS) {
+        const options = COMPRESSION_OPTIONS[format];
+        // Use specific methods based on format
+        switch (format) {
+            case 'jpeg':
+            case 'jpg':
+                return await sharpInstance.jpeg(options).toBuffer();
+            case 'png':
+                return await sharpInstance.png(options).toBuffer();
+            case 'webp':
+                return await sharpInstance.webp(options).toBuffer();
+            case 'avif':
+                return await sharpInstance.avif(options).toBuffer();
+            case 'tiff':
+                return await sharpInstance.tiff(options).toBuffer();
+            // For formats without specific compression options
+            case 'gif':
+            case 'svg':
+                return await sharpInstance.toBuffer();
+        }
+    }
+    // Default to jpeg if format not supported
+    return await sharpInstance.jpeg(COMPRESSION_OPTIONS.jpeg).toBuffer();
+}
+// Extract image from file
+async function extractImageFromFile(params) {
+    try {
+        const { file_path, resize, max_width, max_height } = params;
+        // Check if file exists
+        if (!fs.existsSync(file_path)) {
+            return {
+                content: [{ type: "text", text: `Error: File ${file_path} does not exist` }],
+                isError: true
+            };
+        }
+        // Read file
+        let imageBuffer = fs.readFileSync(file_path);
+        // Check size
+        if (imageBuffer.length > MAX_IMAGE_SIZE) {
+            return {
+                content: [{ type: "text", text: `Error: Image size exceeds maximum allowed size of ${MAX_IMAGE_SIZE} bytes` }],
+                isError: true
+            };
+        }
+        // Process the image
+        let metadata = await (0, sharp_1.default)(imageBuffer).metadata();
+        // Always resize to ensure the base64 representation is reasonable
+        // This will help avoid consuming too much of the context window
+        if (metadata.width && metadata.height) {
+            // Use provided dimensions or fallback to defaults for optimal LLM context usage
+            const targetWidth = Math.min(metadata.width, DEFAULT_MAX_WIDTH);
+            const targetHeight = Math.min(metadata.height, DEFAULT_MAX_HEIGHT);
+            // Only resize if needed
+            if (metadata.width > targetWidth || metadata.height > targetHeight) {
+                imageBuffer = await (0, sharp_1.default)(imageBuffer)
+                    .resize({
+                    width: targetWidth,
+                    height: targetHeight,
+                    fit: 'inside',
+                    withoutEnlargement: true
+                })
+                    .toBuffer();
+                // Update metadata after resize
+                metadata = await (0, sharp_1.default)(imageBuffer).metadata();
+            }
+        }
+        // Determine mime type based on file extension
+        const fileExt = path.extname(file_path).toLowerCase();
+        let mimeType = 'image/jpeg';
+        let format = 'jpeg';
+        if (fileExt === '.png') {
+            mimeType = 'image/png';
+            format = 'png';
+        }
+        else if (fileExt === '.jpg' || fileExt === '.jpeg') {
+            mimeType = 'image/jpeg';
+            format = 'jpeg';
+        }
+        else if (fileExt === '.gif') {
+            mimeType = 'image/gif';
+            format = 'gif';
+        }
+        else if (fileExt === '.webp') {
+            mimeType = 'image/webp';
+            format = 'webp';
+        }
+        else if (fileExt === '.svg') {
+            mimeType = 'image/svg+xml';
+            format = 'svg';
+        }
+        else if (fileExt === '.avif') {
+            mimeType = 'image/avif';
+            format = 'avif';
+        }
+        // Compress the image based on its format
+        try {
+            imageBuffer = await compressImage(imageBuffer, format);
+        }
+        catch (compressionError) {
+            console.warn('Compression warning, using original image:', compressionError);
+            // Continue with the original image if compression fails
+        }
+        // Convert to base64
+        const base64 = imageBuffer.toString('base64');
+        // Return both text and image content
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        width: metadata.width,
+                        height: metadata.height,
+                        format: metadata.format,
+                        size: imageBuffer.length
+                    })
+                },
+                {
+                    type: "image",
+                    data: base64,
+                    mimeType: mimeType
+                }
+            ]
+        };
+    }
+    catch (error) {
+        console.error('Error processing image file:', error);
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+}
+// Extract image from URL
+async function extractImageFromUrl(params) {
+    try {
+        const { url, resize, max_width, max_height } = params;
+        // Validate URL
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            return {
+                content: [{ type: "text", text: "Error: URL must start with http:// or https://" }],
+                isError: true
+            };
+        }
+        // Domain validation if ALLOWED_DOMAINS is set
+        if (ALLOWED_DOMAINS.length > 0) {
+            const urlObj = new URL(url);
+            const domain = urlObj.hostname;
+            const isAllowed = ALLOWED_DOMAINS.some((allowedDomain) => domain === allowedDomain || domain.endsWith(`.${allowedDomain}`));
+            if (!isAllowed) {
+                return {
+                    content: [{ type: "text", text: `Error: Domain ${domain} is not in the allowed domains list` }],
+                    isError: true
+                };
+            }
+        }
+        // Fetch the image
+        const response = await axios_1.default.get(url, {
+            responseType: 'arraybuffer',
+            maxContentLength: MAX_IMAGE_SIZE,
+        });
+        // Process the image
+        let imageBuffer = Buffer.from(response.data);
+        let metadata = await (0, sharp_1.default)(imageBuffer).metadata();
+        // Always resize to ensure the base64 representation is reasonable
+        // This will help avoid consuming too much of the context window
+        if (metadata.width && metadata.height) {
+            // Use provided dimensions or fallback to defaults for optimal LLM context usage
+            const targetWidth = Math.min(metadata.width, DEFAULT_MAX_WIDTH);
+            const targetHeight = Math.min(metadata.height, DEFAULT_MAX_HEIGHT);
+            // Only resize if needed
+            if (metadata.width > targetWidth || metadata.height > targetHeight) {
+                imageBuffer = await (0, sharp_1.default)(imageBuffer)
+                    .resize({
+                    width: targetWidth,
+                    height: targetHeight,
+                    fit: 'inside',
+                    withoutEnlargement: true
+                })
+                    .toBuffer();
+                // Update metadata after resize
+                metadata = await (0, sharp_1.default)(imageBuffer).metadata();
+            }
+        }
+        // Compress the image based on its format
+        try {
+            const format = metadata.format || 'jpeg';
+            imageBuffer = await compressImage(imageBuffer, format);
+        }
+        catch (compressionError) {
+            console.warn('Compression warning, using original image:', compressionError);
+            // Continue with the original image if compression fails
+        }
+        // Convert to base64
+        const base64 = imageBuffer.toString('base64');
+        const mimeType = response.headers['content-type'] || 'image/jpeg';
+        // Return both text and image content
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        width: metadata.width,
+                        height: metadata.height,
+                        format: metadata.format,
+                        size: imageBuffer.length
+                    })
+                },
+                {
+                    type: "image",
+                    data: base64,
+                    mimeType: mimeType
+                }
+            ]
+        };
+    }
+    catch (error) {
+        console.error('Error processing image from URL:', error);
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+}
+// Extract image from base64
+async function extractImageFromBase64(params) {
+    try {
+        const { base64, mime_type, resize, max_width, max_height } = params;
+        // Decode base64
+        let imageBuffer;
+        try {
+            imageBuffer = Buffer.from(base64, 'base64');
+            // Quick validation - valid base64 strings should be decodable
+            if (imageBuffer.length === 0) {
+                throw new Error("Invalid base64 string - decoded to empty buffer");
+            }
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error: Invalid base64 string - ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true
+            };
+        }
+        // Check size
+        if (imageBuffer.length > MAX_IMAGE_SIZE) {
+            return {
+                content: [{ type: "text", text: `Error: Image size exceeds maximum allowed size of ${MAX_IMAGE_SIZE} bytes` }],
+                isError: true
+            };
+        }
+        // Process the image
+        let metadata;
+        try {
+            metadata = await (0, sharp_1.default)(imageBuffer).metadata();
+        }
+        catch (e) {
+            return {
+                content: [{ type: "text", text: `Error: Could not process image data - ${e instanceof Error ? e.message : String(e)}` }],
+                isError: true
+            };
+        }
+        // Always resize to ensure the base64 representation is reasonable
+        // This will help avoid consuming too much of the context window
+        if (metadata.width && metadata.height) {
+            // Use provided dimensions or fallback to defaults for optimal LLM context usage
+            const targetWidth = Math.min(metadata.width, DEFAULT_MAX_WIDTH);
+            const targetHeight = Math.min(metadata.height, DEFAULT_MAX_HEIGHT);
+            // Only resize if needed
+            if (metadata.width > targetWidth || metadata.height > targetHeight) {
+                imageBuffer = await (0, sharp_1.default)(imageBuffer)
+                    .resize({
+                    width: targetWidth,
+                    height: targetHeight,
+                    fit: 'inside',
+                    withoutEnlargement: true
+                })
+                    .toBuffer();
+                // Update metadata after resize
+                metadata = await (0, sharp_1.default)(imageBuffer).metadata();
+            }
+        }
+        // Compress the image based on its format
+        try {
+            const format = metadata.format || mime_type.split('/')[1] || 'jpeg';
+            imageBuffer = await compressImage(imageBuffer, format);
+        }
+        catch (compressionError) {
+            console.warn('Compression warning, using original image:', compressionError);
+            // Continue with the original image if compression fails
+        }
+        // Convert back to base64
+        const processedBase64 = imageBuffer.toString('base64');
+        // Return both text and image content
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        width: metadata.width,
+                        height: metadata.height,
+                        format: metadata.format,
+                        size: imageBuffer.length
+                    })
+                },
+                {
+                    type: "image",
+                    data: processedBase64,
+                    mimeType: mime_type
+                }
+            ]
+        };
+    }
+    catch (error) {
+        console.error('Error processing base64 image:', error);
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true
+        };
+    }
+}

package/dist/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const dotenv = __importStar(require("dotenv"));
+const image_utils_1 = require("./image-utils");
+dotenv.config();
+// Create an MCP server
+const server = new mcp_js_1.McpServer({
+    name: "mcp-image-extractor",
+    description: "MCP server for analyzing of images from files, URLs, and base64 data for visual content understanding, text extraction (OCR), and object recognition in screenshots and photos",
+    version: "1.0.0"
+});
+// Add extract_image_from_file tool
+server.tool("extract_image_from_file", "Extract and analyze images from local file paths. Supports visual content understanding, OCR text extraction, and object recognition for screenshots, photos, diagrams, and documents.", {
+    file_path: zod_1.z.string().describe("Path to the image file to analyze (supports screenshots, photos, diagrams, and documents in PNG, JPG, GIF, WebP formats)"),
+    resize: zod_1.z.boolean().default(true).describe("For backward compatibility only. Images are always automatically resized to optimal dimensions (max 512x512) for LLM analysis"),
+    max_width: zod_1.z.number().default(512).describe("For backward compatibility only. Default maximum width is now 512px"),
+    max_height: zod_1.z.number().default(512).describe("For backward compatibility only. Default maximum height is now 512px")
+}, async (args, extra) => {
+    const result = await (0, image_utils_1.extractImageFromFile)(args);
+    return result;
+});
+// Add extract_image_from_url tool
+server.tool("extract_image_from_url", "Extract and analyze images from web URLs. Perfect for analyzing web screenshots, online photos, diagrams, or any image accessible via HTTP/HTTPS for visual content analysis and text extraction.", {
+    url: zod_1.z.string().describe("URL of the image to analyze for visual content, text extraction, or object recognition (supports web screenshots, photos, diagrams)"),
+    resize: zod_1.z.boolean().default(true).describe("For backward compatibility only. Images are always automatically resized to optimal dimensions (max 512x512) for LLM analysis"),
+    max_width: zod_1.z.number().default(512).describe("For backward compatibility only. Default maximum width is now 512px"),
+    max_height: zod_1.z.number().default(512).describe("For backward compatibility only. Default maximum height is now 512px")
+}, async (args, extra) => {
+    const result = await (0, image_utils_1.extractImageFromUrl)(args);
+    return result;
+});
+// Add extract_image_from_base64 tool
+server.tool("extract_image_from_base64", "Extract and analyze images from base64-encoded data. Ideal for processing screenshots from clipboard, dynamically generated images, or images embedded in applications without requiring file system access.", {
+    base64: zod_1.z.string().describe("Base64-encoded image data to analyze (useful for screenshots, images from clipboard, or dynamically generated visuals)"),
+    mime_type: zod_1.z.string().default("image/png").describe("MIME type of the image (e.g., image/png, image/jpeg)"),
+    resize: zod_1.z.boolean().default(true).describe("For backward compatibility only. Images are always automatically resized to optimal dimensions (max 512x512) for LLM analysis"),
+    max_width: zod_1.z.number().default(512).describe("For backward compatibility only. Default maximum width is now 512px"),
+    max_height: zod_1.z.number().default(512).describe("For backward compatibility only. Default maximum height is now 512px")
+}, async (args, extra) => {
+    const result = await (0, image_utils_1.extractImageFromBase64)(args);
+    return result;
+});
+// Start the server using stdio transport
+const transport = new stdio_js_1.StdioServerTransport();
+server.connect(transport).catch((error) => {
+    console.error('Error starting MCP server:', error);
+    process.exit(1);
+});
+console.log('MCP Image Extractor server started in stdio mode');

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@c5t8fbt-wy/mcp-image-extractor",
+  "version": "1.2.0",
+  "description": "Enhanced MCP server for extracting and converting images to base64 for LLM analysis with configurable quality settings",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-image-extractor": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('fs').chmodSync('dist/index.js', '755')\"",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint . --ext .ts",
+    "test": "jest --no-cache --passWithNoTests",
+    "test:ci": "jest --ci",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "image",
+    "base64",
+    "llm",
+    "smithery",
+    "image-processing",
+    "sharp",
+    "configurable"
+  ],
+  "author": "C5T8fBt-WY",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.1",
+    "axios": "^1.6.2",
+    "dotenv": "^16.3.1",
+    "sharp": "^0.33.0",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@deploya/smithery-cli": "^0.0.1",
+    "@smithery/cli": "^1.1.46",
+    "@types/axios": "^0.14.4",
+    "@types/dotenv": "^8.2.3",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.10.0",
+    "@types/sharp": "^0.32.0",
+    "@typescript-eslint/eslint-plugin": "^6.12.0",
+    "@typescript-eslint/parser": "^6.12.0",
+    "eslint": "^8.54.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2"
+  },
+  "smithery": {
+    "name": "@c5t8fbt-wy/mcp-image-extractor",
+    "description": "Enhanced MCP server for extracting and converting images to base64 for LLM analysis",
+    "version": "1.2.0",
+    "author": "C5T8fBt-WY",
+    "license": "MIT"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/C5T8fBt-WY/mcp-image-extractor_fork"
+  },
+  "homepage": "https://github.com/C5T8fBt-WY/mcp-image-extractor_fork#readme",
+  "bugs": {
+    "url": "https://github.com/C5T8fBt-WY/mcp-image-extractor_fork/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}