@jgardner04/ghost-mcp-server 1.1.10 → 1.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "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/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');
   }

package/src/utils/__tests__/logger.test.js

@@ -0,0 +1,512 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createContextLogger } from '../logger.js';
+import logger from '../logger.js';
+
+describe('logger', () => {
+  describe('default logger export', () => {
+    it('should export a winston logger instance', () => {
+      expect(logger).toBeDefined();
+      expect(typeof logger.info).toBe('function');
+      expect(typeof logger.error).toBe('function');
+      expect(typeof logger.warn).toBe('function');
+      expect(typeof logger.debug).toBe('function');
+    });
+
+    it('should have core logging methods', () => {
+      expect(logger).toHaveProperty('info');
+      expect(logger).toHaveProperty('error');
+      expect(logger).toHaveProperty('warn');
+      expect(logger).toHaveProperty('debug');
+      expect(logger).toHaveProperty('log');
+    });
+  });
+
+  describe('createContextLogger', () => {
+    let contextLogger;
+    let logSpy;
+
+    beforeEach(() => {
+      // Spy on the underlying logger methods
+      logSpy = {
+        debug: vi.spyOn(logger, 'debug').mockImplementation(() => {}),
+        info: vi.spyOn(logger, 'info').mockImplementation(() => {}),
+        warn: vi.spyOn(logger, 'warn').mockImplementation(() => {}),
+        error: vi.spyOn(logger, 'error').mockImplementation(() => {}),
+      };
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    describe('return value structure', () => {
+      it('should return an object with expected methods', () => {
+        contextLogger = createContextLogger('test-context');
+
+        expect(contextLogger).toBeDefined();
+        expect(typeof contextLogger).toBe('object');
+      });
+
+      it('should have basic logging methods', () => {
+        contextLogger = createContextLogger('test-context');
+
+        expect(typeof contextLogger.info).toBe('function');
+        expect(typeof contextLogger.warn).toBe('function');
+        expect(typeof contextLogger.error).toBe('function');
+        expect(typeof contextLogger.debug).toBe('function');
+      });
+
+      it('should have API-specific methods', () => {
+        contextLogger = createContextLogger('test-context');
+
+        expect(typeof contextLogger.apiRequest).toBe('function');
+        expect(typeof contextLogger.apiResponse).toBe('function');
+        expect(typeof contextLogger.apiError).toBe('function');
+      });
+
+      it('should have tool-specific methods', () => {
+        contextLogger = createContextLogger('test-context');
+
+        expect(typeof contextLogger.toolExecution).toBe('function');
+        expect(typeof contextLogger.toolSuccess).toBe('function');
+        expect(typeof contextLogger.toolError).toBe('function');
+      });
+
+      it('should have file operation method', () => {
+        contextLogger = createContextLogger('test-context');
+
+        expect(typeof contextLogger.fileOperation).toBe('function');
+      });
+    });
+
+    describe('basic logging methods', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('test-service');
+      });
+
+      it('should call logger.debug with context', () => {
+        contextLogger.debug('debug message');
+
+        expect(logSpy.debug).toHaveBeenCalledWith('debug message', {
+          context: 'test-service',
+        });
+      });
+
+      it('should call logger.info with context', () => {
+        contextLogger.info('info message');
+
+        expect(logSpy.info).toHaveBeenCalledWith('info message', {
+          context: 'test-service',
+        });
+      });
+
+      it('should call logger.warn with context', () => {
+        contextLogger.warn('warning message');
+
+        expect(logSpy.warn).toHaveBeenCalledWith('warning message', {
+          context: 'test-service',
+        });
+      });
+
+      it('should call logger.error with context', () => {
+        contextLogger.error('error message');
+
+        expect(logSpy.error).toHaveBeenCalledWith('error message', {
+          context: 'test-service',
+        });
+      });
+
+      it('should merge additional metadata with context', () => {
+        contextLogger.info('info message', { userId: '123', action: 'login' });
+
+        expect(logSpy.info).toHaveBeenCalledWith('info message', {
+          context: 'test-service',
+          userId: '123',
+          action: 'login',
+        });
+      });
+
+      it('should handle empty metadata object', () => {
+        contextLogger.info('info message', {});
+
+        expect(logSpy.info).toHaveBeenCalledWith('info message', {
+          context: 'test-service',
+        });
+      });
+
+      it('should work with different context values', () => {
+        const logger1 = createContextLogger('service-a');
+        const logger2 = createContextLogger('service-b');
+
+        logger1.info('message from A');
+        logger2.info('message from B');
+
+        expect(logSpy.info).toHaveBeenCalledWith('message from A', {
+          context: 'service-a',
+        });
+        expect(logSpy.info).toHaveBeenCalledWith('message from B', {
+          context: 'service-b',
+        });
+      });
+    });
+
+    describe('apiRequest method', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('api-handler');
+      });
+
+      it('should log API request with method and URL', () => {
+        contextLogger.apiRequest('GET', '/api/posts');
+
+        expect(logSpy.info).toHaveBeenCalledWith('GET /api/posts', {
+          context: 'api-handler',
+          type: 'api_request',
+        });
+      });
+
+      it('should include additional metadata', () => {
+        contextLogger.apiRequest('POST', '/api/posts', { requestId: 'req-123' });
+
+        expect(logSpy.info).toHaveBeenCalledWith('POST /api/posts', {
+          context: 'api-handler',
+          type: 'api_request',
+          requestId: 'req-123',
+        });
+      });
+
+      it('should handle different HTTP methods', () => {
+        contextLogger.apiRequest('PUT', '/api/posts/1');
+        contextLogger.apiRequest('DELETE', '/api/posts/1');
+        contextLogger.apiRequest('PATCH', '/api/posts/1');
+
+        expect(logSpy.info).toHaveBeenCalledWith('PUT /api/posts/1', expect.any(Object));
+        expect(logSpy.info).toHaveBeenCalledWith('DELETE /api/posts/1', expect.any(Object));
+        expect(logSpy.info).toHaveBeenCalledWith('PATCH /api/posts/1', expect.any(Object));
+      });
+    });
+
+    describe('apiResponse method', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('api-handler');
+      });
+
+      it('should log API response with method, URL, and status', () => {
+        contextLogger.apiResponse('GET', '/api/posts', 200);
+
+        expect(logSpy.info).toHaveBeenCalledWith('GET /api/posts -> 200', {
+          context: 'api-handler',
+          type: 'api_response',
+        });
+      });
+
+      it('should include additional metadata', () => {
+        contextLogger.apiResponse('POST', '/api/posts', 201, { duration: 150 });
+
+        expect(logSpy.info).toHaveBeenCalledWith('POST /api/posts -> 201', {
+          context: 'api-handler',
+          type: 'api_response',
+          duration: 150,
+        });
+      });
+
+      it('should handle different status codes', () => {
+        contextLogger.apiResponse('GET', '/api/posts', 404);
+        contextLogger.apiResponse('POST', '/api/posts', 500);
+
+        expect(logSpy.info).toHaveBeenCalledWith('GET /api/posts -> 404', expect.any(Object));
+        expect(logSpy.info).toHaveBeenCalledWith('POST /api/posts -> 500', expect.any(Object));
+      });
+    });
+
+    describe('apiError method', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('api-handler');
+      });
+
+      it('should log API error with method, URL, and error details', () => {
+        const error = new Error('Connection timeout');
+        error.stack = 'Error: Connection timeout\n    at test.js:1:1';
+
+        contextLogger.apiError('GET', '/api/posts', error);
+
+        expect(logSpy.error).toHaveBeenCalledWith('GET /api/posts failed', {
+          context: 'api-handler',
+          type: 'api_error',
+          error: 'Connection timeout',
+          stack: error.stack,
+        });
+      });
+
+      it('should include additional metadata', () => {
+        const error = new Error('Database error');
+        error.stack = 'Error: Database error\n    at test.js:1:1';
+
+        contextLogger.apiError('POST', '/api/posts', error, { retryCount: 3 });
+
+        expect(logSpy.error).toHaveBeenCalledWith('POST /api/posts failed', {
+          context: 'api-handler',
+          type: 'api_error',
+          error: 'Database error',
+          stack: error.stack,
+          retryCount: 3,
+        });
+      });
+
+      it('should extract error message and stack from error object', () => {
+        const error = new Error('Simple error');
+
+        contextLogger.apiError('GET', '/api/posts', error);
+
+        expect(logSpy.error).toHaveBeenCalledWith('GET /api/posts failed', {
+          context: 'api-handler',
+          type: 'api_error',
+          error: 'Simple error',
+          stack: expect.any(String),
+        });
+      });
+    });
+
+    describe('toolExecution method', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('mcp-server');
+      });
+
+      it('should log tool execution with tool name', () => {
+        contextLogger.toolExecution('ghost_create_post', { title: 'Test' });
+
+        expect(logSpy.info).toHaveBeenCalledWith('Executing tool: ghost_create_post', {
+          context: 'mcp-server',
+          type: 'tool_execution',
+          tool: 'ghost_create_post',
+          inputKeys: ['title'],
+        });
+      });
+
+      it('should handle empty input object', () => {
+        contextLogger.toolExecution('ghost_get_tags', {});
+
+        expect(logSpy.info).toHaveBeenCalledWith('Executing tool: ghost_get_tags', {
+          context: 'mcp-server',
+          type: 'tool_execution',
+          tool: 'ghost_get_tags',
+          inputKeys: [],
+        });
+      });
+
+      it('should handle null input', () => {
+        contextLogger.toolExecution('ghost_get_tags', null);
+
+        expect(logSpy.info).toHaveBeenCalledWith('Executing tool: ghost_get_tags', {
+          context: 'mcp-server',
+          type: 'tool_execution',
+          tool: 'ghost_get_tags',
+          inputKeys: [],
+        });
+      });
+
+      it('should include additional metadata', () => {
+        contextLogger.toolExecution(
+          'ghost_upload_image',
+          { url: 'https://example.com' },
+          { requestId: 'req-456' }
+        );
+
+        expect(logSpy.info).toHaveBeenCalledWith('Executing tool: ghost_upload_image', {
+          context: 'mcp-server',
+          type: 'tool_execution',
+          tool: 'ghost_upload_image',
+          inputKeys: ['url'],
+          requestId: 'req-456',
+        });
+      });
+    });
+
+    describe('toolSuccess method', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('mcp-server');
+      });
+
+      it('should log tool success with tool name and result type', () => {
+        contextLogger.toolSuccess('ghost_create_post', { id: '123' });
+
+        expect(logSpy.info).toHaveBeenCalledWith('Tool ghost_create_post completed successfully', {
+          context: 'mcp-server',
+          type: 'tool_success',
+          tool: 'ghost_create_post',
+          resultType: 'object',
+        });
+      });
+
+      it('should handle different result types', () => {
+        contextLogger.toolSuccess('tool1', 'string result');
+        contextLogger.toolSuccess('tool2', 123);
+        contextLogger.toolSuccess('tool3', true);
+        contextLogger.toolSuccess('tool4', ['array']);
+
+        expect(logSpy.info).toHaveBeenCalledWith(
+          expect.any(String),
+          expect.objectContaining({ resultType: 'string' })
+        );
+        expect(logSpy.info).toHaveBeenCalledWith(
+          expect.any(String),
+          expect.objectContaining({ resultType: 'number' })
+        );
+        expect(logSpy.info).toHaveBeenCalledWith(
+          expect.any(String),
+          expect.objectContaining({ resultType: 'object' })
+        );
+        expect(logSpy.info).toHaveBeenCalledWith(
+          expect.any(String),
+          expect.objectContaining({ resultType: 'object' })
+        );
+      });
+
+      it('should include additional metadata', () => {
+        contextLogger.toolSuccess('ghost_upload_image', { url: 'https://...' }, { duration: 250 });
+
+        expect(logSpy.info).toHaveBeenCalledWith('Tool ghost_upload_image completed successfully', {
+          context: 'mcp-server',
+          type: 'tool_success',
+          tool: 'ghost_upload_image',
+          resultType: 'object',
+          duration: 250,
+        });
+      });
+    });
+
+    describe('toolError method', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('mcp-server');
+      });
+
+      it('should log tool error with tool name and error details', () => {
+        const error = new Error('Upload failed');
+        error.stack = 'Error: Upload failed\n    at test.js:1:1';
+
+        contextLogger.toolError('ghost_upload_image', error);
+
+        expect(logSpy.error).toHaveBeenCalledWith('Tool ghost_upload_image failed', {
+          context: 'mcp-server',
+          type: 'tool_error',
+          tool: 'ghost_upload_image',
+          error: 'Upload failed',
+          stack: error.stack,
+        });
+      });
+
+      it('should include additional metadata', () => {
+        const error = new Error('Validation failed');
+        error.stack = 'Error: Validation failed\n    at test.js:1:1';
+
+        contextLogger.toolError('ghost_create_post', error, {
+          validationErrors: ['title required'],
+        });
+
+        expect(logSpy.error).toHaveBeenCalledWith('Tool ghost_create_post failed', {
+          context: 'mcp-server',
+          type: 'tool_error',
+          tool: 'ghost_create_post',
+          error: 'Validation failed',
+          stack: error.stack,
+          validationErrors: ['title required'],
+        });
+      });
+
+      it('should extract error message and stack from error object', () => {
+        const error = new Error('Simple error');
+
+        contextLogger.toolError('ghost_get_tags', error);
+
+        expect(logSpy.error).toHaveBeenCalledWith('Tool ghost_get_tags failed', {
+          context: 'mcp-server',
+          type: 'tool_error',
+          tool: 'ghost_get_tags',
+          error: 'Simple error',
+          stack: expect.any(String),
+        });
+      });
+    });
+
+    describe('fileOperation method', () => {
+      beforeEach(() => {
+        contextLogger = createContextLogger('image-processor');
+      });
+
+      it('should log file operation with operation type and filename', () => {
+        contextLogger.fileOperation('write', '/tmp/images/test.jpg');
+
+        expect(logSpy.debug).toHaveBeenCalledWith('File operation: write', {
+          context: 'image-processor',
+          type: 'file_operation',
+          operation: 'write',
+          file: 'test.jpg',
+        });
+      });
+
+      it('should extract basename from full path', () => {
+        contextLogger.fileOperation('read', '/very/long/path/to/image.png');
+
+        expect(logSpy.debug).toHaveBeenCalledWith('File operation: read', {
+          context: 'image-processor',
+          type: 'file_operation',
+          operation: 'read',
+          file: 'image.png',
+        });
+      });
+
+      it('should handle different operation types', () => {
+        contextLogger.fileOperation('delete', '/tmp/old-file.jpg');
+        contextLogger.fileOperation('move', '/tmp/new-location.jpg');
+
+        expect(logSpy.debug).toHaveBeenCalledWith('File operation: delete', expect.any(Object));
+        expect(logSpy.debug).toHaveBeenCalledWith('File operation: move', expect.any(Object));
+      });
+
+      it('should include additional metadata', () => {
+        contextLogger.fileOperation('optimize', '/tmp/image.jpg', { size: 1024, quality: 80 });
+
+        expect(logSpy.debug).toHaveBeenCalledWith('File operation: optimize', {
+          context: 'image-processor',
+          type: 'file_operation',
+          operation: 'optimize',
+          file: 'image.jpg',
+          size: 1024,
+          quality: 80,
+        });
+      });
+    });
+
+    describe('context isolation', () => {
+      it('should maintain separate contexts for different loggers', () => {
+        const logger1 = createContextLogger('service-1');
+        const logger2 = createContextLogger('service-2');
+
+        logger1.info('message 1');
+        logger2.info('message 2');
+
+        expect(logSpy.info).toHaveBeenCalledWith('message 1', {
+          context: 'service-1',
+        });
+        expect(logSpy.info).toHaveBeenCalledWith('message 2', {
+          context: 'service-2',
+        });
+      });
+
+      it('should not leak metadata between calls', () => {
+        contextLogger = createContextLogger('test');
+
+        contextLogger.info('first', { value: 1 });
+        contextLogger.info('second', { value: 2 });
+
+        expect(logSpy.info).toHaveBeenNthCalledWith(1, 'first', {
+          context: 'test',
+          value: 1,
+        });
+        expect(logSpy.info).toHaveBeenNthCalledWith(2, 'second', {
+          context: 'test',
+          value: 2,
+        });
+      });
+    });
+  });
+});