@jgardner04/ghost-mcp-server 1.0.0 → 1.1.1

package/src/services/ghostServiceImproved.js

@@ -1,6 +1,6 @@
-import GhostAdminAPI from "@tryghost/admin-api";
+import GhostAdminAPI from '@tryghost/admin-api';
 import sanitizeHtml from 'sanitize-html';
-import dotenv from "dotenv";
+import dotenv from 'dotenv';
 import { promises as fs } from 'fs';
 import {
   GhostAPIError,
@@ -9,8 +9,8 @@ import {
   NotFoundError,
   ErrorHandler,
   CircuitBreaker,
-  retryWithBackoff
-} from "../errors/index.js";
+  retryWithBackoff,
+} from '../errors/index.js';
 
 dotenv.config();
 
@@ -19,10 +19,8 @@ const { GHOST_ADMIN_API_URL, GHOST_ADMIN_API_KEY } = process.env;
 // Validate configuration at startup
 if (!GHOST_ADMIN_API_URL || !GHOST_ADMIN_API_KEY) {
   throw new ConfigurationError(
-    "Ghost Admin API configuration is incomplete",
-    ["GHOST_ADMIN_API_URL", "GHOST_ADMIN_API_KEY"].filter(
-      key => !process.env[key]
-    )
+    'Ghost Admin API configuration is incomplete',
+    ['GHOST_ADMIN_API_URL', 'GHOST_ADMIN_API_KEY'].filter((key) => !process.env[key])
   );
 }
 
@@ -30,31 +28,23 @@ if (!GHOST_ADMIN_API_URL || !GHOST_ADMIN_API_KEY) {
 const api = new GhostAdminAPI({
   url: GHOST_ADMIN_API_URL,
   key: GHOST_ADMIN_API_KEY,
-  version: "v5.0",
+  version: 'v5.0',
 });
 
 // Circuit breaker for Ghost API
 const ghostCircuitBreaker = new CircuitBreaker({
   failureThreshold: 5,
   resetTimeout: 60000, // 1 minute
-  monitoringPeriod: 10000 // 10 seconds
+  monitoringPeriod: 10000, // 10 seconds
 });
 
 /**
  * Enhanced handler for Ghost Admin API requests with proper error handling
  */
-const handleApiRequest = async (
-  resource,
-  action,
-  data = {},
-  options = {},
-  config = {}
-) => {
+const handleApiRequest = async (resource, action, data = {}, options = {}, config = {}) => {
   // Validate inputs
-  if (!api[resource] || typeof api[resource][action] !== "function") {
-    throw new ValidationError(
-      `Invalid Ghost API resource or action: ${resource}.${action}`
-    );
+  if (!api[resource] || typeof api[resource][action] !== 'function') {
+    throw new ValidationError(`Invalid Ghost API resource or action: ${resource}.${action}`);
   }
 
   const operation = `${resource}.${action}`;
@@ -65,23 +55,23 @@ const handleApiRequest = async (
   const executeRequest = async () => {
     try {
       console.log(`Executing Ghost API request: ${operation}`);
-      
+
       let result;
-      
+
       // Handle different action signatures
       switch (action) {
-        case "add":
-        case "edit":
+        case 'add':
+        case 'edit':
           result = await api[resource][action](data, options);
           break;
-        case "upload":
+        case 'upload':
           result = await api[resource][action](data);
           break;
-        case "browse":
-        case "read":
+        case 'browse':
+        case 'read':
           result = await api[resource][action](options, data);
           break;
-        case "delete":
+        case 'delete':
           result = await api[resource][action](data.id || data, options);
           break;
         default:
@@ -90,7 +80,6 @@ const handleApiRequest = async (
 
       console.log(`Successfully executed Ghost API request: ${operation}`);
       return result;
-      
     } catch (error) {
       // Transform Ghost API errors into our error types
       throw ErrorHandler.fromGhostError(error, operation);
@@ -106,15 +95,15 @@ const handleApiRequest = async (
   try {
     return await retryWithBackoff(wrappedExecute, {
       maxAttempts: maxRetries,
-      onRetry: (attempt, error) => {
+      onRetry: (attempt, _error) => {
         console.log(`Retrying ${operation} (attempt ${attempt}/${maxRetries})`);
-        
+
         // Log circuit breaker state if relevant
         if (useCircuitBreaker) {
           const state = ghostCircuitBreaker.getState();
           console.log(`Circuit breaker state:`, state);
         }
-      }
+      },
     });
   } catch (error) {
     console.error(`Failed to execute ${operation} after ${maxRetries} attempts:`, error.message);
@@ -128,23 +117,29 @@ const handleApiRequest = async (
 const validators = {
   validatePostData(postData) {
     const errors = [];
-    
+
     if (!postData.title || postData.title.trim().length === 0) {
       errors.push({ field: 'title', message: 'Title is required' });
     }
-    
+
     if (!postData.html && !postData.mobiledoc) {
       errors.push({ field: 'content', message: 'Either html or mobiledoc content is required' });
     }
-    
+
     if (postData.status && !['draft', 'published', 'scheduled'].includes(postData.status)) {
-      errors.push({ field: 'status', message: 'Invalid status. Must be draft, published, or scheduled' });
+      errors.push({
+        field: 'status',
+        message: 'Invalid status. Must be draft, published, or scheduled',
+      });
     }
-    
+
     if (postData.status === 'scheduled' && !postData.published_at) {
-      errors.push({ field: 'published_at', message: 'published_at is required when status is scheduled' });
+      errors.push({
+        field: 'published_at',
+        message: 'published_at is required when status is scheduled',
+      });
     }
-    
+
     if (postData.published_at) {
       const publishDate = new Date(postData.published_at);
       if (isNaN(publishDate.getTime())) {
@@ -153,7 +148,7 @@ const validators = {
         errors.push({ field: 'published_at', message: 'Scheduled date must be in the future' });
       }
     }
-    
+
     if (errors.length > 0) {
       throw new ValidationError('Post validation failed', errors);
     }
@@ -161,15 +156,18 @@ const validators = {
 
   validateTagData(tagData) {
     const errors = [];
-    
+
     if (!tagData.name || tagData.name.trim().length === 0) {
       errors.push({ field: 'name', message: 'Tag name is required' });
     }
-    
-    if (tagData.slug && !/^[a-z0-9\-]+$/.test(tagData.slug)) {
-      errors.push({ field: 'slug', message: 'Slug must contain only lowercase letters, numbers, and hyphens' });
+
+    if (tagData.slug && !/^[a-z0-9-]+$/.test(tagData.slug)) {
+      errors.push({
+        field: 'slug',
+        message: 'Slug must contain only lowercase letters, numbers, and hyphens',
+      });
     }
-    
+
     if (errors.length > 0) {
       throw new ValidationError('Tag validation failed', errors);
     }
@@ -179,14 +177,14 @@ const validators = {
     if (!imagePath || typeof imagePath !== 'string') {
       throw new ValidationError('Image path is required and must be a string');
     }
-    
+
     // Check if file exists
     try {
       await fs.access(imagePath);
     } catch {
       throw new NotFoundError('Image file', imagePath);
     }
-  }
+  },
 };
 
 /**
@@ -195,20 +193,20 @@ const validators = {
 
 export async function getSiteInfo() {
   try {
-    return await handleApiRequest("site", "read");
+    return await handleApiRequest('site', 'read');
   } catch (error) {
-    console.error("Failed to get site info:", error);
+    console.error('Failed to get site info:', error);
     throw error;
   }
 }
 
-export async function createPost(postData, options = { source: "html" }) {
+export async function createPost(postData, options = { source: 'html' }) {
   // Validate input
   validators.validatePostData(postData);
-  
+
   // Add defaults
   const dataWithDefaults = {
-    status: "draft",
+    status: 'draft',
     ...postData,
   };
 
@@ -217,28 +215,51 @@ export async function createPost(postData, options = { source: "html" }) {
     // Use proper HTML sanitization library to prevent XSS
     dataWithDefaults.html = sanitizeHtml(dataWithDefaults.html, {
       allowedTags: [
-        'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'blockquote', 'p', 'a', 'ul', 'ol', 'nl', 'li',
-        'b', 'i', 'strong', 'em', 'strike', 'code', 'hr', 'br', 'div', 'span', 'img', 'pre'
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'blockquote',
+        'p',
+        'a',
+        'ul',
+        'ol',
+        'nl',
+        'li',
+        'b',
+        'i',
+        'strong',
+        'em',
+        'strike',
+        'code',
+        'hr',
+        'br',
+        'div',
+        'span',
+        'img',
+        'pre',
       ],
       allowedAttributes: {
-        'a': ['href', 'title'],
-        'img': ['src', 'alt', 'title', 'width', 'height'],
-        '*': ['class', 'id']
+        a: ['href', 'title'],
+        img: ['src', 'alt', 'title', 'width', 'height'],
+        '*': ['class', 'id'],
       },
       allowedSchemes: ['http', 'https', 'mailto'],
       allowedSchemesByTag: {
-        img: ['http', 'https', 'data']
-      }
+        img: ['http', 'https', 'data'],
+      },
     });
   }
 
   try {
-    return await handleApiRequest("posts", "add", dataWithDefaults, options);
+    return await handleApiRequest('posts', 'add', dataWithDefaults, options);
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
       // Transform Ghost validation errors into our format
       throw new ValidationError('Post creation failed due to validation errors', [
-        { field: 'post', message: error.originalError }
+        { field: 'post', message: error.originalError },
       ]);
     }
     throw error;
@@ -249,19 +270,19 @@ export async function updatePost(postId, updateData, options = {}) {
   if (!postId) {
     throw new ValidationError('Post ID is required for update');
   }
-  
+
   // Get the current post first to ensure it exists
   try {
-    const existingPost = await handleApiRequest("posts", "read", { id: postId });
-    
+    const existingPost = await handleApiRequest('posts', 'read', { id: postId });
+
     // Merge with existing data
     const mergedData = {
       ...existingPost,
       ...updateData,
-      updated_at: existingPost.updated_at // Required for Ghost API
+      updated_at: existingPost.updated_at, // Required for Ghost API
     };
-    
-    return await handleApiRequest("posts", "edit", mergedData, { id: postId, ...options });
+
+    return await handleApiRequest('posts', 'edit', mergedData, { id: postId, ...options });
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
       throw new NotFoundError('Post', postId);
@@ -274,9 +295,9 @@ export async function deletePost(postId) {
   if (!postId) {
     throw new ValidationError('Post ID is required for deletion');
   }
-  
+
   try {
-    return await handleApiRequest("posts", "delete", { id: postId });
+    return await handleApiRequest('posts', 'delete', { id: postId });
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
       throw new NotFoundError('Post', postId);
@@ -289,9 +310,9 @@ export async function getPost(postId, options = {}) {
   if (!postId) {
     throw new ValidationError('Post ID is required');
   }
-  
+
   try {
-    return await handleApiRequest("posts", "read", { id: postId }, options);
+    return await handleApiRequest('posts', 'read', { id: postId }, options);
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
       throw new NotFoundError('Post', postId);
@@ -304,13 +325,13 @@ export async function getPosts(options = {}) {
   const defaultOptions = {
     limit: 15,
     include: 'tags,authors',
-    ...options
+    ...options,
   };
-  
+
   try {
-    return await handleApiRequest("posts", "browse", {}, defaultOptions);
+    return await handleApiRequest('posts', 'browse', {}, defaultOptions);
   } catch (error) {
-    console.error("Failed to get posts:", error);
+    console.error('Failed to get posts:', error);
     throw error;
   }
 }
@@ -318,11 +339,11 @@ export async function getPosts(options = {}) {
 export async function uploadImage(imagePath) {
   // Validate input
   await validators.validateImagePath(imagePath);
-  
+
   const imageData = { file: imagePath };
-  
+
   try {
-    return await handleApiRequest("images", "upload", imageData);
+    return await handleApiRequest('images', 'upload', imageData);
   } catch (error) {
     if (error instanceof GhostAPIError) {
       throw new ValidationError(`Image upload failed: ${error.originalError}`);
@@ -334,7 +355,7 @@ export async function uploadImage(imagePath) {
 export async function createTag(tagData) {
   // Validate input
   validators.validateTagData(tagData);
-  
+
   // Auto-generate slug if not provided
   if (!tagData.slug) {
     tagData.slug = tagData.name
@@ -342,9 +363,9 @@ export async function createTag(tagData) {
       .replace(/[^a-z0-9]+/g, '-')
       .replace(/^-+|-+$/g, '');
   }
-  
+
   try {
-    return await handleApiRequest("tags", "add", tagData);
+    return await handleApiRequest('tags', 'add', tagData);
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
       // Check if it's a duplicate tag error
@@ -356,7 +377,7 @@ export async function createTag(tagData) {
         }
       }
       throw new ValidationError('Tag creation failed', [
-        { field: 'tag', message: error.originalError }
+        { field: 'tag', message: error.originalError },
       ]);
     }
     throw error;
@@ -365,15 +386,15 @@ export async function createTag(tagData) {
 
 export async function getTags(name) {
   const options = {
-    limit: "all",
+    limit: 'all',
     ...(name && { filter: `name:'${name}'` }),
   };
-  
+
   try {
-    const tags = await handleApiRequest("tags", "browse", {}, options);
+    const tags = await handleApiRequest('tags', 'browse', {}, options);
     return tags || [];
   } catch (error) {
-    console.error("Failed to get tags:", error);
+    console.error('Failed to get tags:', error);
     throw error;
   }
 }
@@ -382,9 +403,9 @@ export async function getTag(tagId) {
   if (!tagId) {
     throw new ValidationError('Tag ID is required');
   }
-  
+
   try {
-    return await handleApiRequest("tags", "read", { id: tagId });
+    return await handleApiRequest('tags', 'read', { id: tagId });
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
       throw new NotFoundError('Tag', tagId);
@@ -397,24 +418,24 @@ export async function updateTag(tagId, updateData) {
   if (!tagId) {
     throw new ValidationError('Tag ID is required for update');
   }
-  
+
   validators.validateTagData({ name: 'dummy', ...updateData }); // Validate update data
-  
+
   try {
     const existingTag = await getTag(tagId);
     const mergedData = {
       ...existingTag,
-      ...updateData
+      ...updateData,
     };
-    
-    return await handleApiRequest("tags", "edit", mergedData, { id: tagId });
+
+    return await handleApiRequest('tags', 'edit', mergedData, { id: tagId });
   } catch (error) {
     if (error instanceof NotFoundError) {
       throw error;
     }
     if (error instanceof GhostAPIError && error.ghostStatusCode === 422) {
       throw new ValidationError('Tag update failed', [
-        { field: 'tag', message: error.originalError }
+        { field: 'tag', message: error.originalError },
       ]);
     }
     throw error;
@@ -425,9 +446,9 @@ export async function deleteTag(tagId) {
   if (!tagId) {
     throw new ValidationError('Tag ID is required for deletion');
   }
-  
+
   try {
-    return await handleApiRequest("tags", "delete", { id: tagId });
+    return await handleApiRequest('tags', 'delete', { id: tagId });
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
       throw new NotFoundError('Tag', tagId);
@@ -443,34 +464,29 @@ export async function checkHealth() {
   try {
     const site = await getSiteInfo();
     const circuitState = ghostCircuitBreaker.getState();
-    
+
     return {
       status: 'healthy',
       site: {
         title: site.title,
         version: site.version,
-        url: site.url
+        url: site.url,
       },
       circuitBreaker: circuitState,
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     };
   } catch (error) {
     return {
       status: 'unhealthy',
       error: error.message,
       circuitBreaker: ghostCircuitBreaker.getState(),
-      timestamp: new Date().toISOString()
+      timestamp: new Date().toISOString(),
     };
   }
 }
 
 // Export everything including the API client for backward compatibility
-export {
-  api,
-  handleApiRequest,
-  ghostCircuitBreaker,
-  validators
-};
+export { api, handleApiRequest, ghostCircuitBreaker, validators };
 
 export default {
   getSiteInfo,
@@ -485,5 +501,5 @@ export default {
   getTag,
   updateTag,
   deleteTag,
-  checkHealth
-};
+  checkHealth,
+};

package/src/services/imageProcessingService.js

@@ -1,8 +1,8 @@
-import sharp from "sharp";
-import path from "path";
-import fs from "fs";
-import Joi from "joi";
-import { createContextLogger } from "../utils/logger.js";
+import sharp from 'sharp';
+import path from 'path';
+import fs from 'fs';
+import Joi from 'joi';
+import { createContextLogger } from '../utils/logger.js';
 
 // Define processing parameters (e.g., max width)
 const MAX_WIDTH = 1200;
@@ -17,32 +17,32 @@ const OUTPUT_QUALITY = 80; // JPEG quality
 // Validation schema for processing parameters
 const processImageSchema = Joi.object({
   inputPath: Joi.string().required(),
-  outputDir: Joi.string().required()
+  outputDir: Joi.string().required(),
 });
 
 const processImage = async (inputPath, outputDir) => {
   const logger = createContextLogger('image-processing');
-  
+
   // Validate inputs to prevent path injection
   const { error } = processImageSchema.validate({ inputPath, outputDir });
   if (error) {
     logger.error('Invalid processing parameters', {
       error: error.details[0].message,
       inputPath: path.basename(inputPath),
-      outputDir: path.basename(outputDir)
+      outputDir: path.basename(outputDir),
     });
     throw new Error('Invalid processing parameters');
   }
-  
+
   // Ensure paths are safe
   const resolvedInputPath = path.resolve(inputPath);
   const resolvedOutputDir = path.resolve(outputDir);
-  
+
   // Verify input file exists
   if (!fs.existsSync(resolvedInputPath)) {
     throw new Error('Input file does not exist');
   }
-  
+
   const filename = path.basename(resolvedInputPath);
   const nameWithoutExt = filename.split('.').slice(0, -1).join('.');
   // Use timestamp for unique output filename
@@ -53,7 +53,7 @@ const processImage = async (inputPath, outputDir) => {
   try {
     logger.info('Processing image', {
       inputFile: path.basename(inputPath),
-      outputDir: path.basename(outputDir)
+      outputDir: path.basename(outputDir),
     });
     const image = sharp(inputPath);
     const metadata = await image.metadata();
@@ -65,7 +65,7 @@ const processImage = async (inputPath, outputDir) => {
       logger.info('Resizing image', {
         originalWidth: metadata.width,
         targetWidth: MAX_WIDTH,
-        inputFile: path.basename(inputPath)
+        inputFile: path.basename(inputPath),
       });
       processedImage = processedImage.resize({ width: MAX_WIDTH });
     }
@@ -78,14 +78,14 @@ const processImage = async (inputPath, outputDir) => {
       inputFile: path.basename(inputPath),
       outputFile: path.basename(outputPath),
       originalSize: metadata.size,
-      quality: OUTPUT_QUALITY
+      quality: OUTPUT_QUALITY,
     });
     return outputPath;
   } catch (error) {
     logger.error('Image processing failed', {
       inputFile: path.basename(inputPath),
       error: error.message,
-      stack: error.stack
+      stack: error.stack,
     });
     // If processing fails, maybe fall back to using the original?
     // Or throw the error to fail the upload.