@jgardner04/ghost-mcp-server 1.1.11 → 1.1.13

package/src/__tests__/mcp_server.test.js

@@ -0,0 +1,381 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Store tool implementations for testing
+const toolImplementations = {};
+
+// Mock MCP SDK
+vi.mock('@modelcontextprotocol/sdk/server/index.js', () => {
+  const mockServerInstance = {
+    addResource: vi.fn(),
+    addTool: vi.fn(),
+    listen: vi.fn().mockResolvedValue(undefined),
+    listResources: vi.fn().mockReturnValue([{ name: 'ghost/tag' }, { name: 'ghost/post' }]),
+    listTools: vi
+      .fn()
+      .mockReturnValue([
+        { name: 'ghost_create_post' },
+        { name: 'ghost_upload_image' },
+        { name: 'ghost_get_tags' },
+        { name: 'ghost_create_tag' },
+      ]),
+  };
+
+  return {
+    MCPServer: class MockMCPServer {
+      constructor() {
+        Object.assign(this, mockServerInstance);
+      }
+
+      static getInstance() {
+        return mockServerInstance;
+      }
+    },
+    Resource: class MockResource {
+      constructor(config) {
+        this.name = config.name;
+        this.description = config.description;
+        this.schema = config.schema;
+      }
+    },
+    Tool: class MockTool {
+      constructor(config) {
+        toolImplementations[config.name] = config.implementation;
+        this.name = config.name;
+        this.description = config.description;
+        this.inputSchema = config.inputSchema;
+        this.outputSchema = config.outputSchema;
+        this.implementation = config.implementation;
+      }
+    },
+  };
+});
+
+// Mock dotenv
+vi.mock('dotenv', () => ({
+  default: { config: vi.fn() },
+}));
+
+// Mock services
+const mockCreatePostService = vi.fn();
+const mockUploadGhostImage = vi.fn();
+const mockGetGhostTags = vi.fn();
+const mockCreateGhostTag = vi.fn();
+const mockProcessImage = vi.fn();
+
+vi.mock('../services/postService.js', () => ({
+  createPostService: (...args) => mockCreatePostService(...args),
+}));
+
+vi.mock('../services/ghostService.js', () => ({
+  uploadImage: (...args) => mockUploadGhostImage(...args),
+  getTags: (...args) => mockGetGhostTags(...args),
+  createTag: (...args) => mockCreateGhostTag(...args),
+}));
+
+vi.mock('../services/imageProcessingService.js', () => ({
+  processImage: (...args) => mockProcessImage(...args),
+}));
+
+// Mock axios
+const mockAxios = vi.fn();
+vi.mock('axios', () => ({
+  default: (...args) => mockAxios(...args),
+}));
+
+// Mock fs
+const mockUnlink = vi.fn((path, cb) => cb(null));
+const mockCreateWriteStream = vi.fn();
+vi.mock('fs', () => ({
+  default: {
+    unlink: (...args) => mockUnlink(...args),
+    createWriteStream: (...args) => mockCreateWriteStream(...args),
+  },
+}));
+
+// Mock os
+vi.mock('os', () => ({
+  default: { tmpdir: vi.fn().mockReturnValue('/tmp') },
+}));
+
+// Mock uuid
+vi.mock('uuid', () => ({
+  v4: vi.fn().mockReturnValue('test-uuid-1234'),
+}));
+
+// Mock urlValidator
+const mockValidateImageUrl = vi.fn();
+const mockCreateSecureAxiosConfig = vi.fn();
+vi.mock('../utils/urlValidator.js', () => ({
+  validateImageUrl: (...args) => mockValidateImageUrl(...args),
+  createSecureAxiosConfig: (...args) => mockCreateSecureAxiosConfig(...args),
+}));
+
+// Mock logger
+vi.mock('../utils/logger.js', () => ({
+  createContextLogger: vi.fn().mockReturnValue({
+    info: vi.fn(),
+    error: vi.fn(),
+    warn: vi.fn(),
+    debug: vi.fn(),
+    toolExecution: vi.fn(),
+    toolSuccess: vi.fn(),
+    toolError: vi.fn(),
+    fileOperation: vi.fn(),
+  }),
+}));
+
+describe('mcp_server', () => {
+  let mcpServerModule;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Import module once to register tools
+    if (!mcpServerModule) {
+      mcpServerModule = await import('../mcp_server.js');
+    }
+  });
+
+  describe('ghost_create_post tool', () => {
+    it('should call createPostService with input and return result', async () => {
+      const createdPost = {
+        id: '1',
+        title: 'Test Post',
+        html: '<p>Content</p>',
+        status: 'draft',
+      };
+      mockCreatePostService.mockResolvedValue(createdPost);
+
+      const input = { title: 'Test Post', html: '<p>Content</p>' };
+      const result = await toolImplementations.ghost_create_post(input);
+
+      expect(mockCreatePostService).toHaveBeenCalledWith(input);
+      expect(result).toEqual(createdPost);
+    });
+
+    it('should handle tags and other optional fields', async () => {
+      const createdPost = { id: '1', title: 'Test', tags: ['tech'] };
+      mockCreatePostService.mockResolvedValue(createdPost);
+
+      const input = {
+        title: 'Test',
+        html: '<p>Content</p>',
+        tags: ['tech'],
+        status: 'published',
+        feature_image: 'https://example.com/image.jpg',
+      };
+      const result = await toolImplementations.ghost_create_post(input);
+
+      expect(mockCreatePostService).toHaveBeenCalledWith(input);
+      expect(result).toEqual(createdPost);
+    });
+
+    it('should throw wrapped error when service fails', async () => {
+      mockCreatePostService.mockRejectedValue(new Error('Database error'));
+
+      const input = { title: 'Test Post', html: '<p>Content</p>' };
+
+      await expect(toolImplementations.ghost_create_post(input)).rejects.toThrow(
+        'Failed to create Ghost post: Database error'
+      );
+    });
+  });
+
+  describe('ghost_upload_image tool', () => {
+    beforeEach(() => {
+      mockValidateImageUrl.mockReturnValue({
+        isValid: true,
+        sanitizedUrl: 'https://example.com/image.jpg',
+      });
+      mockCreateSecureAxiosConfig.mockReturnValue({
+        url: 'https://example.com/image.jpg',
+        responseType: 'stream',
+      });
+
+      const mockWriter = {
+        on: vi.fn((event, cb) => {
+          if (event === 'finish') setTimeout(cb, 0);
+          return mockWriter;
+        }),
+      };
+      mockCreateWriteStream.mockReturnValue(mockWriter);
+
+      const mockStream = { pipe: vi.fn().mockReturnValue(mockWriter) };
+      mockAxios.mockResolvedValue({ data: mockStream });
+
+      mockProcessImage.mockResolvedValue('/tmp/processed-image.jpg');
+      mockUploadGhostImage.mockResolvedValue({
+        url: 'https://ghost.com/content/images/image.jpg',
+      });
+    });
+
+    it('should validate image URL for SSRF protection', async () => {
+      mockValidateImageUrl.mockReturnValue({
+        isValid: false,
+        error: 'Private IP address not allowed',
+      });
+
+      const input = { imageUrl: 'http://192.168.1.1/image.jpg' };
+
+      await expect(toolImplementations.ghost_upload_image(input)).rejects.toThrow(
+        'Invalid image URL: Private IP address not allowed'
+      );
+    });
+
+    it('should download, process, and upload image successfully', async () => {
+      const input = { imageUrl: 'https://example.com/image.jpg' };
+      const result = await toolImplementations.ghost_upload_image(input);
+
+      expect(mockValidateImageUrl).toHaveBeenCalledWith(input.imageUrl);
+      expect(mockAxios).toHaveBeenCalled();
+      expect(mockProcessImage).toHaveBeenCalled();
+      expect(mockUploadGhostImage).toHaveBeenCalled();
+      expect(result.url).toBe('https://ghost.com/content/images/image.jpg');
+    });
+
+    it('should use provided alt text', async () => {
+      const input = { imageUrl: 'https://example.com/image.jpg', alt: 'My custom alt' };
+      const result = await toolImplementations.ghost_upload_image(input);
+
+      expect(result.alt).toBe('My custom alt');
+    });
+
+    it('should generate default alt text from filename', async () => {
+      const input = { imageUrl: 'https://example.com/beautiful-sunset.jpg' };
+      const result = await toolImplementations.ghost_upload_image(input);
+
+      expect(result.alt).toBeTruthy();
+      expect(result.alt).not.toBe('');
+    });
+
+    it('should cleanup temporary files on success', async () => {
+      const input = { imageUrl: 'https://example.com/image.jpg' };
+      await toolImplementations.ghost_upload_image(input);
+
+      expect(mockUnlink).toHaveBeenCalled();
+    });
+
+    it('should cleanup temporary files on error', async () => {
+      mockUploadGhostImage.mockRejectedValue(new Error('Upload failed'));
+
+      const input = { imageUrl: 'https://example.com/image.jpg' };
+      await expect(toolImplementations.ghost_upload_image(input)).rejects.toThrow();
+
+      expect(mockUnlink).toHaveBeenCalled();
+    });
+
+    it('should handle download errors', async () => {
+      mockAxios.mockRejectedValue(new Error('Network error'));
+
+      const input = { imageUrl: 'https://example.com/image.jpg' };
+      await expect(toolImplementations.ghost_upload_image(input)).rejects.toThrow(
+        'Failed to upload image from URL'
+      );
+    });
+
+    it('should handle processing errors', async () => {
+      mockProcessImage.mockRejectedValue(new Error('Invalid image format'));
+
+      const input = { imageUrl: 'https://example.com/image.jpg' };
+      await expect(toolImplementations.ghost_upload_image(input)).rejects.toThrow(
+        'Failed to upload image from URL'
+      );
+    });
+  });
+
+  describe('ghost_get_tags tool', () => {
+    it('should get all tags without filter', async () => {
+      const tags = [
+        { id: '1', name: 'Tag1', slug: 'tag1' },
+        { id: '2', name: 'Tag2', slug: 'tag2' },
+      ];
+      mockGetGhostTags.mockResolvedValue(tags);
+
+      const result = await toolImplementations.ghost_get_tags({});
+
+      expect(mockGetGhostTags).toHaveBeenCalledWith(undefined);
+      expect(result).toEqual(tags);
+    });
+
+    it('should filter tags by name', async () => {
+      const tags = [{ id: '1', name: 'Technology', slug: 'technology' }];
+      mockGetGhostTags.mockResolvedValue(tags);
+
+      const result = await toolImplementations.ghost_get_tags({ name: 'Technology' });
+
+      expect(mockGetGhostTags).toHaveBeenCalledWith('Technology');
+      expect(result).toEqual(tags);
+    });
+
+    it('should return empty array when no tags match', async () => {
+      mockGetGhostTags.mockResolvedValue([]);
+
+      const result = await toolImplementations.ghost_get_tags({ name: 'NonExistent' });
+
+      expect(result).toEqual([]);
+    });
+
+    it('should throw wrapped error when service fails', async () => {
+      mockGetGhostTags.mockRejectedValue(new Error('API error'));
+
+      await expect(toolImplementations.ghost_get_tags({})).rejects.toThrow(
+        'Failed to get Ghost tags: API error'
+      );
+    });
+  });
+
+  describe('ghost_create_tag tool', () => {
+    it('should create tag with name only', async () => {
+      const newTag = { id: '1', name: 'NewTag', slug: 'newtag' };
+      mockCreateGhostTag.mockResolvedValue(newTag);
+
+      const input = { name: 'NewTag' };
+      const result = await toolImplementations.ghost_create_tag(input);
+
+      expect(mockCreateGhostTag).toHaveBeenCalledWith(input);
+      expect(result).toEqual(newTag);
+    });
+
+    it('should create tag with all fields', async () => {
+      const newTag = {
+        id: '1',
+        name: 'Tech',
+        slug: 'technology',
+        description: 'Tech articles',
+      };
+      mockCreateGhostTag.mockResolvedValue(newTag);
+
+      const input = { name: 'Tech', slug: 'technology', description: 'Tech articles' };
+      const result = await toolImplementations.ghost_create_tag(input);
+
+      expect(mockCreateGhostTag).toHaveBeenCalledWith(input);
+      expect(result).toEqual(newTag);
+    });
+
+    it('should throw wrapped error when service fails', async () => {
+      mockCreateGhostTag.mockRejectedValue(new Error('Duplicate tag'));
+
+      await expect(toolImplementations.ghost_create_tag({ name: 'Existing' })).rejects.toThrow(
+        'Failed to create Ghost tag: Duplicate tag'
+      );
+    });
+  });
+
+  describe('startMCPServer', () => {
+    it('should export startMCPServer function', async () => {
+      const { startMCPServer } = await import('../mcp_server.js');
+      expect(typeof startMCPServer).toBe('function');
+    });
+  });
+
+  describe('module exports', () => {
+    it('should export mcpServer', async () => {
+      const module = await import('../mcp_server.js');
+      expect(module.mcpServer).toBeDefined();
+    });
+
+    it('should export startMCPServer', async () => {
+      const module = await import('../mcp_server.js');
+      expect(module.startMCPServer).toBeDefined();
+    });
+  });
+});

package/src/config/__tests__/mcp-config.test.js

@@ -0,0 +1,311 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// Mock dotenv before importing config
+vi.mock('dotenv', () => ({
+  default: { config: vi.fn() },
+}));
+
+describe('mcp-config', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.resetModules();
+    // Reset environment variables to a clean state
+    process.env = {
+      ...originalEnv,
+      GHOST_ADMIN_API_URL: 'https://ghost.example.com',
+      GHOST_ADMIN_API_KEY: 'test-api-key',
+    };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('mcpConfig object', () => {
+    describe('transport configuration', () => {
+      it('should use default transport type "http" when not specified', async () => {
+        delete process.env.MCP_TRANSPORT;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.type).toBe('http');
+      });
+
+      it('should use MCP_TRANSPORT env var when specified', async () => {
+        process.env.MCP_TRANSPORT = 'websocket';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.type).toBe('websocket');
+      });
+
+      it('should use default port 3001 when not specified', async () => {
+        delete process.env.MCP_PORT;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.port).toBe(3001);
+      });
+
+      it('should use MCP_PORT env var when specified', async () => {
+        process.env.MCP_PORT = '4000';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.port).toBe(4000);
+      });
+
+      it('should use default CORS "*" when not specified', async () => {
+        delete process.env.MCP_CORS;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.cors).toBe('*');
+      });
+
+      it('should use MCP_CORS env var when specified', async () => {
+        process.env.MCP_CORS = 'https://example.com';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.cors).toBe('https://example.com');
+      });
+
+      it('should use default SSE endpoint when not specified', async () => {
+        delete process.env.MCP_SSE_ENDPOINT;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.sseEndpoint).toBe('/mcp/sse');
+      });
+
+      it('should use default WebSocket path when not specified', async () => {
+        delete process.env.MCP_WS_PATH;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.wsPath).toBe('/');
+      });
+
+      it('should use default heartbeat interval when not specified', async () => {
+        delete process.env.MCP_WS_HEARTBEAT;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.transport.wsHeartbeatInterval).toBe(30000);
+      });
+    });
+
+    describe('metadata configuration', () => {
+      it('should use default server name when not specified', async () => {
+        delete process.env.MCP_SERVER_NAME;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.metadata.name).toBe('Ghost CMS Manager');
+      });
+
+      it('should use MCP_SERVER_NAME env var when specified', async () => {
+        process.env.MCP_SERVER_NAME = 'My Ghost Server';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.metadata.name).toBe('My Ghost Server');
+      });
+
+      it('should use default description when not specified', async () => {
+        delete process.env.MCP_SERVER_DESC;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.metadata.description).toContain('MCP Server to manage a Ghost CMS');
+      });
+
+      it('should use default version when not specified', async () => {
+        delete process.env.MCP_SERVER_VERSION;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.metadata.version).toBe('1.0.0');
+      });
+    });
+
+    describe('errorHandling configuration', () => {
+      it('should not include stack trace in production', async () => {
+        process.env.NODE_ENV = 'production';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.errorHandling.includeStackTrace).toBe(false);
+      });
+
+      it('should include stack trace in development', async () => {
+        process.env.NODE_ENV = 'development';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.errorHandling.includeStackTrace).toBe(true);
+      });
+
+      it('should use default max retries when not specified', async () => {
+        delete process.env.MCP_MAX_RETRIES;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.errorHandling.maxRetries).toBe(3);
+      });
+
+      it('should use default retry delay when not specified', async () => {
+        delete process.env.MCP_RETRY_DELAY;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.errorHandling.retryDelay).toBe(1000);
+      });
+    });
+
+    describe('logging configuration', () => {
+      it('should use default log level when not specified', async () => {
+        delete process.env.MCP_LOG_LEVEL;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.logging.level).toBe('info');
+      });
+
+      it('should use MCP_LOG_LEVEL env var when specified', async () => {
+        process.env.MCP_LOG_LEVEL = 'debug';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.logging.level).toBe('debug');
+      });
+
+      it('should use default log format when not specified', async () => {
+        delete process.env.MCP_LOG_FORMAT;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.logging.format).toBe('json');
+      });
+    });
+
+    describe('security configuration', () => {
+      it('should include API key when specified', async () => {
+        process.env.MCP_API_KEY = 'secret-key';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.security.apiKey).toBe('secret-key');
+      });
+
+      it('should have undefined API key when not specified', async () => {
+        delete process.env.MCP_API_KEY;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.security.apiKey).toBeUndefined();
+      });
+
+      it('should use default allowed origins when not specified', async () => {
+        delete process.env.MCP_ALLOWED_ORIGINS;
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.security.allowedOrigins).toEqual(['*']);
+      });
+
+      it('should parse comma-separated allowed origins', async () => {
+        process.env.MCP_ALLOWED_ORIGINS = 'https://a.com,https://b.com';
+        const { mcpConfig } = await import('../mcp-config.js');
+        expect(mcpConfig.security.allowedOrigins).toEqual(['https://a.com', 'https://b.com']);
+      });
+    });
+  });
+
+  describe('getTransportConfig', () => {
+    it('should return stdio config for stdio transport', async () => {
+      process.env.MCP_TRANSPORT = 'stdio';
+      const { getTransportConfig } = await import('../mcp-config.js');
+      const config = getTransportConfig();
+      expect(config).toEqual({ type: 'stdio' });
+    });
+
+    it('should return SSE config for http transport', async () => {
+      process.env.MCP_TRANSPORT = 'http';
+      process.env.MCP_PORT = '3001';
+      const { getTransportConfig } = await import('../mcp-config.js');
+      const config = getTransportConfig();
+      expect(config.type).toBe('sse');
+      expect(config.port).toBe(3001);
+      expect(config.cors).toBeDefined();
+      expect(config.endpoint).toBeDefined();
+    });
+
+    it('should return SSE config for sse transport', async () => {
+      process.env.MCP_TRANSPORT = 'sse';
+      const { getTransportConfig } = await import('../mcp-config.js');
+      const config = getTransportConfig();
+      expect(config.type).toBe('sse');
+    });
+
+    it('should return websocket config for websocket transport', async () => {
+      process.env.MCP_TRANSPORT = 'websocket';
+      process.env.MCP_PORT = '3002';
+      process.env.MCP_WS_PATH = '/ws';
+      process.env.MCP_WS_HEARTBEAT = '15000';
+      const { getTransportConfig } = await import('../mcp-config.js');
+      const config = getTransportConfig();
+      expect(config).toEqual({
+        type: 'websocket',
+        port: 3002,
+        path: '/ws',
+        heartbeatInterval: 15000,
+      });
+    });
+
+    it('should throw error for unknown transport type', async () => {
+      process.env.MCP_TRANSPORT = 'invalid-transport';
+      const { getTransportConfig } = await import('../mcp-config.js');
+      expect(() => getTransportConfig()).toThrow('Unknown transport type: invalid-transport');
+    });
+  });
+
+  describe('validateConfig', () => {
+    it('should return true when configuration is valid', async () => {
+      process.env.GHOST_ADMIN_API_URL = 'https://ghost.example.com';
+      process.env.GHOST_ADMIN_API_KEY = 'test-api-key';
+      process.env.MCP_TRANSPORT = 'http';
+      process.env.MCP_PORT = '3001';
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(validateConfig()).toBe(true);
+    });
+
+    it('should throw error when GHOST_ADMIN_API_URL is missing', async () => {
+      delete process.env.GHOST_ADMIN_API_URL;
+      process.env.GHOST_ADMIN_API_KEY = 'test-api-key';
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(() => validateConfig()).toThrow('Missing GHOST_ADMIN_API_URL');
+    });
+
+    it('should throw error when GHOST_ADMIN_API_KEY is missing', async () => {
+      process.env.GHOST_ADMIN_API_URL = 'https://ghost.example.com';
+      delete process.env.GHOST_ADMIN_API_KEY;
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(() => validateConfig()).toThrow('Missing GHOST_ADMIN_API_KEY');
+    });
+
+    it('should throw error for invalid transport type', async () => {
+      process.env.MCP_TRANSPORT = 'invalid';
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(() => validateConfig()).toThrow('Invalid transport type');
+    });
+
+    it('should throw error for invalid port (0)', async () => {
+      process.env.MCP_TRANSPORT = 'http';
+      process.env.MCP_PORT = '0';
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(() => validateConfig()).toThrow('Invalid port');
+    });
+
+    it('should throw error for invalid port (negative)', async () => {
+      process.env.MCP_TRANSPORT = 'http';
+      process.env.MCP_PORT = '-1';
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(() => validateConfig()).toThrow('Invalid port');
+    });
+
+    it('should throw error for invalid port (> 65535)', async () => {
+      process.env.MCP_TRANSPORT = 'http';
+      process.env.MCP_PORT = '70000';
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(() => validateConfig()).toThrow('Invalid port');
+    });
+
+    it('should not validate port for stdio transport', async () => {
+      process.env.MCP_TRANSPORT = 'stdio';
+      process.env.MCP_PORT = '0'; // Invalid port, but not checked for stdio
+      const { validateConfig } = await import('../mcp-config.js');
+      expect(validateConfig()).toBe(true);
+    });
+
+    it('should accumulate multiple errors', async () => {
+      delete process.env.GHOST_ADMIN_API_URL;
+      delete process.env.GHOST_ADMIN_API_KEY;
+      process.env.MCP_TRANSPORT = 'invalid';
+      const { validateConfig } = await import('../mcp-config.js');
+      try {
+        validateConfig();
+        expect.fail('Should have thrown');
+      } catch (error) {
+        expect(error.message).toContain('Invalid transport type');
+        expect(error.message).toContain('GHOST_ADMIN_API_URL');
+        expect(error.message).toContain('GHOST_ADMIN_API_KEY');
+      }
+    });
+  });
+
+  describe('default export', () => {
+    it('should export mcpConfig as default', async () => {
+      const module = await import('../mcp-config.js');
+      expect(module.default).toBeDefined();
+      expect(module.default).toHaveProperty('transport');
+      expect(module.default).toHaveProperty('metadata');
+    });
+  });
+});