mcp-grocy 2.2.0 → 2.6.0

package/build/server/http-server.js

@@ -1,218 +0,0 @@
-import express from 'express';
-import { randomUUID } from 'crypto';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import { VERSION, PACKAGE_NAME as SERVER_NAME } from '../version.js';
-import cors from 'cors';
-import http from 'http';
-import { logger } from '../utils/logger.js';
-// HTTP Transport for MCP (Context7 style)
-export function startHttpServer(mcpServer, port = 8080) {
-    return new Promise((resolve, reject) => {
-        const app = express();
-        // Enable JSON body parsing with increased limit
-        app.use(express.json({
-            limit: '10mb'
-        }));
-        // Enable CORS for all routes
-        app.use(cors({
-            origin: '*',
-            methods: ['GET', 'POST', 'OPTIONS'],
-            allowedHeaders: ['Origin', 'X-Requested-With', 'Content-Type', 'Accept', 'Mcp-Session-Id', 'Authorization'],
-            exposedHeaders: ['Mcp-Session-Id', 'Content-Type'],
-            optionsSuccessStatus: 200
-        }));
-        // Simple health check endpoint
-        app.get('/', (_req, res) => {
-            res.json({
-                status: 'ok',
-                service: SERVER_NAME,
-                version: VERSION,
-                message: 'MCP server is running',
-                endpoints: {
-                    streamable: '/mcp',
-                    sse: '/mcp/sse',
-                    sseMessages: '/mcp/messages'
-                }
-            });
-        });
-        // Session management for transports
-        const streamableTransports = {};
-        const sseTransports = {};
-        const sseServerInstances = {};
-        // Simplified request logging
-        app.use((req, _res, next) => {
-            logger.server(`${req.method} ${req.path}`);
-            next();
-        });
-        // Helper function to get server instance (shared or new)
-        const getServerInstance = () => {
-            if (typeof mcpServer === 'function') {
-                return mcpServer(); // Create new instance
-            }
-            else {
-                return mcpServer; // Use shared instance
-            }
-        };
-        // Streamable HTTP endpoint (Context7 modern)
-        app.post('/mcp', async (req, res) => {
-            try {
-                const clientSessionId = req.headers['mcp-session-id'];
-                let transport = undefined;
-                // Accept header check (can be done early)
-                const accept = req.headers.accept || '';
-                if (!accept.includes('application/json') && !accept.includes('text/event-stream')) {
-                    logger.error('Client must accept application/json or text/event-stream', 'server');
-                    res.status(406).json({
-                        jsonrpc: '2.0',
-                        error: {
-                            code: -32000,
-                            message: 'Not Acceptable: Client must accept application/json or text/event-stream'
-                        },
-                        id: req.body?.id || null
-                    });
-                    return;
-                }
-                if (clientSessionId) {
-                    transport = streamableTransports[clientSessionId];
-                    if (!transport) {
-                        res.status(400).json({
-                            jsonrpc: '2.0',
-                            error: { code: -32001, message: `Invalid or expired session ID: ${clientSessionId}. Please re-initialize.` },
-                            id: req.body?.id || null
-                        });
-                        return;
-                    }
-                }
-                else {
-                    // No session ID provided by client, create new transport
-                    const newGeneratedSessionId = randomUUID();
-                    const newTransportInstance = new StreamableHTTPServerTransport({
-                        sessionIdGenerator: () => newGeneratedSessionId
-                    });
-                    transport = newTransportInstance;
-                    streamableTransports[newGeneratedSessionId] = transport;
-                    transport.onclose = () => {
-                        const closedSessionId = transport?.sessionId || newGeneratedSessionId;
-                        delete streamableTransports[closedSessionId];
-                    };
-                    const serverInstance = getServerInstance();
-                    await serverInstance.connect(transport); // Type assertion to work around SDK type issue
-                }
-                if (!transport) {
-                    logger.error('Transport is undefined before handling request. This should not happen.', 'server');
-                    res.status(500).json({ jsonrpc: '2.0', error: { code: -32000, message: 'Internal server error: Transport not available' }, id: req.body?.id || null });
-                    return;
-                }
-                if (transport.sessionId) {
-                    res.setHeader('Mcp-Session-Id', transport.sessionId);
-                }
-                await transport.handleRequest(req, res, req.body);
-            }
-            catch (error) {
-                logger.error('Failed to handle streamable HTTP request', 'server', { error });
-                // Send error response if headers not sent yet
-                if (!res.headersSent) {
-                    res.status(500).json({
-                        jsonrpc: '2.0',
-                        error: {
-                            code: -32000,
-                            message: `Internal server error: ${error instanceof Error ? error.message : String(error)}`
-                        },
-                        id: req.body?.id || null
-                    });
-                }
-            }
-        });
-        // SSE endpoint
-        app.get('/mcp/sse', async (_req, res) => {
-            try {
-                // Set SSE headers before creating transport
-                res.setHeader('Content-Type', 'text/event-stream');
-                res.setHeader('Cache-Control', 'no-cache');
-                res.setHeader('Connection', 'keep-alive');
-                const transport = new SSEServerTransport('/mcp/messages', res);
-                const sessionId = transport.sessionId;
-                sseTransports[sessionId] = transport;
-                // Handle connection cleanup
-                const cleanup = () => {
-                    delete sseTransports[sessionId];
-                    delete sseServerInstances[sessionId];
-                };
-                res.on('close', cleanup);
-                res.on('error', (err) => {
-                    logger.error(`SSE connection error for session ${sessionId}`, 'server', { error: err });
-                    cleanup();
-                });
-                // Create isolated server instance for this SSE connection to prevent response cross-talk
-                const isolatedServer = getServerInstance();
-                sseServerInstances[sessionId] = isolatedServer;
-                // Connect transport to isolated MCP server (non-blocking)
-                isolatedServer.connect(transport).catch((error) => {
-                    logger.error(`Failed to connect SSE transport for session ${sessionId}`, 'server', { error });
-                    cleanup();
-                    if (!res.headersSent) {
-                        res.status(500).end();
-                    }
-                });
-                // Send initial comment to keep connection alive
-                res.write(': connected\n\n');
-            }
-            catch (error) {
-                logger.error('Failed to handle SSE connection', 'server', { error });
-                if (!res.headersSent) {
-                    res.status(500).send('Internal Server Error');
-                }
-                else {
-                    res.end();
-                }
-            }
-        });
-        // Message endpoint for SSE
-        app.post('/mcp/messages', async (req, res) => {
-            const sessionId = req.query.sessionId;
-            if (!sessionId) {
-                res.status(400).json({
-                    error: 'Missing sessionId parameter',
-                    status: 400
-                });
-                return;
-            }
-            const transport = sseTransports[sessionId];
-            if (transport) {
-                try {
-                    await transport.handlePostMessage(req, res, req.body);
-                }
-                catch (error) {
-                    logger.error(`Failed to handle SSE message for session ${sessionId}`, 'server', { error });
-                    res.status(500).json({
-                        error: `Internal server error: ${error instanceof Error ? error.message : String(error)}`,
-                        status: 500
-                    });
-                }
-            }
-            else {
-                res.status(404).json({
-                    error: `No active SSE connection found for session ID: ${sessionId}`,
-                    status: 404
-                });
-            }
-        });
-        // Create HTTP server with explicit error handling
-        const server = http.createServer(app);
-        server.on('error', (error) => {
-            logger.error(`HTTP server error: ${error.message}`, 'server');
-            reject(error);
-        });
-        // Start the server
-        server.listen(port, () => {
-            logger.server(`HTTP server listening on port ${port}`);
-            logger.server(`Available endpoints:`);
-            logger.server(`  - Health check: http://localhost:${port}/`);
-            logger.server(`  - Streamable HTTP: http://localhost:${port}/mcp`);
-            logger.server(`  - SSE: http://localhost:${port}/mcp/sse`);
-            logger.server(`  - SSE Messages: http://localhost:${port}/mcp/messages`);
-            resolve(server);
-        });
-    });
-}

package/build/server/mcp-server.js

@@ -1,163 +0,0 @@
-/**
- * Simplified MCP Server implementation
- * Reduced complexity and improved performance
- */
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { VERSION, PACKAGE_NAME as SERVER_NAME } from '../version.js';
-import { createToolRegistry } from '../tools/index.js';
-import { config } from '../config/index.js';
-import { startHttpServer } from './http-server.js';
-import { ResourceHandler } from './resources.js';
-import { logger } from '../utils/logger.js';
-import { ErrorHandler } from '../utils/errors.js';
-export class GrocyMcpServer {
-    server;
-    enabledTools = new Set();
-    toolSubConfigs = new Map();
-    toolAckTokens = new Map();
-    resourceHandler;
-    toolRegistry;
-    constructor(server, toolRegistry, resourceHandler) {
-        this.server = server;
-        this.toolRegistry = toolRegistry;
-        this.resourceHandler = resourceHandler;
-        this.parseToolConfiguration();
-        this.setupHandlers();
-        this.setupErrorHandling();
-    }
-    static async create() {
-        // Initialize components
-        const [toolRegistry, resourceHandler] = await Promise.all([
-            createToolRegistry(),
-            Promise.resolve(new ResourceHandler())
-        ]);
-        // Create server
-        const server = new Server({
-            name: SERVER_NAME,
-            version: VERSION,
-            serverUrl: "https://github.com/miguelangel-nubla/mcp-grocy",
-            documentationUrl: "https://github.com/miguelangel-nubla/mcp-grocy/blob/main/README.md"
-        }, {
-            capabilities: {
-                tools: {},
-                resources: {},
-                prompts: {}
-            }
-        });
-        return new GrocyMcpServer(server, toolRegistry, resourceHandler);
-    }
-    parseToolConfiguration() {
-        const { enabledTools, toolSubConfigs, toolAckTokens } = config.parseToolConfiguration();
-        this.toolSubConfigs = toolSubConfigs;
-        this.toolAckTokens = toolAckTokens;
-        // Validate tool names
-        const validToolNames = new Set(this.toolRegistry.getToolNames());
-        if (enabledTools.size > 0) {
-            const invalidTools = Array.from(enabledTools).filter(tool => !validToolNames.has(tool));
-            if (invalidTools.length > 0) {
-                const validNames = Array.from(validToolNames).sort().join(', ');
-                logger.error(`Invalid tools: ${invalidTools.join(', ')}. Valid: ${validNames}`, 'CONFIG');
-                process.exit(1);
-            }
-            this.enabledTools = enabledTools;
-            logger.config(`Enabled tools: ${Array.from(enabledTools).join(', ')}`);
-        }
-        else {
-            logger.warn('No tools enabled', 'CONFIG');
-        }
-    }
-    setupHandlers() {
-        // Initialize handler
-        this.server.setRequestHandler(z.object({ method: z.literal('initialize'), params: z.any().optional() }), async (request) => {
-            logger.debug('Initialize request', 'MCP');
-            return {
-                protocolVersion: request.params?.protocolVersion || '2024-11-05',
-                capabilities: { tools: {}, resources: {}, prompts: {} },
-                serverInfo: { name: SERVER_NAME, version: VERSION }
-            };
-        });
-        // List tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            const allTools = this.toolRegistry.getDefinitions();
-            const filteredTools = allTools.filter(tool => this.enabledTools.has(tool.name));
-            logger.config(`Available tools: ${filteredTools.map(t => t.name).join(', ')}`);
-            return { tools: filteredTools };
-        });
-        // Call tool
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name: toolName, arguments: args } = request.params;
-            // Check if tool is enabled
-            if (!this.enabledTools.has(toolName)) {
-                throw new McpError(ErrorCode.InvalidRequest, `Tool '${toolName}' is not enabled. Enable it in your configuration.`);
-            }
-            // Get handler
-            const handler = this.toolRegistry.getHandler(toolName);
-            if (!handler) {
-                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${toolName}`);
-            }
-            try {
-                const subConfigs = this.toolSubConfigs.get(toolName);
-                const result = await handler(args, subConfigs);
-                // Automatically add ack_token to successful responses (at the beginning)
-                if (!result.isError) {
-                    const ackToken = this.toolAckTokens.get(toolName);
-                    if (ackToken) {
-                        result.content.unshift({
-                            type: 'text',
-                            text: `Acknowledgment token: ${ackToken}`
-                        });
-                    }
-                }
-                return result;
-            }
-            catch (error) {
-                ErrorHandler.logError(error, `tool: ${toolName}`);
-                throw ErrorHandler.toMcpError(error, `${toolName} failed`);
-            }
-        });
-        // Resources
-        this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-            return this.resourceHandler.listResources();
-        });
-        this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-            return this.resourceHandler.readResource(request.params.uri);
-        });
-    }
-    setupErrorHandling() {
-        this.server.onerror = (error) => {
-            logger.error('MCP protocol error', 'MCP', { error });
-        };
-        process.on('SIGINT', async () => {
-            logger.info('Shutting down server...', 'SERVER');
-            await this.server.close();
-            process.exit(0);
-        });
-    }
-    async start() {
-        // Start STDIO transport
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        logger.info('MCP server running on stdio', 'SERVER');
-        // Start HTTP/SSE if enabled
-        if (config.server.enable_http_server) {
-            try {
-                logger.config(`Starting HTTP server on port ${config.server.http_server_port}`);
-                const serverFactory = () => this.server;
-                await startHttpServer(serverFactory, config.server.http_server_port);
-            }
-            catch (error) {
-                logger.error('Failed to start HTTP server', 'SERVER', { error });
-                logger.error('HTTP server is explicitly enabled but cannot start - exiting', 'SERVER');
-                process.exit(1);
-            }
-        }
-    }
-    // Expose server for HTTP transport
-    get serverInstance() {
-        return this.server;
-    }
-}
-export default GrocyMcpServer;

package/build/server/resources.js

@@ -1,60 +0,0 @@
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { SERVER_NAME } from '../version.js';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-export class ResourceHandler {
-    __dirname;
-    constructor() {
-        const __filename = fileURLToPath(import.meta.url);
-        this.__dirname = path.dirname(__filename);
-    }
-    async listResources() {
-        return {
-            resources: [
-                {
-                    uri: `${SERVER_NAME}://examples`,
-                    name: 'Grocy API Usage Examples',
-                    description: 'Detailed examples of using the Grocy API',
-                    mimeType: 'text/markdown'
-                },
-                {
-                    uri: `${SERVER_NAME}://response-format`,
-                    name: 'Response Format Documentation',
-                    description: 'Documentation of the response format and structure',
-                    mimeType: 'text/markdown'
-                },
-                {
-                    uri: `${SERVER_NAME}://config`,
-                    name: 'Configuration Documentation',
-                    description: 'Documentation of all configuration options and how to use them',
-                    mimeType: 'text/markdown'
-                }
-            ]
-        };
-    }
-    async readResource(uri) {
-        const uriPattern = new RegExp(`^${SERVER_NAME}://(.+)$`);
-        const match = uri.match(uriPattern);
-        if (!match) {
-            throw new McpError(ErrorCode.InvalidRequest, `Invalid resource URI format: ${uri}`);
-        }
-        const resource = match[1];
-        try {
-            // In the built app, resources are in build/resources
-            // In development, they're in src/resources
-            const resourcePath = path.join(this.__dirname, '../resources', `${resource}.md`);
-            const content = await fs.promises.readFile(resourcePath, 'utf8');
-            return {
-                contents: [{
-                        uri,
-                        mimeType: 'text/markdown',
-                        text: content
-                    }]
-            };
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InvalidRequest, `Resource not found: ${resource}`);
-        }
-    }
-}

package/build/tools/base.js

@@ -1,141 +0,0 @@
-/**
- * Simplified base tool handler
- */
-import apiClient from '../api/client.js';
-import { ErrorHandler, ValidationError } from '../utils/errors.js';
-import { logger } from '../utils/logger.js';
-export class BaseToolHandler {
-    /**
-     * Create a standardized success result
-     */
-    createSuccess(data, message) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: message || 'Operation completed successfully'
-                },
-                {
-                    type: 'text',
-                    text: JSON.stringify(data, null, 2)
-                }
-            ]
-        };
-    }
-    /**
-     * Create a standardized error result
-     */
-    createError(message, details) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Error: ${message}`
-                },
-                ...(details ? [{
-                        type: 'text',
-                        text: JSON.stringify(details, null, 2)
-                    }] : [])
-            ],
-            isError: true
-        };
-    }
-    /**
-     * Validate required parameters
-     */
-    validateRequired(params, required) {
-        const missing = required.filter(field => {
-            const value = params[field];
-            return value === undefined || value === null || value === '';
-        });
-        if (missing.length > 0) {
-            throw new ValidationError(`Missing required parameters: ${missing.join(', ')}`, 'parameter validation');
-        }
-    }
-    /**
-     * Safely make API calls with error handling
-     */
-    async apiCall(endpoint, method = 'GET', data, options) {
-        return ErrorHandler.handleAsync(async () => {
-            const response = await apiClient.request(endpoint, {
-                method,
-                body: data,
-                queryParams: options?.queryParams || {}
-            });
-            return response.data;
-        }, `API ${method} ${endpoint}`);
-    }
-    /**
-     * Handle tool execution with standardized error handling
-     */
-    async executeToolHandler(handler) {
-        try {
-            return await handler();
-        }
-        catch (error) {
-            ErrorHandler.logError(error, 'tool execution');
-            if (error instanceof ValidationError) {
-                return this.createError(error.message);
-            }
-            const message = error instanceof Error ? error.message : 'Internal error';
-            return this.createError(`Tool execution failed: ${message}`);
-        }
-    }
-    /**
-     * Safe JSON formatting
-     */
-    safeStringify(data) {
-        try {
-            return JSON.stringify(data, null, 2);
-        }
-        catch (error) {
-            logger.warn('Failed to stringify data', 'TOOLS', { error });
-            return '[Unable to format data]';
-        }
-    }
-    /**
-     * Filter object fields based on allowlist
-     */
-    filterFields(objects, fields) {
-        return objects.map(obj => {
-            const filtered = {};
-            fields.forEach(field => {
-                if (field in obj) {
-                    filtered[field] = obj[field];
-                }
-            });
-            return filtered;
-        });
-    }
-    /**
-     * Parse and validate array parameter
-     */
-    parseArrayParam(value, paramName) {
-        if (!value) {
-            throw new ValidationError(`${paramName} is required`);
-        }
-        if (!Array.isArray(value)) {
-            throw new ValidationError(`${paramName} must be an array`);
-        }
-        if (value.length === 0) {
-            throw new ValidationError(`${paramName} cannot be empty`);
-        }
-        return value.map(v => String(v));
-    }
-    /**
-     * Parse and validate numeric parameter
-     */
-    parseNumberParam(value, paramName, required = true) {
-        if (value === undefined || value === null) {
-            if (required) {
-                throw new ValidationError(`${paramName} is required`);
-            }
-            return undefined;
-        }
-        const num = Number(value);
-        if (isNaN(num)) {
-            throw new ValidationError(`${paramName} must be a valid number`);
-        }
-        return num;
-    }
-}