@jgardner04/ghost-mcp-server 1.0.0

package/src/services/postService.js

@@ -0,0 +1,174 @@
+import sanitizeHtml from "sanitize-html";
+import Joi from "joi";
+import { createContextLogger } from "../utils/logger.js";
+import {
+  createPost as createGhostPost,
+  getTags as getGhostTags,
+  createTag as createGhostTag,
+  // Import other necessary functions from ghostService later
+} from "./ghostService.js"; // Note the relative path
+
+/**
+ * Helper to generate a simple meta description from HTML content.
+ * Uses sanitize-html to safely strip HTML tags and truncates.
+ * @param {string} htmlContent - The HTML content of the post.
+ * @param {number} maxLength - The maximum length of the description.
+ * @returns {string} A plain text truncated description.
+ */
+const generateSimpleMetaDescription = (htmlContent, maxLength = 500) => {
+  if (!htmlContent) return "";
+  
+  // Use sanitize-html to safely remove all HTML tags
+  // This prevents ReDoS attacks and properly handles malformed HTML
+  const textContent = sanitizeHtml(htmlContent, {
+    allowedTags: [], // Remove all HTML tags
+    allowedAttributes: {},
+    textFilter: function(text) {
+      return text.replace(/\s\s+/g, ' ').trim();
+    }
+  });
+  
+  // Truncate and add ellipsis if needed
+  return textContent.length > maxLength
+    ? textContent.substring(0, maxLength - 3) + "..."
+    : textContent;
+};
+
+/**
+ * Service layer function to handle the business logic of creating a post.
+ * Transforms input data, handles/resolves tags, includes feature image and metadata.
+ * @param {object} postInput - Data received from the controller.
+ * @returns {Promise<object>} The created post object from the Ghost API.
+ */
+// Validation schema for post input
+const postInputSchema = Joi.object({
+  title: Joi.string().max(255).required(),
+  html: Joi.string().required(),
+  custom_excerpt: Joi.string().max(500).optional(),
+  status: Joi.string().valid('draft', 'published', 'scheduled').optional(),
+  published_at: Joi.string().isoDate().optional(),
+  tags: Joi.array().items(Joi.string().max(50)).max(10).optional(),
+  feature_image: Joi.string().uri().optional(),
+  feature_image_alt: Joi.string().max(255).optional(),
+  feature_image_caption: Joi.string().max(500).optional(),
+  meta_title: Joi.string().max(70).optional(),
+  meta_description: Joi.string().max(160).optional()
+});
+
+const createPostService = async (postInput) => {
+  const logger = createContextLogger('post-service');
+  
+  // Validate input to prevent format string vulnerabilities
+  const { error, value: validatedInput } = postInputSchema.validate(postInput);
+  if (error) {
+    logger.error('Post input validation failed', {
+      error: error.details[0].message,
+      inputKeys: Object.keys(postInput)
+    });
+    throw new Error(`Invalid post input: ${error.details[0].message}`);
+  }
+  
+  const {
+    title,
+    html,
+    custom_excerpt,
+    status,
+    published_at,
+    tags, // Expecting array of strings (tag names) here now
+    feature_image,
+    feature_image_alt,
+    feature_image_caption,
+    meta_title,
+    meta_description,
+  } = validatedInput;
+
+  // --- Resolve Tag Names to Tag Objects (ID/Slug/Name) ---
+  let resolvedTags = [];
+  if (tags && Array.isArray(tags) && tags.length > 0) {
+    logger.info('Resolving provided tag names', { tagCount: tags.length, tags });
+    resolvedTags = await Promise.all(
+      tags.map(async (tagName) => {
+        if (typeof tagName !== "string" || !tagName.trim()) {
+          logger.warn('Skipping invalid tag name', { tagName, type: typeof tagName });
+          return null; // Skip invalid entries
+        }
+        tagName = tagName.trim();
+
+        try {
+          // Check if tag exists by name
+          const existingTags = await getGhostTags(tagName);
+          if (existingTags && existingTags.length > 0) {
+            logger.debug('Found existing tag', {
+              tagName,
+              tagId: existingTags[0].id
+            });
+            // Use the existing tag (Ghost usually accepts name, slug, or id)
+            return { name: tagName }; // Or { id: existingTags[0].id } or { slug: existingTags[0].slug }
+          } else {
+            // Tag doesn't exist, create it
+            logger.info('Creating new tag', { tagName });
+            const newTag = await createGhostTag({ name: tagName });
+            logger.info('Created new tag successfully', {
+              tagName,
+              tagId: newTag.id
+            });
+            // Use the new tag
+            return { name: tagName }; // Or { id: newTag.id }
+          }
+        } catch (tagError) {
+          logger.error('Error processing tag', {
+            tagName,
+            error: tagError.message
+          });
+          return null; // Skip tags that cause errors during processing
+        }
+      })
+    );
+    // Filter out any nulls from skipped/errored tags
+    resolvedTags = resolvedTags.filter((tag) => tag !== null);
+    logger.debug('Resolved tags for API', {
+      resolvedTagCount: resolvedTags.length,
+      resolvedTags
+    });
+  }
+  // --- End Tag Resolution ---
+
+  // --- Metadata Defaults/Generation ---
+  const finalMetaTitle = meta_title || title; // Default meta_title to title
+  const finalMetaDescription =
+    meta_description || custom_excerpt || generateSimpleMetaDescription(html); // Default meta_description
+  // Ensure description does not exceed limit even after defaulting
+  const truncatedMetaDescription =
+    finalMetaDescription.length > 500
+      ? finalMetaDescription.substring(0, 497) + "..."
+      : finalMetaDescription;
+  // --- End Metadata Defaults ---
+
+  // Prepare data for the Ghost API, including feature image fields
+  const postDataForApi = {
+    title,
+    html,
+    custom_excerpt,
+    status: status || "draft", // Default to draft
+    published_at,
+    tags: resolvedTags,
+    feature_image,
+    feature_image_alt,
+    feature_image_caption,
+    meta_title: finalMetaTitle, // Use final value
+    meta_description: truncatedMetaDescription, // Use final, truncated value
+    // Add metadata fields here if needed in the future
+  };
+
+  logger.info('Creating Ghost post', {
+    title: postDataForApi.title,
+    status: postDataForApi.status,
+    tagCount: postDataForApi.tags?.length || 0,
+    hasFeatureImage: !!postDataForApi.feature_image
+  });
+  // Call the lower-level ghostService function
+  const newPost = await createGhostPost(postDataForApi);
+  return newPost;
+};
+
+export { createPostService };

package/src/utils/logger.js

@@ -0,0 +1,153 @@
+import winston from 'winston';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get log level from environment or default to 'info'
+const logLevel = process.env.LOG_LEVEL || 'info';
+const isDevelopment = process.env.NODE_ENV === 'development';
+
+// Define custom log format
+const logFormat = winston.format.combine(
+  winston.format.timestamp({
+    format: 'YYYY-MM-DD HH:mm:ss'
+  }),
+  winston.format.errors({ stack: true }),
+  winston.format.json(),
+  winston.format.metadata({ fillExcept: ['message', 'level', 'timestamp'] })
+);
+
+// Development format (more readable)
+const devFormat = winston.format.combine(
+  winston.format.timestamp({
+    format: 'HH:mm:ss'
+  }),
+  winston.format.colorize(),
+  winston.format.printf(({ level, message, timestamp, metadata }) => {
+    let metaString = '';
+    if (metadata && Object.keys(metadata).length > 0) {
+      metaString = ` ${JSON.stringify(metadata)}`;
+    }
+    return `${timestamp} [${level}] ${message}${metaString}`;
+  })
+);
+
+// Create the logger instance
+const logger = winston.createLogger({
+  level: logLevel,
+  format: isDevelopment ? devFormat : logFormat,
+  defaultMeta: { 
+    service: 'ghost-mcp-server',
+    pid: process.pid
+  },
+  transports: [
+    // Console output
+    new winston.transports.Console({
+      level: isDevelopment ? 'debug' : 'info'
+    })
+  ],
+  // Handle uncaught exceptions
+  exceptionHandlers: [
+    new winston.transports.Console()
+  ],
+  // Handle unhandled promise rejections
+  rejectionHandlers: [
+    new winston.transports.Console()
+  ]
+});
+
+// Add file logging in production
+if (!isDevelopment) {
+  const logDir = path.join(__dirname, '../../logs');
+  
+  // Create logs directory if it doesn't exist
+  import('fs').then(fs => {
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+  });
+  
+  // Add file transports for production
+  logger.add(new winston.transports.File({
+    filename: path.join(logDir, 'error.log'),
+    level: 'error',
+    maxsize: 10 * 1024 * 1024, // 10MB
+    maxFiles: 5,
+    tailable: true
+  }));
+  
+  logger.add(new winston.transports.File({
+    filename: path.join(logDir, 'combined.log'),
+    maxsize: 10 * 1024 * 1024, // 10MB
+    maxFiles: 10,
+    tailable: true
+  }));
+}
+
+// Create helper functions for common logging patterns
+const createContextLogger = (context) => {
+  return {
+    debug: (message, meta = {}) => logger.debug(message, { ...meta, context }),
+    info: (message, meta = {}) => logger.info(message, { ...meta, context }),
+    warn: (message, meta = {}) => logger.warn(message, { ...meta, context }),
+    error: (message, meta = {}) => logger.error(message, { ...meta, context }),
+    
+    // Convenience methods for common patterns
+    apiRequest: (method, url, meta = {}) => 
+      logger.info(`${method} ${url}`, { ...meta, context, type: 'api_request' }),
+    
+    apiResponse: (method, url, status, meta = {}) =>
+      logger.info(`${method} ${url} -> ${status}`, { ...meta, context, type: 'api_response' }),
+    
+    apiError: (method, url, error, meta = {}) =>
+      logger.error(`${method} ${url} failed`, { 
+        ...meta, 
+        context, 
+        type: 'api_error',
+        error: error.message,
+        stack: error.stack 
+      }),
+    
+    toolExecution: (toolName, input, meta = {}) =>
+      logger.info(`Executing tool: ${toolName}`, { 
+        ...meta, 
+        context, 
+        type: 'tool_execution',
+        tool: toolName,
+        inputKeys: Object.keys(input || {})
+      }),
+    
+    toolSuccess: (toolName, result, meta = {}) =>
+      logger.info(`Tool ${toolName} completed successfully`, {
+        ...meta,
+        context,
+        type: 'tool_success',
+        tool: toolName,
+        resultType: typeof result
+      }),
+    
+    toolError: (toolName, error, meta = {}) =>
+      logger.error(`Tool ${toolName} failed`, {
+        ...meta,
+        context,
+        type: 'tool_error',
+        tool: toolName,
+        error: error.message,
+        stack: error.stack
+      }),
+      
+    fileOperation: (operation, filePath, meta = {}) =>
+      logger.debug(`File operation: ${operation}`, {
+        ...meta,
+        context,
+        type: 'file_operation',
+        operation,
+        file: path.basename(filePath)
+      })
+  };
+};
+
+export default logger;
+export { createContextLogger };

package/src/utils/urlValidator.js

@@ -0,0 +1,169 @@
+import Joi from 'joi';
+import { URL } from 'url';
+
+// Configure allowed domains for image downloads
+const ALLOWED_DOMAINS = [
+  // Common CDNs and image hosting services
+  'imgur.com',
+  'i.imgur.com',
+  'github.com',
+  'githubusercontent.com',
+  'unsplash.com',
+  'images.unsplash.com',
+  'cloudinary.com',
+  'res.cloudinary.com',
+  'amazonaws.com',
+  's3.amazonaws.com',
+  'googleusercontent.com',
+  'gravatar.com',
+  'secure.gravatar.com',
+  'wp.com',
+  'wordpress.com',
+  'flickr.com',
+  'staticflickr.com',
+  'dropbox.com',
+  'dl.dropboxusercontent.com',
+  'pexels.com',
+  'images.pexels.com',
+  'pixabay.com',
+  'cdn.pixabay.com'
+];
+
+// Private/internal IP ranges to block
+const BLOCKED_IP_PATTERNS = [
+  /^127\./, // 127.0.0.0/8 - localhost
+  /^10\./, // 10.0.0.0/8 - private
+  /^172\.(1[6-9]|2[0-9]|3[0-1])\./, // 172.16.0.0/12 - private
+  /^192\.168\./, // 192.168.0.0/16 - private
+  /^169\.254\./, // 169.254.0.0/16 - link local
+  /^0\./, // 0.0.0.0/8
+  /^224\./, // 224.0.0.0/4 - multicast
+  /^240\./, // 240.0.0.0/4 - reserved
+  /^255\.255\.255\.255$/, // broadcast
+  /^::1$/, // IPv6 localhost
+  /^::/, // IPv6 unspecified
+  /^fc00:/, // IPv6 unique local
+  /^fe80:/, // IPv6 link local
+  /^ff00:/ // IPv6 multicast
+];
+
+/**
+ * Validates if a hostname/IP is safe for external requests
+ * @param {string} hostname - The hostname or IP to validate
+ * @returns {boolean} True if safe, false if blocked
+ */
+const isSafeHost = (hostname) => {
+  // Check if hostname is an IP address
+  const ipv4Pattern = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+  const ipv6Pattern = /^[0-9a-f:]+$/i;
+  
+  if (ipv4Pattern.test(hostname) || ipv6Pattern.test(hostname)) {
+    // Check against blocked IP patterns
+    return !BLOCKED_IP_PATTERNS.some(pattern => pattern.test(hostname));
+  }
+  
+  // For domain names, check against allowlist
+  const normalizedHost = hostname.toLowerCase();
+  return ALLOWED_DOMAINS.some(allowed => 
+    normalizedHost === allowed || normalizedHost.endsWith('.' + allowed)
+  );
+};
+
+/**
+ * Validates and sanitizes a URL for safe external requests
+ * @param {string} url - The URL to validate
+ * @returns {object} Validation result with isValid boolean and sanitizedUrl
+ */
+const validateImageUrl = (url) => {
+  try {
+    // Basic URL validation with Joi
+    const urlSchema = Joi.string().uri({
+      scheme: ['http', 'https'],
+      allowRelative: false
+    }).required();
+    
+    const validation = urlSchema.validate(url);
+    if (validation.error) {
+      return {
+        isValid: false,
+        error: `Invalid URL format: ${validation.error.details[0].message}`
+      };
+    }
+    
+    // Parse URL for additional security checks
+    const parsedUrl = new URL(url);
+    
+    // Only allow HTTP/HTTPS
+    if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+      return {
+        isValid: false,
+        error: 'Only HTTP and HTTPS protocols are allowed'
+      };
+    }
+    
+    // Check if host is safe (not internal/private)
+    if (!isSafeHost(parsedUrl.hostname)) {
+      return {
+        isValid: false,
+        error: `Requests to ${parsedUrl.hostname} are not allowed for security reasons`
+      };
+    }
+    
+    // Prevent requests to non-standard ports (common in SSRF attacks)
+    const port = parsedUrl.port;
+    if (port && !['80', '443', '8080', '8443'].includes(port)) {
+      return {
+        isValid: false,
+        error: `Requests to non-standard port ${port} are not allowed`
+      };
+    }
+    
+    // Additional checks for suspicious patterns
+    if (parsedUrl.hostname.includes('localhost') || 
+        parsedUrl.hostname === '0.0.0.0' ||
+        parsedUrl.hostname.startsWith('192.168.') ||
+        parsedUrl.hostname.startsWith('10.') ||
+        parsedUrl.hostname.includes('.local')) {
+      return {
+        isValid: false,
+        error: 'Requests to local/private addresses are not allowed'
+      };
+    }
+    
+    return {
+      isValid: true,
+      sanitizedUrl: parsedUrl.href
+    };
+    
+  } catch (error) {
+    return {
+      isValid: false,
+      error: `URL parsing failed: ${error.message}`
+    };
+  }
+};
+
+/**
+ * Configures axios with security settings for external requests
+ * @param {string} url - The validated URL to request
+ * @returns {object} Axios configuration with security settings
+ */
+const createSecureAxiosConfig = (url) => {
+  return {
+    url,
+    responseType: 'stream',
+    timeout: 10000, // 10 second timeout
+    maxRedirects: 3, // Limit redirects
+    maxContentLength: 50 * 1024 * 1024, // 50MB max response
+    validateStatus: (status) => status >= 200 && status < 300, // Only accept 2xx
+    headers: {
+      'User-Agent': 'Ghost-MCP-Server/1.0'
+    }
+  };
+};
+
+export {
+  validateImageUrl,
+  createSecureAxiosConfig,
+  ALLOWED_DOMAINS
+};