@jgardner04/ghost-mcp-server 1.0.0

package/src/mcp_server_enhanced.js

@@ -0,0 +1,675 @@
+/**
+ * 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 });
+}