@jgardner04/ghost-mcp-server 1.1.9 → 1.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.1.9",
+  "version": "1.1.11",
   "description": "A Model Context Protocol (MCP) server for interacting with Ghost CMS via the Admin API",
   "author": "Jonathan Gardner",
   "type": "module",

package/src/services/__tests__/imageProcessingService.test.js

@@ -0,0 +1,204 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock sharp with chainable API
+const mockMetadata = vi.fn();
+const mockResize = vi.fn();
+const mockJpeg = vi.fn();
+const mockToFile = vi.fn();
+
+const createMockSharp = () => {
+  const instance = {
+    metadata: mockMetadata,
+    resize: mockResize,
+    jpeg: mockJpeg,
+  };
+
+  // Make methods chainable
+  mockResize.mockReturnValue(instance);
+  mockJpeg.mockReturnValue(instance);
+  instance.toFile = mockToFile;
+
+  return instance;
+};
+
+vi.mock('sharp', () => ({
+  default: vi.fn(() => createMockSharp()),
+}));
+
+// Mock fs
+vi.mock('fs', () => ({
+  default: {
+    existsSync: vi.fn(),
+  },
+}));
+
+// Mock path - use actual implementation but allow spying
+vi.mock('path', async () => {
+  const actual = await vi.importActual('path');
+  return {
+    default: actual.default,
+    ...actual,
+  };
+});
+
+// Import after mocks are set up
+import { processImage } from '../imageProcessingService.js';
+import sharp from 'sharp';
+import fs from 'fs';
+
+describe('imageProcessingService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset mock implementations
+    mockMetadata.mockResolvedValue({ width: 800, size: 100000 });
+    mockToFile.mockResolvedValue();
+    fs.existsSync.mockReturnValue(true);
+  });
+
+  describe('Input Validation', () => {
+    it('should accept valid inputPath and outputDir', async () => {
+      const inputPath = '/tmp/test-image.jpg';
+      const outputDir = '/tmp/output';
+
+      await processImage(inputPath, outputDir);
+
+      expect(sharp).toHaveBeenCalledWith(inputPath);
+      expect(mockToFile).toHaveBeenCalled();
+    });
+
+    it('should reject missing inputPath', async () => {
+      await expect(processImage(undefined, '/tmp/output')).rejects.toThrow(
+        'Invalid processing parameters'
+      );
+      expect(sharp).not.toHaveBeenCalled();
+    });
+
+    it('should reject missing outputDir', async () => {
+      await expect(processImage('/tmp/test.jpg', undefined)).rejects.toThrow(
+        'Invalid processing parameters'
+      );
+      expect(sharp).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Path Security', () => {
+    it('should resolve paths correctly', async () => {
+      const inputPath = './relative/path/image.jpg';
+      const outputDir = './output';
+
+      await processImage(inputPath, outputDir);
+
+      expect(fs.existsSync).toHaveBeenCalledWith(expect.stringContaining('image.jpg'));
+      expect(mockToFile).toHaveBeenCalledWith(expect.stringContaining('output'));
+    });
+
+    it('should throw error when input file does not exist', async () => {
+      fs.existsSync.mockReturnValue(false);
+
+      await expect(processImage('/tmp/nonexistent.jpg', '/tmp/output')).rejects.toThrow(
+        'Input file does not exist'
+      );
+      expect(sharp).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Image Processing', () => {
+    it('should not resize image when width <= MAX_WIDTH (1200)', async () => {
+      mockMetadata.mockResolvedValue({ width: 1000, size: 100000 });
+
+      await processImage('/tmp/small-image.jpg', '/tmp/output');
+
+      expect(mockResize).not.toHaveBeenCalled();
+      expect(mockJpeg).toHaveBeenCalledWith({ quality: 80 });
+      expect(mockToFile).toHaveBeenCalled();
+    });
+
+    it('should resize image when width > MAX_WIDTH (1200)', async () => {
+      mockMetadata.mockResolvedValue({ width: 2000, size: 200000 });
+
+      await processImage('/tmp/large-image.jpg', '/tmp/output');
+
+      expect(mockResize).toHaveBeenCalledWith({ width: 1200 });
+      expect(mockJpeg).toHaveBeenCalledWith({ quality: 80 });
+      expect(mockToFile).toHaveBeenCalled();
+    });
+
+    it('should generate output filename with timestamp and processed prefix', async () => {
+      const inputPath = '/tmp/test-photo.jpg';
+      const outputDir = '/tmp/output';
+
+      // Mock Date.now to get predictable filename
+      const mockTimestamp = 1234567890;
+      vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+
+      await processImage(inputPath, outputDir);
+
+      expect(mockToFile).toHaveBeenCalledWith(
+        expect.stringMatching(/processed-1234567890-test-photo\.jpg$/)
+      );
+
+      vi.restoreAllMocks();
+    });
+
+    it('should convert image to JPEG with quality setting of 80', async () => {
+      await processImage('/tmp/image.png', '/tmp/output');
+
+      expect(mockJpeg).toHaveBeenCalledWith({ quality: 80 });
+      expect(mockToFile).toHaveBeenCalled();
+    });
+
+    it('should handle images with multiple dots in filename', async () => {
+      const inputPath = '/tmp/my.test.image.png';
+      const outputDir = '/tmp/output';
+      const mockTimestamp = 9999999999;
+      vi.spyOn(Date, 'now').mockReturnValue(mockTimestamp);
+
+      await processImage(inputPath, outputDir);
+
+      expect(mockToFile).toHaveBeenCalledWith(
+        expect.stringMatching(/processed-9999999999-my\.test\.image\.jpg$/)
+      );
+
+      vi.restoreAllMocks();
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should catch and re-throw sharp processing failures', async () => {
+      const processingError = new Error('Sharp processing failed');
+      mockMetadata.mockRejectedValue(processingError);
+
+      await expect(processImage('/tmp/corrupt.jpg', '/tmp/output')).rejects.toThrow(
+        'Image processing failed: Sharp processing failed'
+      );
+    });
+
+    it('should include original error message in re-thrown error', async () => {
+      const originalMessage = 'Input buffer contains unsupported image format';
+      mockToFile.mockRejectedValue(new Error(originalMessage));
+
+      await expect(processImage('/tmp/bad-format.dat', '/tmp/output')).rejects.toThrow(
+        `Image processing failed: ${originalMessage}`
+      );
+    });
+
+    it('should handle errors during JPEG conversion', async () => {
+      const conversionError = new Error('JPEG conversion failed');
+      mockToFile.mockRejectedValue(conversionError);
+
+      await expect(processImage('/tmp/image.jpg', '/tmp/output')).rejects.toThrow(
+        'Image processing failed: JPEG conversion failed'
+      );
+    });
+  });
+});

package/src/services/__tests__/postService.test.js

@@ -0,0 +1,504 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockDotenv } from '../../__tests__/helpers/testUtils.js';
+import { createMockContextLogger } from '../../__tests__/helpers/mockLogger.js';
+
+// Mock dotenv
+vi.mock('dotenv', () => mockDotenv());
+
+// Mock logger
+vi.mock('../../utils/logger.js', () => ({
+  createContextLogger: createMockContextLogger(),
+}));
+
+// Mock ghostService functions - must use factory pattern to avoid hoisting issues
+vi.mock('../ghostService.js', () => ({
+  createPost: vi.fn(),
+  getTags: vi.fn(),
+  createTag: vi.fn(),
+}));
+
+// Import after mocks are set up
+import { createPostService } from '../postService.js';
+import { createPost, getTags, createTag } from '../ghostService.js';
+
+describe('postService', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('createPostService - validation', () => {
+    it('should accept valid input and create a post', async () => {
+      const validInput = {
+        title: 'Test Post',
+        html: '<p>Test content</p>',
+      };
+      const expectedPost = { id: '1', title: 'Test Post', status: 'draft' };
+      createPost.mockResolvedValue(expectedPost);
+
+      const result = await createPostService(validInput);
+
+      expect(result).toEqual(expectedPost);
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          title: 'Test Post',
+          html: '<p>Test content</p>',
+          status: 'draft',
+        })
+      );
+    });
+
+    it('should reject input with missing title', async () => {
+      const invalidInput = {
+        html: '<p>Test content</p>',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow(
+        'Invalid post input: "title" is required'
+      );
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should reject input with missing html', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow(
+        'Invalid post input: "html" is required'
+      );
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should reject input with invalid status', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        status: 'invalid-status',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow(
+        'Invalid post input: "status" must be one of [draft, published, scheduled]'
+      );
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should accept valid status values', async () => {
+      const statuses = ['draft', 'published', 'scheduled'];
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      for (const status of statuses) {
+        const input = {
+          title: 'Test Post',
+          html: '<p>Content</p>',
+          status,
+        };
+
+        await createPostService(input);
+
+        expect(createPost).toHaveBeenCalledWith(expect.objectContaining({ status }));
+        vi.clearAllMocks();
+      }
+    });
+
+    it('should validate tags array with maximum length', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: Array(11).fill('tag'), // 11 tags exceeds max of 10
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should validate tag string max length', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['a'.repeat(51)], // 51 chars exceeds max of 50
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should validate feature_image is a valid URI', async () => {
+      const invalidInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        feature_image: 'not-a-valid-url',
+      };
+
+      await expect(createPostService(invalidInput)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should accept valid feature_image URI', async () => {
+      const validInput = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        feature_image: 'https://example.com/image.jpg',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(validInput);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          feature_image: 'https://example.com/image.jpg',
+        })
+      );
+    });
+  });
+
+  describe('createPostService - tag resolution', () => {
+    it('should find and reuse existing tag', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['existing-tag'],
+      };
+      const existingTag = { id: '1', name: 'existing-tag', slug: 'existing-tag' };
+      getTags.mockResolvedValue([existingTag]);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledWith('existing-tag');
+      expect(createTag).not.toHaveBeenCalled();
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'existing-tag' }],
+        })
+      );
+    });
+
+    it('should create new tag when not found', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['new-tag'],
+      };
+      getTags.mockResolvedValue([]); // Tag not found
+      const newTag = { id: '2', name: 'new-tag', slug: 'new-tag' };
+      createTag.mockResolvedValue(newTag);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledWith('new-tag');
+      expect(createTag).toHaveBeenCalledWith({ name: 'new-tag' });
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'new-tag' }],
+        })
+      );
+    });
+
+    it('should handle errors during tag lookup gracefully', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['error-tag', 'good-tag'],
+      };
+      // First tag causes error, second tag exists
+      getTags
+        .mockRejectedValueOnce(new Error('Tag lookup failed'))
+        .mockResolvedValueOnce([{ id: '1', name: 'good-tag' }]);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      // Should skip error-tag and only include good-tag
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'good-tag' }],
+        })
+      );
+    });
+
+    it('should reject tags array with non-string values', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: [null, 'valid-tag'],
+      };
+
+      await expect(createPostService(input)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should reject tags array with empty strings', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['', 'valid-tag'],
+      };
+
+      await expect(createPostService(input)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should trim whitespace from tag names', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['  trimmed-tag  '],
+      };
+      getTags.mockResolvedValue([{ id: '1', name: 'trimmed-tag' }]);
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledWith('trimmed-tag');
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'trimmed-tag' }],
+        })
+      );
+    });
+
+    it('should handle mixed existing and new tags', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: ['existing-tag', 'new-tag'],
+      };
+      getTags
+        .mockResolvedValueOnce([{ id: '1', name: 'existing-tag' }]) // First tag exists
+        .mockResolvedValueOnce([]); // Second tag doesn't exist
+      createTag.mockResolvedValue({ id: '2', name: 'new-tag' });
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(getTags).toHaveBeenCalledTimes(2);
+      expect(createTag).toHaveBeenCalledTimes(1);
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [{ name: 'existing-tag' }, { name: 'new-tag' }],
+        })
+      );
+    });
+  });
+
+  describe('createPostService - metadata defaults', () => {
+    it('should default meta_title to title when not provided', async () => {
+      const input = {
+        title: 'Test Post Title',
+        html: '<p>Content</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_title: 'Test Post Title',
+        })
+      );
+    });
+
+    it('should use provided meta_title instead of defaulting to title', async () => {
+      const input = {
+        title: 'Test Post Title',
+        html: '<p>Content</p>',
+        meta_title: 'Custom Meta Title',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_title: 'Custom Meta Title',
+        })
+      );
+    });
+
+    it('should default meta_description to custom_excerpt when provided', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Long HTML content that would be stripped</p>',
+        custom_excerpt: 'This is the custom excerpt',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_description: 'This is the custom excerpt',
+        })
+      );
+    });
+
+    it('should generate meta_description from HTML when no excerpt provided', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>This is HTML content with tags stripped</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_description: 'This is HTML content with tags stripped',
+        })
+      );
+    });
+
+    it('should use provided meta_description over custom_excerpt and HTML', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>HTML content</p>',
+        custom_excerpt: 'Custom excerpt',
+        meta_description: 'Explicit meta description',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          meta_description: 'Explicit meta description',
+        })
+      );
+    });
+
+    it('should truncate meta_description to 500 characters with ellipsis when generated from long HTML', async () => {
+      const longHtml = '<p>' + 'a'.repeat(600) + '</p>';
+      const input = {
+        title: 'Test Post',
+        html: longHtml,
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      const calledDescription = createPost.mock.calls[0][0].meta_description;
+      expect(calledDescription).toHaveLength(500);
+      expect(calledDescription.endsWith('...')).toBe(true);
+      expect(calledDescription).toBe('a'.repeat(497) + '...');
+    });
+
+    it('should reject empty HTML content', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '',
+      };
+
+      await expect(createPostService(input)).rejects.toThrow('Invalid post input:');
+      expect(createPost).not.toHaveBeenCalled();
+    });
+
+    it('should strip HTML tags and truncate when generating meta_description', async () => {
+      const longHtml = '<p>' + 'word '.repeat(200) + '</p>';
+      const input = {
+        title: 'Test Post',
+        html: longHtml,
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      const calledDescription = createPost.mock.calls[0][0].meta_description;
+      expect(calledDescription).not.toContain('<p>');
+      expect(calledDescription).not.toContain('</p>');
+      expect(calledDescription.length).toBeLessThanOrEqual(500);
+    });
+  });
+
+  describe('createPostService - complete post creation', () => {
+    it('should create post with all optional fields', async () => {
+      const input = {
+        title: 'Complete Post',
+        html: '<p>Full content</p>',
+        custom_excerpt: 'Excerpt',
+        status: 'published',
+        published_at: '2025-12-10T12:00:00.000Z',
+        tags: ['tag1', 'tag2'],
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Image alt text',
+        feature_image_caption: 'Image caption',
+        meta_title: 'Custom Meta Title',
+        meta_description: 'Custom meta description',
+      };
+      getTags.mockResolvedValue([]);
+      createTag
+        .mockResolvedValueOnce({ id: '1', name: 'tag1' })
+        .mockResolvedValueOnce({ id: '2', name: 'tag2' });
+      createPost.mockResolvedValue({ id: '1', title: 'Complete Post' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith({
+        title: 'Complete Post',
+        html: '<p>Full content</p>',
+        custom_excerpt: 'Excerpt',
+        status: 'published',
+        published_at: '2025-12-10T12:00:00.000Z',
+        tags: [{ name: 'tag1' }, { name: 'tag2' }],
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Image alt text',
+        feature_image_caption: 'Image caption',
+        meta_title: 'Custom Meta Title',
+        meta_description: 'Custom meta description',
+      });
+    });
+
+    it('should default status to draft when not provided', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: 'draft',
+        })
+      );
+    });
+
+    it('should handle post creation with no tags', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [],
+        })
+      );
+      expect(getTags).not.toHaveBeenCalled();
+      expect(createTag).not.toHaveBeenCalled();
+    });
+
+    it('should handle post creation with empty tags array', async () => {
+      const input = {
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        tags: [],
+      };
+      createPost.mockResolvedValue({ id: '1', title: 'Test' });
+
+      await createPostService(input);
+
+      expect(createPost).toHaveBeenCalledWith(
+        expect.objectContaining({
+          tags: [],
+        })
+      );
+      expect(getTags).not.toHaveBeenCalled();
+      expect(createTag).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/services/imageProcessingService.js

@@ -28,8 +28,8 @@ const processImage = async (inputPath, outputDir) => {
   if (error) {
     logger.error('Invalid processing parameters', {
       error: error.details[0].message,
-      inputPath: path.basename(inputPath),
-      outputDir: path.basename(outputDir),
+      inputPath: inputPath ? path.basename(inputPath) : 'undefined',
+      outputDir: outputDir ? path.basename(outputDir) : 'undefined',
     });
     throw new Error('Invalid processing parameters');
   }