mcp-grocy 1.9.0

package/build/server/http-server.js

@@ -0,0 +1,214 @@
+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';
+// HTTP Transport for MCP (Context7 style)
+export function startHttpServer(mcpServer, port = 8080) {
+    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) => {
+        console.error(`[${new Date().toISOString()}] ${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')) {
+                console.error('[ERROR] Client must accept application/json or text/event-stream');
+                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);
+            }
+            if (!transport) {
+                console.error('[CRITICAL_ERROR] Transport is undefined before handling request. This should not happen.');
+                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) {
+            console.error('[ERROR] Failed to handle streamable HTTP request:', 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) => {
+                console.error(`[ERROR] SSE connection error for session ${sessionId}:`, 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) => {
+                console.error(`[ERROR] Failed to connect SSE transport for session ${sessionId}:`, error);
+                cleanup();
+                if (!res.headersSent) {
+                    res.status(500).end();
+                }
+            });
+            // Send initial comment to keep connection alive
+            res.write(': connected\n\n');
+        }
+        catch (error) {
+            console.error('[ERROR] Failed to handle SSE connection:', 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) {
+                console.error(`[ERROR] Failed to handle SSE message for session ${sessionId}:`, 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) => {
+        console.error(`[ERROR] HTTP server error: ${error.message}`);
+    });
+    // Start the server
+    server.listen(port, () => {
+        console.error(`[MCP] HTTP server listening on port ${port}`);
+        console.error(`[MCP] Available endpoints:`);
+        console.error(`[MCP]   - Health check: http://localhost:${port}/`);
+        console.error(`[MCP]   - Streamable HTTP: http://localhost:${port}/mcp`);
+        console.error(`[MCP]   - SSE: http://localhost:${port}/mcp/sse`);
+        console.error(`[MCP]   - SSE Messages: http://localhost:${port}/mcp/messages`);
+    });
+    return server;
+}

package/build/server/mcp-server.js

@@ -0,0 +1,173 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, InitializeRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { VERSION, PACKAGE_NAME as SERVER_NAME } from '../version.js';
+import { toolRegistry } from '../tools/index.js';
+import config from '../config/environment.js';
+import { startHttpServer } from './http-server.js';
+import { ResourceHandler } from './resources.js';
+export class GrocyMcpServer {
+    server;
+    enabledTools = new Set();
+    toolSubConfigs = new Map();
+    resourceHandler;
+    // Expose server instance for HTTP/SSE transport
+    get serverInstance() {
+        return this.server;
+    }
+    constructor() {
+        this.resourceHandler = new ResourceHandler();
+        this.parseToolConfiguration();
+        this.setupServer();
+    }
+    parseToolConfiguration() {
+        const { enabledTools, toolSubConfigs } = config.parseToolConfiguration();
+        this.toolSubConfigs = toolSubConfigs;
+        // Validate tool names against registry
+        const validToolNames = new Set(toolRegistry.getToolNames());
+        if (enabledTools.size > 0) {
+            const invalidTools = Array.from(enabledTools).filter(tool => !validToolNames.has(tool));
+            if (invalidTools.length > 0) {
+                console.error(`[ERROR] Invalid tool names in configuration: ${invalidTools.join(', ')}`);
+                console.error(`[ERROR] Valid tool names are: ${Array.from(validToolNames).sort().join(', ')}`);
+                process.exit(1);
+            }
+            this.enabledTools = enabledTools;
+        }
+        else {
+            console.error('[CONFIG] No tools enabled - server will have no tools available');
+        }
+    }
+    isToolAllowed(toolName) {
+        // Only enabled tools are allowed - all others are disabled by default
+        return this.enabledTools.has(toolName);
+    }
+    async setupServer() {
+        this.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: {}
+            }
+        });
+        this.setupHandlers();
+        this.setupErrorHandling();
+    }
+    setupHandlers() {
+        // Initialize handler
+        this.server.setRequestHandler(InitializeRequestSchema, async (request) => {
+            console.error('[DEBUG] Initialize handler called with request:', JSON.stringify(request));
+            return {
+                capabilities: {
+                    tools: {},
+                    resources: {},
+                    prompts: {}
+                },
+                serverInfo: {
+                    name: SERVER_NAME,
+                    version: VERSION
+                }
+            };
+        });
+        // Plain initialize handler for compatibility
+        const PlainInitializeRequestSchema = z.object({
+            jsonrpc: z.literal('2.0'),
+            id: z.union([z.string(), z.number()]).optional(),
+            method: z.literal('initialize'),
+            params: z.any().optional()
+        });
+        this.server.setRequestHandler(PlainInitializeRequestSchema, async (request) => {
+            console.error('[DEBUG] Plain "initialize" handler called');
+            let protocolVersion = '2024-11-05';
+            if (request.params && typeof request.params.protocolVersion === 'string') {
+                protocolVersion = request.params.protocolVersion;
+            }
+            return {
+                protocolVersion,
+                capabilities: {
+                    tools: {},
+                    resources: {},
+                    prompts: {}
+                },
+                serverInfo: {
+                    name: SERVER_NAME,
+                    version: VERSION
+                }
+            };
+        });
+        // List tools handler
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            const allTools = toolRegistry.getDefinitions();
+            const filteredTools = allTools.filter(tool => this.isToolAllowed(tool.name));
+            console.error(`[CONFIG] Available tools: ${filteredTools.map(t => t.name).join(', ')}`);
+            return { tools: filteredTools };
+        });
+        // Call tool handler
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const toolName = request.params.name;
+            // Check if the tool is allowed
+            if (!this.isToolAllowed(toolName)) {
+                throw new McpError(ErrorCode.InvalidRequest, `Tool '${toolName}' is not enabled. Set TOOL__${toolName}=true in your configuration to enable it.`);
+            }
+            // Get handler from registry
+            const handler = toolRegistry.getHandler(toolName);
+            if (!handler) {
+                throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${toolName}`);
+            }
+            try {
+                const subConfigs = this.toolSubConfigs.get(toolName);
+                const result = await handler(request.params.arguments, subConfigs);
+                return result; // Cast to proper MCP type
+            }
+            catch (error) {
+                console.error(`Error executing tool ${toolName}:`, error);
+                if (error instanceof McpError) {
+                    throw error;
+                }
+                throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error.message || error}`);
+            }
+        });
+        // Resource handlers
+        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) => console.error('[MCP Error]', error);
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    async start() {
+        // Start STDIO transport
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('Grocy MCP server running on stdio');
+        // Start HTTP/SSE transport if enabled
+        const envConfig = config.get();
+        if (envConfig.ENABLE_HTTP_SERVER) {
+            try {
+                console.error(`[CONFIG] Starting HTTP/SSE server on port ${envConfig.HTTP_SERVER_PORT}`);
+                const serverFactory = () => new GrocyMcpServer().serverInstance;
+                startHttpServer(serverFactory, envConfig.HTTP_SERVER_PORT);
+            }
+            catch (error) {
+                console.error('[ERROR] Failed to start HTTP/SSE server:', error);
+            }
+        }
+        else {
+            console.error('[CONFIG] HTTP/SSE server is disabled');
+        }
+    }
+}
+export default GrocyMcpServer;

package/build/server/resources.js

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,56 @@
+import apiClient, { ApiError } from '../api/client.js';
+export class BaseToolHandler {
+    safeJsonStringify(data) {
+        try {
+            return JSON.stringify(data, null, 2);
+        }
+        catch (error) {
+            console.error('Error stringifying JSON:', error);
+            return JSON.stringify({ error: 'Error formatting response data' }, null, 2);
+        }
+    }
+    createSuccessResult(data) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: this.safeJsonStringify(data)
+                }]
+        };
+    }
+    createErrorResult(error, context) {
+        const errorMessage = error instanceof Error ? error.message : error;
+        const result = { error: errorMessage };
+        if (context) {
+            result.context = context;
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: this.safeJsonStringify(result)
+                }],
+            isError: true
+        };
+    }
+    async handleApiCall(endpoint, description, options = {}) {
+        try {
+            const method = options.method || 'GET';
+            const body = options.body || null;
+            const headers = options.headers || {};
+            const queryParams = options.queryParams || {};
+            const response = await apiClient.request(endpoint, {
+                method,
+                body,
+                headers,
+                queryParams
+            });
+            return this.createSuccessResult(response.data);
+        }
+        catch (error) {
+            console.error(`Error in ${description}:`, error);
+            if (error instanceof ApiError) {
+                return this.createErrorResult(`Failed to ${description.toLowerCase()}: ${error.message}`);
+            }
+            return this.createErrorResult(`Failed to ${description.toLowerCase()}: ${error.message || error}`);
+        }
+    }
+}