@teamflojo/floimg 0.1.0

package/dist/mcp/server.js

@@ -0,0 +1,731 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { readFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import createClient from "../index.js";
+import { loadConfig } from "../config/loader.js";
+import { FloimgError } from "../core/errors.js";
+/**
+ * floimg MCP Server v0.1.0 - Smart Image Generation & Workflow Orchestration
+ *
+ * Key improvements:
+ * - Session workspace: Images stored with IDs, no byte passing between tools
+ * - File path references: Transform/save can reference any image by path or ID
+ * - Pipeline support: Multi-step workflows in a single call
+ * - Better intent routing: Recognizes AI image requests properly
+ */
+// Session workspace for storing images between tool calls
+const SESSION_WORKSPACE = join(process.cwd(), ".floimg", "mcp-session");
+const imageRegistry = new Map();
+// Ensure workspace exists
+async function ensureWorkspace() {
+    if (!existsSync(SESSION_WORKSPACE)) {
+        await mkdir(SESSION_WORKSPACE, { recursive: true });
+    }
+}
+// Generate unique image ID
+function generateImageId() {
+    return `img_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+// Load image from various sources
+async function loadImage(imageId, imagePath, imageBytes, mime) {
+    // Priority 1: imageId (reference to session image)
+    if (imageId) {
+        const registered = imageRegistry.get(imageId);
+        if (!registered) {
+            throw new Error(`Image ID not found: ${imageId}. Use generate_image first to create an image.`);
+        }
+        const bytes = await readFile(registered.path);
+        return {
+            bytes,
+            mime: registered.mime,
+            ...registered.metadata,
+        };
+    }
+    // Priority 2: imagePath (reference to file on disk)
+    if (imagePath) {
+        const bytes = await readFile(imagePath);
+        // Detect MIME type from extension if not provided
+        const detectedMime = mime || detectMimeFromPath(imagePath);
+        return {
+            bytes,
+            mime: detectedMime,
+        };
+    }
+    // Priority 3: imageBytes (base64 encoded, for external images)
+    if (imageBytes && mime) {
+        return {
+            bytes: Buffer.from(imageBytes, "base64"),
+            mime: mime,
+        };
+    }
+    throw new Error("Must provide imageId, imagePath, or imageBytes+mime");
+}
+// Detect MIME type from file path
+function detectMimeFromPath(path) {
+    const ext = path.split('.').pop()?.toLowerCase();
+    const mimeMap = {
+        'svg': 'image/svg+xml',
+        'png': 'image/png',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'webp': 'image/webp',
+        'avif': 'image/avif',
+    };
+    return mimeMap[ext || ''] || 'image/png';
+}
+// Plugin auto-discovery
+async function loadAvailablePlugins(client) {
+    const plugins = [];
+    console.error('[floimg-mcp] Starting plugin discovery...');
+    const potentialPlugins = [
+        { name: 'quickchart', module: '@teamflojo/floimg-quickchart' },
+        { name: 'd3', module: '@teamflojo/floimg-d3' },
+        { name: 'mermaid', module: '@teamflojo/floimg-mermaid' },
+        { name: 'qr', module: '@teamflojo/floimg-qr' },
+        { name: 'screenshot', module: '@teamflojo/floimg-screenshot' },
+    ];
+    for (const { name, module } of potentialPlugins) {
+        try {
+            console.error(`[floimg-mcp] Attempting to load ${module}...`);
+            const plugin = await import(module);
+            if (!plugin.default) {
+                console.error(`[floimg-mcp] ⚠ ${module} has no default export`);
+                continue;
+            }
+            const generator = typeof plugin.default === 'function'
+                ? plugin.default()
+                : plugin.default;
+            client.registerGenerator(generator);
+            plugins.push(name);
+            console.error(`[floimg-mcp] ✓ Loaded plugin: ${name}`);
+        }
+        catch (err) {
+            const error = err;
+            console.error(`[floimg-mcp] ✗ Failed to load ${module}: ${error.message}`);
+        }
+    }
+    console.error(`[floimg-mcp] Plugin discovery complete. Loaded: ${plugins.join(', ') || 'none'}`);
+    if (plugins.length === 0) {
+        console.error('[floimg-mcp] ⚠ No generator plugins found!');
+        console.error('[floimg-mcp] Install with: npm install -g @teamflojo/floimg-quickchart @teamflojo/floimg-mermaid @teamflojo/floimg-qr @teamflojo/floimg-d3 @teamflojo/floimg-screenshot');
+        console.error('[floimg-mcp] Only built-in generators (shapes, openai) will be available.');
+    }
+    return plugins;
+}
+// Smart generator selection based on intent - IMPROVED for v0.4.0
+function selectGenerator(intent, params) {
+    const intentLower = intent.toLowerCase();
+    // QR codes
+    if (intentLower.includes('qr') || intentLower.includes('barcode')) {
+        return 'qr';
+    }
+    // Screenshots
+    if (intentLower.includes('screenshot') || intentLower.includes('capture') ||
+        intentLower.includes('website') || intentLower.includes('webpage') ||
+        intentLower.includes('url') && params.url) {
+        return 'screenshot';
+    }
+    // Diagrams (Mermaid)
+    if (intentLower.includes('flowchart') || intentLower.includes('diagram') ||
+        intentLower.includes('sequence') || intentLower.includes('gantt') ||
+        intentLower.includes('class diagram') || intentLower.includes('entity') ||
+        intentLower.includes('state') || intentLower.includes('mindmap')) {
+        return 'mermaid';
+    }
+    // Charts & Data Visualization (check BEFORE AI detection)
+    if (intentLower.includes('chart') || intentLower.includes('graph') ||
+        intentLower.includes('plot') || intentLower.includes('visualiz')) {
+        // D3 for custom/complex visualizations
+        if (params.render || params.renderString ||
+            intentLower.includes('custom') || intentLower.includes('d3')) {
+            return 'd3';
+        }
+        // QuickChart for standard charts
+        return 'quickchart';
+    }
+    // AI Image Generation - IMPROVED: Better keyword detection
+    // Check for scene descriptions, subjects, art styles, etc.
+    const aiKeywords = [
+        'photo', 'picture', 'illustration', 'painting', 'drawing',
+        'scene', 'image of', 'portrait', 'landscape', 'artwork',
+        'realistic', 'photorealistic', 'stylized', 'artistic',
+        'dall-e', 'ai image', 'ai generated', 'generate image',
+        'person', 'people', 'animal', 'building', 'nature',
+        'stadium', 'player', 'celebrating', 'sunset', 'dramatic'
+    ];
+    const hasAIKeyword = aiKeywords.some(keyword => intentLower.includes(keyword));
+    const hasPromptParam = params.prompt !== undefined;
+    // Route to OpenAI if:
+    // 1. Has AI-related keywords OR
+    // 2. Has prompt parameter OR
+    // 3. Intent describes a scene/subject (more than 5 words)
+    const wordCount = intent.trim().split(/\s+/).length;
+    const isDescriptiveIntent = wordCount > 5 && !intentLower.includes('gradient') && !intentLower.includes('shape');
+    if (hasAIKeyword || hasPromptParam || isDescriptiveIntent) {
+        return 'openai';
+    }
+    // Default to shapes for simple SVG graphics (gradients, basic shapes)
+    return 'shapes';
+}
+// Initialize server
+const server = new Server({
+    name: "floimg",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Define available tools
+const TOOLS = [
+    {
+        name: "generate_image",
+        description: "Generate any type of image. Routes to the appropriate generator based on intent. " +
+            "Supports: AI images (DALL-E), charts (bar, line, pie), diagrams (flowcharts, sequence), " +
+            "QR codes, screenshots, data visualizations (D3), and simple shapes/gradients. " +
+            "Images are saved to session workspace and assigned an imageId for chaining operations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                intent: {
+                    type: "string",
+                    description: "Brief description to route to the right generator and provide simple defaults. " +
+                        "For AI images: intent becomes the prompt (e.g., 'golden retriever in field'). " +
+                        "For QR codes: include the URL (e.g., 'QR code for https://example.com'). " +
+                        "For charts/diagrams: just routing hint (e.g., 'bar chart', 'flowchart') - must provide params with data.",
+                },
+                params: {
+                    type: "object",
+                    description: "Generator-specific parameters. " +
+                        "AI images & QR codes: Optional (auto-filled from intent). " +
+                        "Charts & diagrams: REQUIRED - must provide structured data. " +
+                        "Examples: " +
+                        "Charts: {type: 'bar', data: {labels: [...], datasets: [...]}}. " +
+                        "Diagrams: {code: 'graph TD; A-->B'}. " +
+                        "AI images: {prompt: '...', size: '1024x1024'} (or omit, uses intent). " +
+                        "QR codes: {text: 'https://...'} (or omit if URL in intent).",
+                    default: {},
+                },
+                saveTo: {
+                    type: "string",
+                    description: "Optional: Also save to a destination (filesystem or cloud). " +
+                        "Examples: './output.png', 's3://bucket/key.png', 'r2://bucket/key.png'. " +
+                        "Image is always saved to session workspace regardless.",
+                },
+            },
+            required: ["intent"],
+        },
+    },
+    {
+        name: "transform_image",
+        description: "Transform an image with filters, effects, text, resizing, and more. " +
+            "Reference images by: imageId (from generate_image), imagePath (any file), or imageBytes (base64). " +
+            "Supports: resize, convert, blur, sharpen, grayscale, modulate, tint, roundCorners, " +
+            "addText, addCaption, and preset filters (vintage, vibrant, dramatic, etc.). " +
+            "Transformed image is saved to session workspace with new imageId.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                imageId: {
+                    type: "string",
+                    description: "ID of image from previous generate_image or transform_image call",
+                },
+                imagePath: {
+                    type: "string",
+                    description: "Path to image file on disk (e.g., './my-image.png', 'generated/abc.png')",
+                },
+                imageBytes: {
+                    type: "string",
+                    description: "Base64-encoded image bytes (for external images not in session)",
+                },
+                mime: {
+                    type: "string",
+                    description: "MIME type (required only if using imageBytes, auto-detected for imagePath/imageId)",
+                },
+                operation: {
+                    type: "string",
+                    description: "Transform operation to apply",
+                    enum: [
+                        "convert",
+                        "resize",
+                        "composite",
+                        "optimizeSvg",
+                        "blur",
+                        "sharpen",
+                        "grayscale",
+                        "negate",
+                        "normalize",
+                        "threshold",
+                        "modulate",
+                        "tint",
+                        "extend",
+                        "extract",
+                        "roundCorners",
+                        "addText",
+                        "addCaption",
+                        "preset",
+                    ],
+                },
+                params: {
+                    type: "object",
+                    description: "Parameters for the operation. Examples: " +
+                        "resize: {width: 800, height: 600}, " +
+                        "blur: {sigma: 5}, " +
+                        "modulate: {brightness: 1.2, saturation: 1.3}, " +
+                        "roundCorners: {radius: 20}, " +
+                        "addText: {text: 'Hello', x: 100, y: 100, size: 48, color: '#fff', shadow: true}, " +
+                        "addCaption: {text: 'Caption', position: 'bottom'}, " +
+                        "preset: {name: 'vintage' | 'vibrant' | 'dramatic' | 'soft'}",
+                },
+                to: {
+                    type: "string",
+                    description: "Target MIME type (for convert operation)",
+                },
+                saveTo: {
+                    type: "string",
+                    description: "Optional: Also save to a destination (filesystem or cloud). " +
+                        "Image is always saved to session workspace regardless.",
+                },
+            },
+            required: ["operation"],
+        },
+    },
+    {
+        name: "save_image",
+        description: "Save an image to filesystem or cloud storage (S3, Tigris, R2, etc.). " +
+            "Reference images by: imageId (from previous calls), imagePath (any file), or imageBytes (base64). " +
+            "Supports smart destination routing: './output.png' → filesystem, 's3://bucket/key' → S3. " +
+            "Returns public URL if saving to cloud storage.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                imageId: {
+                    type: "string",
+                    description: "ID of image from previous generate_image or transform_image call",
+                },
+                imagePath: {
+                    type: "string",
+                    description: "Path to image file on disk",
+                },
+                imageBytes: {
+                    type: "string",
+                    description: "Base64-encoded image bytes",
+                },
+                mime: {
+                    type: "string",
+                    description: "MIME type (required only if using imageBytes)",
+                },
+                destination: {
+                    type: "string",
+                    description: "Where to save: './output.png', 's3://bucket/key.png', 'r2://bucket/key.png'",
+                },
+                provider: {
+                    type: "string",
+                    description: "Storage provider: 's3' or 'fs' (auto-detected from destination if not specified)",
+                },
+            },
+            required: ["destination"],
+        },
+    },
+    {
+        name: "run_pipeline",
+        description: "Execute a multi-step image workflow in a single call. " +
+            "Define a series of generate, transform, and save operations. " +
+            "Each step automatically receives the output from the previous step. " +
+            "Perfect for complex workflows like: generate → resize → add caption → upload to cloud.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                steps: {
+                    type: "array",
+                    description: "Array of steps to execute in order. Each step is an object with one key: " +
+                        "'generate', 'transform', or 'save'. The value is the parameters for that operation.",
+                    items: {
+                        type: "object",
+                    },
+                },
+            },
+            required: ["steps"],
+        },
+    },
+];
+// List tools handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+// Call tool handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        await ensureWorkspace();
+        // Load configuration (from floimg.config.ts or .floimgrc.json)
+        const config = await loadConfig();
+        const client = createClient(config);
+        // Load available plugins
+        const availablePlugins = await loadAvailablePlugins(client);
+        console.error(`[floimg-mcp] Available generators: shapes, openai, ${availablePlugins.join(', ')}`);
+        switch (name) {
+            case "generate_image": {
+                const { intent, params = {}, saveTo } = args;
+                if (!intent) {
+                    throw new Error("'intent' parameter is required");
+                }
+                // Smart generator selection
+                const generator = selectGenerator(intent, params);
+                console.error(`[floimg-mcp] Intent: "${intent}" → Generator: ${generator}`);
+                // Auto-fill params for simple cases to improve UX
+                const finalParams = { ...params };
+                if (generator === 'openai' && !finalParams.prompt) {
+                    // For AI images: use intent as prompt
+                    finalParams.prompt = intent;
+                    finalParams.size = finalParams.size || '1024x1024';
+                    console.error(`[floimg-mcp] Auto-filled: prompt="${intent}", size=${finalParams.size}`);
+                }
+                if (generator === 'qr' && !finalParams.text) {
+                    // For QR codes: extract URL from intent
+                    const urlMatch = intent.match(/https?:\/\/[^\s]+/);
+                    if (urlMatch) {
+                        finalParams.text = urlMatch[0];
+                        console.error(`[floimg-mcp] Auto-filled: text="${finalParams.text}"`);
+                    }
+                    else {
+                        throw new Error("Could not extract URL from intent for QR code. " +
+                            "Please provide params.text explicitly. " +
+                            "Example: { intent: 'qr code', params: { text: 'https://example.com' } }");
+                    }
+                }
+                // For charts and diagrams: params always required (too complex to extract)
+                if ((generator === 'quickchart' || generator === 'mermaid' || generator === 'd3') &&
+                    !finalParams.type && !finalParams.data && !finalParams.code && !finalParams.render) {
+                    throw new Error(`${generator} requires explicit params. Intent is only for routing. ` +
+                        `Please provide structured data: ` +
+                        `${generator === 'quickchart' ? '{ type: "bar", data: {...} }' : ''}` +
+                        `${generator === 'mermaid' ? '{ code: "graph TD; A-->B" }' : ''}` +
+                        `${generator === 'd3' ? '{ render: "...", data: [...] }' : ''}`);
+                }
+                const blob = await client.generate({
+                    generator,
+                    params: finalParams,
+                });
+                // Save to session workspace
+                const imageId = generateImageId();
+                const ext = getExtension(blob.mime);
+                const sessionPath = join(SESSION_WORKSPACE, `${imageId}.${ext}`);
+                await client.save(blob, sessionPath);
+                // Register in session
+                imageRegistry.set(imageId, {
+                    path: sessionPath,
+                    mime: blob.mime,
+                    metadata: {
+                        width: blob.width,
+                        height: blob.height,
+                        source: blob.source,
+                    },
+                });
+                console.error(`[floimg-mcp] Saved to session: ${imageId} → ${sessionPath}`);
+                // Optionally save to additional destination
+                let cloudResult = null;
+                if (saveTo) {
+                    cloudResult = await client.save(blob, saveTo);
+                    console.error(`[floimg-mcp] Also saved to: ${saveTo}`);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                imageId,
+                                generator,
+                                session: {
+                                    path: sessionPath,
+                                    mime: blob.mime,
+                                    width: blob.width,
+                                    height: blob.height,
+                                },
+                                ...(cloudResult && {
+                                    saved: {
+                                        location: cloudResult.location,
+                                        provider: cloudResult.provider,
+                                        size: cloudResult.size,
+                                    },
+                                }),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "transform_image": {
+                const { imageId, imagePath, imageBytes, mime, operation, params = {}, to, saveTo } = args;
+                // Load input image
+                const inputBlob = await loadImage(imageId, imagePath, imageBytes, mime);
+                let resultBlob;
+                // Handle special cases that need specific parameters
+                if (operation === "convert") {
+                    if (!to)
+                        throw new Error("'to' parameter required for convert operation");
+                    resultBlob = await client.transform({
+                        blob: inputBlob,
+                        op: "convert",
+                        to: to,
+                        params,
+                    });
+                }
+                else if (operation === "resize") {
+                    const { width, height } = params;
+                    if (!width && !height)
+                        throw new Error("'width' or 'height' required in params for resize");
+                    resultBlob = await client.transform({
+                        blob: inputBlob,
+                        op: "resize",
+                        params: { width, height, ...params },
+                    });
+                }
+                else {
+                    // All other operations use the generic params approach
+                    resultBlob = await client.transform({
+                        blob: inputBlob,
+                        op: operation,
+                        params,
+                    });
+                }
+                // Save to session workspace
+                const newImageId = generateImageId();
+                const ext = getExtension(resultBlob.mime);
+                const sessionPath = join(SESSION_WORKSPACE, `${newImageId}.${ext}`);
+                await client.save(resultBlob, sessionPath);
+                // Register in session
+                imageRegistry.set(newImageId, {
+                    path: sessionPath,
+                    mime: resultBlob.mime,
+                    metadata: {
+                        width: resultBlob.width,
+                        height: resultBlob.height,
+                        source: resultBlob.source,
+                    },
+                });
+                console.error(`[floimg-mcp] Transformed and saved: ${newImageId} → ${sessionPath}`);
+                // Optionally save to additional destination
+                let cloudResult = null;
+                if (saveTo) {
+                    cloudResult = await client.save(resultBlob, saveTo);
+                    console.error(`[floimg-mcp] Also saved to: ${saveTo}`);
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                imageId: newImageId,
+                                operation,
+                                session: {
+                                    path: sessionPath,
+                                    mime: resultBlob.mime,
+                                    width: resultBlob.width,
+                                    height: resultBlob.height,
+                                },
+                                ...(cloudResult && {
+                                    saved: {
+                                        location: cloudResult.location,
+                                        provider: cloudResult.provider,
+                                        size: cloudResult.size,
+                                    },
+                                }),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "save_image": {
+                const { imageId, imagePath, imageBytes, mime, destination, provider } = args;
+                // Load input image
+                const inputBlob = await loadImage(imageId, imagePath, imageBytes, mime);
+                const result = await client.save(inputBlob, provider ? { path: destination, provider } : destination);
+                console.error(`[floimg-mcp] Saved to: ${destination}`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                location: result.location,
+                                provider: result.provider,
+                                size: result.size,
+                                mime: result.mime,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "run_pipeline": {
+                const { steps } = args;
+                if (!Array.isArray(steps) || steps.length === 0) {
+                    throw new Error("'steps' must be a non-empty array");
+                }
+                let currentImageId;
+                const results = [];
+                for (let i = 0; i < steps.length; i++) {
+                    const step = steps[i];
+                    const stepType = Object.keys(step)[0]; // 'generate', 'transform', or 'save'
+                    const stepParams = step[stepType];
+                    console.error(`[floimg-mcp] Pipeline step ${i + 1}/${steps.length}: ${stepType}`);
+                    if (stepType === 'generate') {
+                        // Generate step
+                        const { intent, params = {} } = stepParams;
+                        const generator = selectGenerator(intent, params);
+                        // Auto-fill params for simple cases (same logic as generate_image tool)
+                        const finalParams = { ...params };
+                        if (generator === 'openai' && !finalParams.prompt) {
+                            finalParams.prompt = intent;
+                            finalParams.size = finalParams.size || '1024x1024';
+                        }
+                        if (generator === 'qr' && !finalParams.text) {
+                            const urlMatch = intent.match(/https?:\/\/[^\s]+/);
+                            if (urlMatch)
+                                finalParams.text = urlMatch[0];
+                        }
+                        const blob = await client.generate({ generator, params: finalParams });
+                        // Save to session
+                        const imageId = generateImageId();
+                        const ext = getExtension(blob.mime);
+                        const sessionPath = join(SESSION_WORKSPACE, `${imageId}.${ext}`);
+                        await client.save(blob, sessionPath);
+                        imageRegistry.set(imageId, {
+                            path: sessionPath,
+                            mime: blob.mime,
+                            metadata: { width: blob.width, height: blob.height, source: blob.source },
+                        });
+                        currentImageId = imageId;
+                        results.push({ step: i + 1, type: 'generate', imageId, generator });
+                    }
+                    else if (stepType === 'transform') {
+                        // Transform step - uses current image
+                        if (!currentImageId) {
+                            throw new Error(`Pipeline step ${i + 1}: transform requires a previous generate step`);
+                        }
+                        const { operation, params = {}, to } = stepParams;
+                        const inputBlob = await loadImage(currentImageId);
+                        let resultBlob;
+                        if (operation === "convert") {
+                            resultBlob = await client.transform({
+                                blob: inputBlob,
+                                op: "convert",
+                                to: to,
+                                params,
+                            });
+                        }
+                        else if (operation === "resize") {
+                            resultBlob = await client.transform({
+                                blob: inputBlob,
+                                op: "resize",
+                                params,
+                            });
+                        }
+                        else {
+                            resultBlob = await client.transform({
+                                blob: inputBlob,
+                                op: operation,
+                                params,
+                            });
+                        }
+                        // Save to session
+                        const newImageId = generateImageId();
+                        const ext = getExtension(resultBlob.mime);
+                        const sessionPath = join(SESSION_WORKSPACE, `${newImageId}.${ext}`);
+                        await client.save(resultBlob, sessionPath);
+                        imageRegistry.set(newImageId, {
+                            path: sessionPath,
+                            mime: resultBlob.mime,
+                            metadata: { width: resultBlob.width, height: resultBlob.height },
+                        });
+                        currentImageId = newImageId;
+                        results.push({ step: i + 1, type: 'transform', operation, imageId: newImageId });
+                    }
+                    else if (stepType === 'save') {
+                        // Save step - saves current image
+                        if (!currentImageId) {
+                            throw new Error(`Pipeline step ${i + 1}: save requires a previous generate/transform step`);
+                        }
+                        const { destination, provider } = stepParams;
+                        const inputBlob = await loadImage(currentImageId);
+                        const result = await client.save(inputBlob, provider ? { path: destination, provider } : destination);
+                        results.push({
+                            step: i + 1,
+                            type: 'save',
+                            location: result.location,
+                            provider: result.provider,
+                            size: result.size,
+                        });
+                    }
+                    else {
+                        throw new Error(`Unknown pipeline step type: ${stepType}. Use 'generate', 'transform', or 'save'.`);
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                pipeline: {
+                                    totalSteps: steps.length,
+                                    finalImageId: currentImageId,
+                                    results,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const errorType = error instanceof FloimgError ? error.name : "Error";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        error: errorType,
+                        message,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Helper: Get file extension from MIME type
+function getExtension(mime) {
+    const map = {
+        'image/svg+xml': 'svg',
+        'image/png': 'png',
+        'image/jpeg': 'jpg',
+        'image/webp': 'webp',
+        'image/avif': 'avif',
+    };
+    return map[mime] || 'png';
+}
+// Start server with stdio transport
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr (stdout is used for MCP communication)
+    console.error("floimg MCP server v0.1.0 running on stdio");
+    console.error("Session workspace:", SESSION_WORKSPACE);
+    console.error("Smart routing enabled - will auto-select best generator based on intent");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=server.js.map