mcp-image-server/dist/mcp-server.js

Servidor MCP para geração de imagens e ícones, integrado ao Vibecoding.

#!/usr/bin/env node
console.error('Entrou no arquivo MCP!');
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 { imageGenerationTools } from './mcp-tools.js';
import { ImageGenerationService } from './services/image-generation-service.js';
import { IconGenerationService } from './services/icon-generation-service.js';
export class MCPImageServer {
    server;
    imageService;
    iconService;
    constructor() {
        this.server = new Server({
            name: 'mcp-image-server',
            version: '1.0.7',
            capabilities: {
                tools: {},
                resources: {},
                prompts: {},
                logging: {},
            }
        });
        try {
            console.error('Instanciando ImageGenerationService...');
            this.imageService = new ImageGenerationService();
            console.error('ImageGenerationService instanciado.');
        }
        catch (err) {
            console.error('Erro ao instanciar ImageGenerationService:', err);
            throw err;
        }
        try {
            console.error('Instanciando IconGenerationService...');
            this.iconService = new IconGenerationService();
            console.error('IconGenerationService instanciado.');
        }
        catch (err) {
            console.error('Erro ao instanciar IconGenerationService:', err);
            throw err;
        }
        try {
            console.error('Chamando setupHandlers...');
            this.setupHandlers();
            console.error('setupHandlers concluído.');
        }
        catch (err) {
            console.error('Erro em setupHandlers:', err);
            throw err;
        }
    }
    setupHandlers() {
        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
            tools: imageGenerationTools
        }));
        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
            const { name, arguments: args } = request.params;
            switch (name) {
                case 'generate_image':
                    return await this.handleGenerateImage(args);
                case 'generate_icon':
                    return await this.handleGenerateIcon(args);
                case 'optimize_image':
                    return await this.handleOptimizeImage(args);
                default:
                    throw new Error(`Unknown tool: ${name}`);
            }
        });
    }
    async handleGenerateImage(args) {
        try {
            const result = await this.imageService.generateImage(args);
            return {
                content: [
                    {
                        type: 'text',
                        text: `Image generated successfully: ${result.filePath}`
                    },
                    {
                        type: 'resource',
                        resource: {
                            uri: `file://${result.filePath}`,
                            mimeType: `image/${args.format || 'png'}`
                        }
                    }
                ]
            };
        }
        catch (error) {
            return {
                content: [{
                        type: 'text',
                        text: `Error generating image: ${error.message}`
                    }],
                isError: true
            };
        }
    }
    async handleGenerateIcon(args) {
        try {
            const results = await this.iconService.generateIcon(args);
            return {
                content: [
                    {
                        type: 'text',
                        text: `Icons generated: ${results.map((r) => r.filePath).join(', ')}`
                    },
                    ...results.map((result) => ({
                        type: 'resource',
                        resource: {
                            uri: `file://${result.filePath}`,
                            mimeType: result.mimeType
                        }
                    }))
                ]
            };
        }
        catch (error) {
            return {
                content: [{
                        type: 'text',
                        text: `Error generating icon: ${error.message}`
                    }],
                isError: true
            };
        }
    }
    async handleOptimizeImage(args) {
        // Implementação futura
        return { content: [{ type: 'text', text: 'Optimize image ainda não implementado.' }] };
    }
    async start() {
        try {
            console.error('Iniciando método start()');
            const transport = new StdioServerTransport();
            await this.server.connect(transport);
            await new Promise(() => { }); // Mantém o processo vivo
            console.error('MCP Image Server started');
        }
        catch (err) {
            console.error('Erro no método start:', err);
            throw err;
        }
    }
}
// Executa sempre que rodar diretamente (compatível com ESM)
console.error('Iniciando MCPImageServer...');
if (import.meta.url === `file://${process.argv[1]}` ||
    import.meta.url === process.argv[1]) {
    const server = new MCPImageServer();
    server.start().catch(console.error);
}