Ghost MCP Server

/** * Enhanced MCP Server with Advanced Resource Management */ import { MCPServer, Tool } from '@modelcontextprotocol/sdk/server/index.js'; import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'; import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js'; import { WebSocketServerTransport } from '@modelcontextprotocol/sdk/server/websocket.js'; import dotenv from 'dotenv'; import express from 'express'; import { WebSocketServer } from 'ws'; // Import services import ghostService from './services/ghostServiceImproved.js'; import { ResourceManager } from './resources/ResourceManager.js'; import { ErrorHandler, ValidationError } from './errors/index.js'; import { errorLogger, mcpCors, RateLimiter, healthCheck, GracefulShutdown, } from './middleware/errorMiddleware.js'; dotenv.config(); console.log('Initializing Enhanced MCP Server...'); // Initialize components const resourceManager = new ResourceManager(ghostService); const rateLimiter = new RateLimiter(); const gracefulShutdown = new GracefulShutdown(); // Create MCP Server const mcpServer = new MCPServer({ metadata: { name: 'Ghost CMS Manager', description: 'Enhanced MCP Server for Ghost CMS with advanced resource management', version: '2.0.0', capabilities: { resources: true, tools: true, subscriptions: true, batch: true, }, }, }); // --- Register Resources with Enhanced Fetching --- console.log('Registering enhanced resources...'); // Ghost Post Resource const postResource = resourceManager.registerResource( 'ghost/post', { type: 'object', properties: { id: { type: 'string' }, uuid: { type: 'string' }, title: { type: 'string' }, slug: { type: 'string' }, html: { type: ['string', 'null'] }, status: { type: 'string', enum: ['draft', 'published', 'scheduled'], }, feature_image: { type: ['string', 'null'] }, published_at: { type: ['string', 'null'], format: 'date-time', }, tags: { type: 'array', items: { $ref: 'ghost/tag#/schema' }, }, meta_title: { type: ['string', 'null'] }, meta_description: { type: ['string', 'null'] }, }, required: ['id', 'uuid', 'title', 'slug', 'status'], }, { description: 'Ghost blog post with support for multiple identifier types', examples: [ 'ghost/post/123', 'ghost/post/slug:my-awesome-post', 'ghost/post/uuid:550e8400-e29b-41d4-a716-446655440000', 'ghost/posts?status=published&limit=10&page=1', ], } ); mcpServer.addResource(postResource); // Ghost Tag Resource const tagResource = resourceManager.registerResource( 'ghost/tag', { type: 'object', properties: { id: { type: 'string' }, name: { type: 'string' }, slug: { type: 'string' }, description: { type: ['string', 'null'] }, feature_image: { type: ['string', 'null'] }, visibility: { type: 'string', enum: ['public', 'internal'], }, meta_title: { type: ['string', 'null'] }, meta_description: { type: ['string', 'null'] }, }, required: ['id', 'name', 'slug'], }, { description: 'Ghost tag for categorizing posts', examples: [ 'ghost/tag/technology', 'ghost/tag/slug:web-development', 'ghost/tag/name:JavaScript', 'ghost/tags?limit=20', ], } ); mcpServer.addResource(tagResource); // --- Enhanced Tools --- console.log('Registering enhanced tools...'); // Batch Operations Tool const batchOperationsTool = new Tool({ name: 'ghost_batch_operations', description: 'Execute multiple Ghost operations in a single request', inputSchema: { type: 'object', properties: { operations: { type: 'array', items: { type: 'object', properties: { id: { type: 'string', description: 'Operation ID for reference' }, type: { type: 'string', enum: ['create_post', 'update_post', 'create_tag', 'fetch_resource'], }, data: { type: 'object', description: 'Operation-specific data' }, }, required: ['id', 'type', 'data'], }, minItems: 1, maxItems: 10, }, stopOnError: { type: 'boolean', default: false, description: 'Stop processing on first error', }, }, required: ['operations'], }, outputSchema: { type: 'object', properties: { results: { type: 'object', additionalProperties: { type: 'object', properties: { success: { type: 'boolean' }, data: { type: 'object' }, error: { type: 'object' }, }, }, }, }, }, implementation: async (input) => { const results = {}; for (const operation of input.operations) { try { let result; switch (operation.type) { case 'create_post': result = await ghostService.createPost(operation.data); break; case 'update_post': result = await ghostService.updatePost(operation.data.id, operation.data); break; case 'create_tag': result = await ghostService.createTag(operation.data); break; case 'fetch_resource': result = await resourceManager.fetchResource(operation.data.uri); break; default: throw new ValidationError(`Unknown operation type: ${operation.type}`); } results[operation.id] = { success: true, data: result, }; } catch (error) { results[operation.id] = { success: false, error: ErrorHandler.formatMCPError(error), }; if (input.stopOnError) { break; } } } return { results }; }, }); mcpServer.addTool(batchOperationsTool); // Resource Search Tool const searchResourcesTool = new Tool({ name: 'ghost_search_resources', description: 'Search for Ghost resources with advanced filtering', inputSchema: { type: 'object', properties: { resourceType: { type: 'string', enum: ['posts', 'tags'], description: 'Type of resource to search', }, query: { type: 'string', description: 'Search query', }, filters: { type: 'object', properties: { status: { type: 'string' }, visibility: { type: 'string' }, tag: { type: 'string' }, author: { type: 'string' }, published_after: { type: 'string', format: 'date-time' }, published_before: { type: 'string', format: 'date-time' }, }, }, sort: { type: 'string', default: 'published_at desc', description: 'Sort order', }, limit: { type: 'integer', minimum: 1, maximum: 100, default: 15, }, page: { type: 'integer', minimum: 1, default: 1, }, }, required: ['resourceType'], }, implementation: async (input) => { const { resourceType, query, filters = {}, sort, limit, page } = input; // Build Ghost filter string let filterParts = []; if (query) { filterParts.push(`title:~'${query}'`); } if (filters.status) { filterParts.push(`status:${filters.status}`); } if (filters.visibility) { filterParts.push(`visibility:${filters.visibility}`); } if (filters.tag) { filterParts.push(`tag:${filters.tag}`); } if (filters.author) { filterParts.push(`author:${filters.author}`); } if (filters.published_after) { filterParts.push(`published_at:>='${filters.published_after}'`); } if (filters.published_before) { filterParts.push(`published_at:<='${filters.published_before}'`); } const ghostFilter = filterParts.join('+'); // Build resource URI const uri = `ghost/${resourceType}?${new URLSearchParams({ filter: ghostFilter, order: sort, limit, page, }).toString()}`; // Fetch using ResourceManager return await resourceManager.fetchResource(uri); }, }); mcpServer.addTool(searchResourcesTool); // Cache Management Tool const cacheManagementTool = new Tool({ name: 'ghost_cache_management', description: 'Manage resource cache', inputSchema: { type: 'object', properties: { action: { type: 'string', enum: ['invalidate', 'stats', 'prefetch'], description: 'Cache action to perform', }, pattern: { type: 'string', description: 'Pattern for invalidation (optional)', }, uris: { type: 'array', items: { type: 'string' }, description: 'URIs to prefetch (for prefetch action)', }, }, required: ['action'], }, implementation: async (input) => { switch (input.action) { case 'invalidate': resourceManager.invalidateCache(input.pattern); return { success: true, message: `Cache invalidated${input.pattern ? ` for pattern: ${input.pattern}` : ''}`, }; case 'stats': return resourceManager.getCacheStats(); case 'prefetch': if (!input.uris || input.uris.length === 0) { throw new ValidationError('URIs required for prefetch action'); } return await resourceManager.prefetch(input.uris); default: throw new ValidationError(`Unknown action: ${input.action}`); } }, }); mcpServer.addTool(cacheManagementTool); // Resource Subscription Tool const subscriptionTool = new Tool({ name: 'ghost_subscribe', description: 'Subscribe to resource changes', inputSchema: { type: 'object', properties: { action: { type: 'string', enum: ['subscribe', 'unsubscribe'], description: 'Subscription action', }, uri: { type: 'string', description: 'Resource URI to subscribe to (required for subscribe action)', }, subscriptionId: { type: 'string', description: 'Subscription ID (required for unsubscribe action)', }, options: { type: 'object', properties: { pollingInterval: { type: 'integer', minimum: 5000, default: 30000, description: 'Polling interval in milliseconds', }, enablePolling: { type: 'boolean', default: false, description: 'Enable automatic polling', }, }, }, }, required: ['action'], // Add conditional validation using JSON Schema if/then/else if: { properties: { action: { const: 'subscribe' } }, }, then: { required: ['uri'], }, else: { if: { properties: { action: { const: 'unsubscribe' } }, }, then: { required: ['subscriptionId'], }, }, }, implementation: async (input) => { if (input.action === 'subscribe') { if (!input.uri) { throw new ValidationError('URI required for subscribe action'); } const subscriptionId = resourceManager.subscribe( input.uri, (event) => { // In a real implementation, this would send events to the client console.log('Resource update:', event); }, input.options || {} ); return { success: true, subscriptionId, message: `Subscribed to ${input.uri}`, }; } else if (input.action === 'unsubscribe') { if (!input.subscriptionId) { throw new ValidationError('Subscription ID required for unsubscribe action'); } resourceManager.unsubscribe(input.subscriptionId); return { success: true, message: `Unsubscribed from ${input.subscriptionId}`, }; } }, }); mcpServer.addTool(subscriptionTool); // Keep existing tools (create_post, upload_image, etc.) from previous implementation // ... (include the tools from mcp_server_improved.js) // --- Enhanced Transport with Middleware --- const startEnhancedMCPServer = async (transport = 'http', options = {}) => { try { console.log(`Starting Enhanced MCP Server with ${transport} transport...`); switch (transport) { case 'stdio': const stdioTransport = new StdioServerTransport(); await mcpServer.connect(stdioTransport); console.log('Enhanced MCP Server running on stdio transport'); break; case 'http': case 'sse': const port = options.port || 3001; const app = express(); // Apply middleware app.use(gracefulShutdown.middleware()); app.use(rateLimiter.middleware()); app.use(mcpCors(options.allowedOrigins)); // Health check with Ghost status app.get('/health', healthCheck(ghostService)); // Resource endpoints app.get('/resources', async (req, res) => { try { const resources = resourceManager.listResources(req.query); res.json(resources); } catch (error) { const formatted = ErrorHandler.formatHTTPError(error); res.status(formatted.statusCode).json(formatted.body); } }); app.get('/resources/*', async (req, res) => { try { const uri = req.params[0]; // Validate and sanitize the URI to prevent path traversal if (!uri || typeof uri !== 'string') { throw new ValidationError('Invalid resource URI'); } // Ensure the URI doesn't contain path traversal attempts if (uri.includes('..') || uri.includes('//') || uri.includes('\\')) { throw new ValidationError('Invalid resource URI: path traversal detected'); } // Only allow specific URI patterns for Ghost resources const validPatterns = /^ghost\/(post|posts|tag|tags|author|authors|page|pages)/; if (!validPatterns.test(uri)) { throw new ValidationError('Invalid resource type'); } const result = await resourceManager.fetchResource(uri); res.json(result); } catch (error) { const formatted = ErrorHandler.formatHTTPError(error); res.status(formatted.statusCode).json(formatted.body); } }); // Batch endpoint app.post('/batch', async (req, res) => { try { const result = await resourceManager.batchFetch(req.body.uris); res.json(result); } catch (error) { const formatted = ErrorHandler.formatHTTPError(error); res.status(formatted.statusCode).json(formatted.body); } }); // Cache stats endpoint app.get('/cache/stats', (req, res) => { res.json(resourceManager.getCacheStats()); }); // SSE endpoint for MCP const sseTransport = new SSEServerTransport(); app.get('/mcp/sse', sseTransport.handler()); await mcpServer.connect(sseTransport); const server = app.listen(port, () => { console.log(`Enhanced MCP Server (SSE) listening on port ${port}`); console.log(`Health: http://localhost:${port}/health`); console.log(`Resources: http://localhost:${port}/resources`); console.log(`SSE: http://localhost:${port}/mcp/sse`); }); mcpServer._httpServer = server; // Track connections for graceful shutdown server.on('connection', (connection) => { gracefulShutdown.trackConnection(connection); }); break; case 'websocket': const wsPort = options.port || 3001; const wss = new WebSocketServer({ port: wsPort }); wss.on('connection', async (ws) => { console.log('New WebSocket connection'); const wsTransport = new WebSocketServerTransport(ws); await mcpServer.connect(wsTransport); // Handle subscriptions over WebSocket ws.on('message', async (data) => { try { const message = JSON.parse(data); if (message.type === 'subscribe') { const subscriptionId = resourceManager.subscribe( message.uri, (event) => { ws.send( JSON.stringify({ type: 'subscription_update', ...event, }) ); }, message.options || {} ); ws.send( JSON.stringify({ type: 'subscription_created', subscriptionId, }) ); } } catch (error) { ws.send( JSON.stringify({ type: 'error', error: error.message, }) ); } }); }); console.log(`Enhanced MCP Server (WebSocket) listening on port ${wsPort}`); mcpServer._wss = wss; break; default: throw new Error(`Unknown transport type: ${transport}`); } // Log capabilities console.log('Server Capabilities:'); console.log( '- Resources:', mcpServer.listResources().map((r) => r.name) ); console.log( '- Tools:', mcpServer.listTools().map((t) => t.name) ); console.log('- Cache enabled with LRU eviction'); console.log('- Subscription support for real-time updates'); console.log('- Batch operations for efficiency'); } catch (error) { errorLogger.logError(error); console.error('Failed to start Enhanced MCP Server:', error); process.exit(1); } }; // Graceful shutdown const shutdown = async () => { console.log('\nShutting down Enhanced MCP Server...'); // Clear all subscriptions resourceManager.subscriptionManager.subscriptions.clear(); // Close servers if (mcpServer._httpServer) { await gracefulShutdown.shutdown(mcpServer._httpServer); } if (mcpServer._wss) { mcpServer._wss.close(); } await mcpServer.close(); process.exit(0); }; process.on('SIGINT', shutdown); process.on('SIGTERM', shutdown); // Export export { mcpServer, startEnhancedMCPServer, resourceManager }; // If running directly if (import.meta.url === `file://${process.argv[1]}`) { const transport = process.env.MCP_TRANSPORT || 'http'; const port = parseInt(process.env.MCP_PORT || '3001'); const allowedOrigins = process.env.MCP_ALLOWED_ORIGINS?.split(',') || ['*']; startEnhancedMCPServer(transport, { port, allowedOrigins }); }