@jgardner04/ghost-mcp-server 1.0.0 → 1.1.1

package/src/mcp_server_enhanced.js

@@ -2,32 +2,29 @@
  * 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 { 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, 
+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";
+  GracefulShutdown,
+} from './middleware/errorMiddleware.js';
 
 dotenv.config();
 
-console.log("Initializing Enhanced MCP Server...");
+console.log('Initializing Enhanced MCP Server...');
 
 // Initialize components
 const resourceManager = new ResourceManager(ghostService);
@@ -37,59 +34,59 @@ 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",
+    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
-    }
+      batch: true,
+    },
   },
 });
 
 // --- Register Resources with Enhanced Fetching ---
 
-console.log("Registering enhanced resources...");
+console.log('Registering enhanced resources...');
 
 // Ghost Post Resource
 const postResource = resourceManager.registerResource(
-  "ghost/post",
+  'ghost/post',
   {
-    type: "object",
+    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"]
+      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"
+      feature_image: { type: ['string', 'null'] },
+      published_at: {
+        type: ['string', 'null'],
+        format: 'date-time',
       },
       tags: {
-        type: "array",
-        items: { $ref: "ghost/tag#/schema" }
+        type: 'array',
+        items: { $ref: 'ghost/tag#/schema' },
       },
-      meta_title: { type: ["string", "null"] },
-      meta_description: { type: ["string", "null"] }
+      meta_title: { type: ['string', 'null'] },
+      meta_description: { type: ['string', 'null'] },
     },
-    required: ["id", "uuid", "title", "slug", "status"]
+    required: ['id', 'uuid', 'title', 'slug', 'status'],
   },
   {
-    description: "Ghost blog post with support for multiple identifier types",
+    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"
-    ]
+      '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',
+    ],
   }
 );
 
@@ -97,32 +94,32 @@ mcpServer.addResource(postResource);
 
 // Ghost Tag Resource
 const tagResource = resourceManager.registerResource(
-  "ghost/tag",
+  'ghost/tag',
   {
-    type: "object",
+    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"]
+      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"] }
+      meta_title: { type: ['string', 'null'] },
+      meta_description: { type: ['string', 'null'] },
     },
-    required: ["id", "name", "slug"]
+    required: ['id', 'name', 'slug'],
   },
   {
-    description: "Ghost tag for categorizing posts",
+    description: 'Ghost tag for categorizing posts',
     examples: [
-      "ghost/tag/technology",
-      "ghost/tag/slug:web-development",
-      "ghost/tag/name:JavaScript",
-      "ghost/tags?limit=20"
-    ]
+      'ghost/tag/technology',
+      'ghost/tag/slug:web-development',
+      'ghost/tag/name:JavaScript',
+      'ghost/tags?limit=20',
+    ],
   }
 );
 
@@ -130,72 +127,69 @@ mcpServer.addResource(tagResource);
 
 // --- Enhanced Tools ---
 
-console.log("Registering 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",
+  name: 'ghost_batch_operations',
+  description: 'Execute multiple Ghost operations in a single request',
   inputSchema: {
-    type: "object",
+    type: 'object',
     properties: {
       operations: {
-        type: "array",
+        type: 'array',
         items: {
-          type: "object",
+          type: 'object',
           properties: {
-            id: { type: "string", description: "Operation ID for reference" },
-            type: { 
-              type: "string",
-              enum: ["create_post", "update_post", "create_tag", "fetch_resource"]
+            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" }
+            data: { type: 'object', description: 'Operation-specific data' },
           },
-          required: ["id", "type", "data"]
+          required: ['id', 'type', 'data'],
         },
         minItems: 1,
-        maxItems: 10
+        maxItems: 10,
       },
       stopOnError: {
-        type: "boolean",
+        type: 'boolean',
         default: false,
-        description: "Stop processing on first error"
-      }
+        description: 'Stop processing on first error',
+      },
     },
-    required: ["operations"]
+    required: ['operations'],
   },
   outputSchema: {
-    type: "object",
+    type: 'object',
     properties: {
       results: {
-        type: "object",
+        type: 'object',
         additionalProperties: {
-          type: "object",
+          type: 'object',
           properties: {
-            success: { type: "boolean" },
-            data: { type: "object" },
-            error: { type: "object" }
-          }
-        }
-      }
-    }
+            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
-            );
+            result = await ghostService.updatePost(operation.data.id, operation.data);
             break;
           case 'create_tag':
             result = await ghostService.createTag(operation.data);
@@ -206,237 +200,236 @@ const batchOperationsTool = new Tool({
           default:
             throw new ValidationError(`Unknown operation type: ${operation.type}`);
         }
-        
+
         results[operation.id] = {
           success: true,
-          data: result
+          data: result,
         };
-        
       } catch (error) {
         results[operation.id] = {
           success: false,
-          error: ErrorHandler.formatMCPError(error)
+          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",
+  name: 'ghost_search_resources',
+  description: 'Search for Ghost resources with advanced filtering',
   inputSchema: {
-    type: "object",
+    type: 'object',
     properties: {
       resourceType: {
-        type: "string",
-        enum: ["posts", "tags"],
-        description: "Type of resource to search"
+        type: 'string',
+        enum: ['posts', 'tags'],
+        description: 'Type of resource to search',
       },
       query: {
-        type: "string",
-        description: "Search query"
+        type: 'string',
+        description: 'Search query',
       },
       filters: {
-        type: "object",
+        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" }
-        }
+          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"
+        type: 'string',
+        default: 'published_at desc',
+        description: 'Sort order',
       },
       limit: {
-        type: "integer",
+        type: 'integer',
         minimum: 1,
         maximum: 100,
-        default: 15
+        default: 15,
       },
       page: {
-        type: "integer",
+        type: 'integer',
         minimum: 1,
-        default: 1
-      }
+        default: 1,
+      },
     },
-    required: ["resourceType"]
+    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
+      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",
+  name: 'ghost_cache_management',
+  description: 'Manage resource cache',
   inputSchema: {
-    type: "object",
+    type: 'object',
     properties: {
       action: {
-        type: "string",
-        enum: ["invalidate", "stats", "prefetch"],
-        description: "Cache action to perform"
+        type: 'string',
+        enum: ['invalidate', 'stats', 'prefetch'],
+        description: 'Cache action to perform',
       },
       pattern: {
-        type: "string",
-        description: "Pattern for invalidation (optional)"
+        type: 'string',
+        description: 'Pattern for invalidation (optional)',
       },
       uris: {
-        type: "array",
-        items: { type: "string" },
-        description: "URIs to prefetch (for prefetch action)"
-      }
+        type: 'array',
+        items: { type: 'string' },
+        description: 'URIs to prefetch (for prefetch action)',
+      },
     },
-    required: ["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}` : ''}` 
+        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",
+  name: 'ghost_subscribe',
+  description: 'Subscribe to resource changes',
   inputSchema: {
-    type: "object",
+    type: 'object',
     properties: {
       action: {
-        type: "string",
-        enum: ["subscribe", "unsubscribe"],
-        description: "Subscription action"
+        type: 'string',
+        enum: ['subscribe', 'unsubscribe'],
+        description: 'Subscription action',
       },
       uri: {
-        type: "string",
-        description: "Resource URI to subscribe to (required for subscribe action)"
+        type: 'string',
+        description: 'Resource URI to subscribe to (required for subscribe action)',
       },
       subscriptionId: {
-        type: "string",
-        description: "Subscription ID (required for unsubscribe action)"
+        type: 'string',
+        description: 'Subscription ID (required for unsubscribe action)',
       },
       options: {
-        type: "object",
+        type: 'object',
         properties: {
           pollingInterval: {
-            type: "integer",
+            type: 'integer',
             minimum: 5000,
             default: 30000,
-            description: "Polling interval in milliseconds"
+            description: 'Polling interval in milliseconds',
           },
           enablePolling: {
-            type: "boolean",
+            type: 'boolean',
             default: false,
-            description: "Enable automatic polling"
-          }
-        }
-      }
+            description: 'Enable automatic polling',
+          },
+        },
+      },
     },
-    required: ["action"],
+    required: ['action'],
     // Add conditional validation using JSON Schema if/then/else
     if: {
-      properties: { action: { const: "subscribe" } }
+      properties: { action: { const: 'subscribe' } },
     },
     then: {
-      required: ["uri"]
+      required: ['uri'],
     },
     else: {
       if: {
-        properties: { action: { const: "unsubscribe" } }
+        properties: { action: { const: 'unsubscribe' } },
       },
       then: {
-        required: ["subscriptionId"]
-      }
-    }
+        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) => {
@@ -445,26 +438,25 @@ const subscriptionTool = new Tool({
         },
         input.options || {}
       );
-      
-      return { 
+
+      return {
         success: true,
         subscriptionId,
-        message: `Subscribed to ${input.uri}`
+        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}`
+        message: `Unsubscribed from ${input.subscriptionId}`,
       };
     }
-  }
+  },
 });
 
 mcpServer.addTool(subscriptionTool);
@@ -477,27 +469,28 @@ mcpServer.addTool(subscriptionTool);
 const startEnhancedMCPServer = async (transport = 'http', options = {}) => {
   try {
     console.log(`Starting Enhanced MCP Server with ${transport} transport...`);
-    
+
     switch (transport) {
-      case 'stdio':
+      case 'stdio': {
         const stdioTransport = new StdioServerTransport();
         await mcpServer.connect(stdioTransport);
-        console.log("Enhanced MCP Server running on stdio transport");
+        console.log('Enhanced MCP Server running on stdio transport');
         break;
-        
+      }
+
       case 'http':
-      case 'sse':
+      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 {
@@ -508,27 +501,27 @@ const startEnhancedMCPServer = async (transport = 'http', options = {}) => {
             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) {
@@ -536,7 +529,7 @@ const startEnhancedMCPServer = async (transport = 'http', options = {}) => {
             res.status(formatted.statusCode).json(formatted.body);
           }
         });
-        
+
         // Batch endpoint
         app.post('/batch', async (req, res) => {
           try {
@@ -547,114 +540,127 @@ const startEnhancedMCPServer = async (transport = 'http', options = {}) => {
             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':
+      }
+
+      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
-                    }));
+                    ws.send(
+                      JSON.stringify({
+                        type: 'subscription_update',
+                        ...event,
+                      })
+                    );
                   },
                   message.options || {}
                 );
-                
-                ws.send(JSON.stringify({
-                  type: 'subscription_created',
-                  subscriptionId
-                }));
+
+                ws.send(
+                  JSON.stringify({
+                    type: 'subscription_created',
+                    subscriptionId,
+                  })
+                );
               }
             } catch (error) {
-              ws.send(JSON.stringify({
-                type: 'error',
-                error: error.message
-              }));
+              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");
-    
+    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);
+    console.error('Failed to start Enhanced MCP Server:', error);
     process.exit(1);
   }
 };
 
 // Graceful shutdown
 const shutdown = async () => {
-  console.log("\nShutting down Enhanced MCP Server...");
-  
+  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);
 };
@@ -670,6 +676,6 @@ 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 });
-}
+}