@jgardner04/ghost-mcp-server 1.1.13 → 1.3.0

package/package.json

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

package/src/__tests__/mcp_server_improved.test.js

@@ -0,0 +1,756 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the McpServer to capture tool registrations
+const mockTools = new Map();
+
+vi.mock('@modelcontextprotocol/sdk/server/mcp.js', () => {
+  return {
+    McpServer: class MockMcpServer {
+      constructor(config) {
+        this.config = config;
+      }
+
+      tool(name, description, schema, handler) {
+        mockTools.set(name, { name, description, schema, handler });
+      }
+
+      connect(_transport) {
+        return Promise.resolve();
+      }
+    },
+  };
+});
+
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => {
+  return {
+    StdioServerTransport: class MockStdioServerTransport {},
+  };
+});
+
+// Mock dotenv
+vi.mock('dotenv', () => ({
+  default: { config: vi.fn() },
+}));
+
+// Mock crypto
+vi.mock('crypto', () => ({
+  default: { randomUUID: vi.fn().mockReturnValue('test-uuid-1234') },
+}));
+
+// Mock services - will be lazy loaded
+const mockGetPosts = vi.fn();
+const mockGetPost = vi.fn();
+const mockGetTags = vi.fn();
+const mockCreateTag = vi.fn();
+const mockUploadImage = vi.fn();
+const mockCreatePostService = vi.fn();
+const mockProcessImage = vi.fn();
+const mockValidateImageUrl = vi.fn();
+const mockCreateSecureAxiosConfig = vi.fn();
+const mockUpdatePost = vi.fn();
+const mockDeletePost = vi.fn();
+
+vi.mock('../services/ghostService.js', () => ({
+  getPosts: (...args) => mockGetPosts(...args),
+  getPost: (...args) => mockGetPost(...args),
+  getTags: (...args) => mockGetTags(...args),
+  createTag: (...args) => mockCreateTag(...args),
+  uploadImage: (...args) => mockUploadImage(...args),
+}));
+
+vi.mock('../services/postService.js', () => ({
+  createPostService: (...args) => mockCreatePostService(...args),
+}));
+
+vi.mock('../services/ghostServiceImproved.js', () => ({
+  updatePost: (...args) => mockUpdatePost(...args),
+  deletePost: (...args) => mockDeletePost(...args),
+}));
+
+vi.mock('../services/imageProcessingService.js', () => ({
+  processImage: (...args) => mockProcessImage(...args),
+}));
+
+vi.mock('../utils/urlValidator.js', () => ({
+  validateImageUrl: (...args) => mockValidateImageUrl(...args),
+  createSecureAxiosConfig: (...args) => mockCreateSecureAxiosConfig(...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 path
+vi.mock('path', async () => {
+  const actual = await vi.importActual('path');
+  return {
+    default: actual,
+    ...actual,
+  };
+});
+
+describe('mcp_server_improved - ghost_get_posts tool', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Don't clear mockTools - they're registered once on module load
+    // Import the module to register tools (only first time)
+    if (mockTools.size === 0) {
+      await import('../mcp_server_improved.js');
+    }
+  });
+
+  it('should register ghost_get_posts tool', () => {
+    expect(mockTools.has('ghost_get_posts')).toBe(true);
+  });
+
+  it('should have correct schema with all optional parameters', () => {
+    const tool = mockTools.get('ghost_get_posts');
+    expect(tool).toBeDefined();
+    expect(tool.description).toContain('posts');
+    expect(tool.schema).toBeDefined();
+    expect(tool.schema.limit).toBeDefined();
+    expect(tool.schema.page).toBeDefined();
+    expect(tool.schema.status).toBeDefined();
+    expect(tool.schema.include).toBeDefined();
+    expect(tool.schema.filter).toBeDefined();
+    expect(tool.schema.order).toBeDefined();
+  });
+
+  it('should retrieve posts with default options', async () => {
+    const mockPosts = [
+      { id: '1', title: 'Post 1', slug: 'post-1', status: 'published' },
+      { id: '2', title: 'Post 2', slug: 'post-2', status: 'draft' },
+    ];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    const result = await tool.handler({});
+
+    expect(mockGetPosts).toHaveBeenCalledWith({});
+    expect(result.content[0].text).toContain('Post 1');
+    expect(result.content[0].text).toContain('Post 2');
+  });
+
+  it('should pass limit and page parameters', async () => {
+    const mockPosts = [{ id: '1', title: 'Post 1', slug: 'post-1' }];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    await tool.handler({ limit: 10, page: 2 });
+
+    expect(mockGetPosts).toHaveBeenCalledWith({ limit: 10, page: 2 });
+  });
+
+  it('should validate limit is between 1 and 100', () => {
+    const tool = mockTools.get('ghost_get_posts');
+    const schema = tool.schema;
+
+    // Test that limit schema exists and has proper validation
+    expect(schema.limit).toBeDefined();
+    expect(() => schema.limit.parse(0)).toThrow();
+    expect(() => schema.limit.parse(101)).toThrow();
+    expect(schema.limit.parse(50)).toBe(50);
+  });
+
+  it('should validate page is at least 1', () => {
+    const tool = mockTools.get('ghost_get_posts');
+    const schema = tool.schema;
+
+    expect(schema.page).toBeDefined();
+    expect(() => schema.page.parse(0)).toThrow();
+    expect(schema.page.parse(1)).toBe(1);
+  });
+
+  it('should pass status filter', async () => {
+    const mockPosts = [{ id: '1', title: 'Published Post', status: 'published' }];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    await tool.handler({ status: 'published' });
+
+    expect(mockGetPosts).toHaveBeenCalledWith({ status: 'published' });
+  });
+
+  it('should validate status enum values', () => {
+    const tool = mockTools.get('ghost_get_posts');
+    const schema = tool.schema;
+
+    expect(schema.status).toBeDefined();
+    expect(() => schema.status.parse('invalid')).toThrow();
+    expect(schema.status.parse('published')).toBe('published');
+    expect(schema.status.parse('draft')).toBe('draft');
+    expect(schema.status.parse('scheduled')).toBe('scheduled');
+    expect(schema.status.parse('all')).toBe('all');
+  });
+
+  it('should pass include parameter', async () => {
+    const mockPosts = [
+      {
+        id: '1',
+        title: 'Post with tags',
+        tags: [{ name: 'tech' }],
+        authors: [{ name: 'John' }],
+      },
+    ];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    await tool.handler({ include: 'tags,authors' });
+
+    expect(mockGetPosts).toHaveBeenCalledWith({ include: 'tags,authors' });
+  });
+
+  it('should pass filter parameter (NQL)', async () => {
+    const mockPosts = [{ id: '1', title: 'Featured Post', featured: true }];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    await tool.handler({ filter: 'featured:true' });
+
+    expect(mockGetPosts).toHaveBeenCalledWith({ filter: 'featured:true' });
+  });
+
+  it('should pass order parameter', async () => {
+    const mockPosts = [
+      { id: '1', title: 'Newest', published_at: '2025-12-10' },
+      { id: '2', title: 'Older', published_at: '2025-12-01' },
+    ];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    await tool.handler({ order: 'published_at DESC' });
+
+    expect(mockGetPosts).toHaveBeenCalledWith({ order: 'published_at DESC' });
+  });
+
+  it('should pass all parameters combined', async () => {
+    const mockPosts = [{ id: '1', title: 'Test Post' }];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    await tool.handler({
+      limit: 20,
+      page: 1,
+      status: 'published',
+      include: 'tags,authors',
+      filter: 'featured:true',
+      order: 'published_at DESC',
+    });
+
+    expect(mockGetPosts).toHaveBeenCalledWith({
+      limit: 20,
+      page: 1,
+      status: 'published',
+      include: 'tags,authors',
+      filter: 'featured:true',
+      order: 'published_at DESC',
+    });
+  });
+
+  it('should handle errors from ghostService', async () => {
+    mockGetPosts.mockRejectedValue(new Error('Ghost API error'));
+
+    const tool = mockTools.get('ghost_get_posts');
+    const result = await tool.handler({});
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Ghost API error');
+  });
+
+  it('should return formatted JSON response', async () => {
+    const mockPosts = [
+      {
+        id: '1',
+        title: 'Test Post',
+        slug: 'test-post',
+        html: '<p>Content</p>',
+        status: 'published',
+      },
+    ];
+    mockGetPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_get_posts');
+    const result = await tool.handler({});
+
+    expect(result.content).toBeDefined();
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('"id": "1"');
+    expect(result.content[0].text).toContain('"title": "Test Post"');
+  });
+});
+
+describe('mcp_server_improved - ghost_get_post tool', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Don't clear mockTools - they're registered once on module load
+    if (mockTools.size === 0) {
+      await import('../mcp_server_improved.js');
+    }
+  });
+
+  it('should register ghost_get_post tool', () => {
+    expect(mockTools.has('ghost_get_post')).toBe(true);
+  });
+
+  it('should have correct schema requiring one of id or slug', () => {
+    const tool = mockTools.get('ghost_get_post');
+    expect(tool).toBeDefined();
+    expect(tool.description).toContain('post');
+    expect(tool.schema).toBeDefined();
+    expect(tool.schema.id).toBeDefined();
+    expect(tool.schema.slug).toBeDefined();
+    expect(tool.schema.include).toBeDefined();
+  });
+
+  it('should retrieve post by ID', async () => {
+    const mockPost = {
+      id: '123',
+      title: 'Test Post',
+      slug: 'test-post',
+      html: '<p>Content</p>',
+      status: 'published',
+    };
+    mockGetPost.mockResolvedValue(mockPost);
+
+    const tool = mockTools.get('ghost_get_post');
+    const result = await tool.handler({ id: '123' });
+
+    expect(mockGetPost).toHaveBeenCalledWith('123', {});
+    expect(result.content[0].text).toContain('"id": "123"');
+    expect(result.content[0].text).toContain('"title": "Test Post"');
+  });
+
+  it('should retrieve post by slug', async () => {
+    const mockPost = {
+      id: '123',
+      title: 'Test Post',
+      slug: 'test-post',
+      html: '<p>Content</p>',
+      status: 'published',
+    };
+    mockGetPost.mockResolvedValue(mockPost);
+
+    const tool = mockTools.get('ghost_get_post');
+    const result = await tool.handler({ slug: 'test-post' });
+
+    expect(mockGetPost).toHaveBeenCalledWith('slug/test-post', {});
+    expect(result.content[0].text).toContain('"title": "Test Post"');
+  });
+
+  it('should pass include parameter with ID', async () => {
+    const mockPost = {
+      id: '123',
+      title: 'Post with relations',
+      tags: [{ name: 'tech' }],
+      authors: [{ name: 'John' }],
+    };
+    mockGetPost.mockResolvedValue(mockPost);
+
+    const tool = mockTools.get('ghost_get_post');
+    await tool.handler({ id: '123', include: 'tags,authors' });
+
+    expect(mockGetPost).toHaveBeenCalledWith('123', { include: 'tags,authors' });
+  });
+
+  it('should pass include parameter with slug', async () => {
+    const mockPost = {
+      id: '123',
+      title: 'Post with relations',
+      slug: 'test-post',
+      tags: [{ name: 'tech' }],
+    };
+    mockGetPost.mockResolvedValue(mockPost);
+
+    const tool = mockTools.get('ghost_get_post');
+    await tool.handler({ slug: 'test-post', include: 'tags' });
+
+    expect(mockGetPost).toHaveBeenCalledWith('slug/test-post', { include: 'tags' });
+  });
+
+  it('should prefer ID over slug when both provided', async () => {
+    const mockPost = { id: '123', title: 'Test Post', slug: 'test-post' };
+    mockGetPost.mockResolvedValue(mockPost);
+
+    const tool = mockTools.get('ghost_get_post');
+    await tool.handler({ id: '123', slug: 'wrong-slug' });
+
+    expect(mockGetPost).toHaveBeenCalledWith('123', {});
+  });
+
+  it('should handle not found errors', async () => {
+    mockGetPost.mockRejectedValue(new Error('Post not found'));
+
+    const tool = mockTools.get('ghost_get_post');
+    const result = await tool.handler({ id: 'nonexistent' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Post not found');
+  });
+
+  it('should handle errors from ghostService', async () => {
+    mockGetPost.mockRejectedValue(new Error('Ghost API error'));
+
+    const tool = mockTools.get('ghost_get_post');
+    const result = await tool.handler({ slug: 'test' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Ghost API error');
+  });
+
+  it('should return formatted JSON response', async () => {
+    const mockPost = {
+      id: '1',
+      uuid: 'uuid-123',
+      title: 'Test Post',
+      slug: 'test-post',
+      html: '<p>Content</p>',
+      status: 'published',
+      created_at: '2025-12-10T00:00:00.000Z',
+      updated_at: '2025-12-10T00:00:00.000Z',
+    };
+    mockGetPost.mockResolvedValue(mockPost);
+
+    const tool = mockTools.get('ghost_get_post');
+    const result = await tool.handler({ id: '1' });
+
+    expect(result.content).toBeDefined();
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('"id": "1"');
+    expect(result.content[0].text).toContain('"title": "Test Post"');
+    expect(result.content[0].text).toContain('"status": "published"');
+  });
+
+  it('should handle validation error when neither id nor slug provided', async () => {
+    const tool = mockTools.get('ghost_get_post');
+    const result = await tool.handler({});
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Either id or slug is required');
+  });
+});
+
+describe('mcp_server_improved - ghost_update_post tool', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Don't clear mockTools - they're registered once on module load
+    if (mockTools.size === 0) {
+      await import('../mcp_server_improved.js');
+    }
+  });
+
+  it('should register ghost_update_post tool', () => {
+    expect(mockTools.has('ghost_update_post')).toBe(true);
+  });
+
+  it('should have correct schema with required id field', () => {
+    const tool = mockTools.get('ghost_update_post');
+    expect(tool).toBeDefined();
+    expect(tool.description).toContain('Updates an existing post');
+    expect(tool.schema).toBeDefined();
+    expect(tool.schema.id).toBeDefined();
+    expect(tool.schema.title).toBeDefined();
+    expect(tool.schema.html).toBeDefined();
+    expect(tool.schema.status).toBeDefined();
+    expect(tool.schema.tags).toBeDefined();
+    expect(tool.schema.feature_image).toBeDefined();
+    expect(tool.schema.feature_image_alt).toBeDefined();
+    expect(tool.schema.feature_image_caption).toBeDefined();
+    expect(tool.schema.meta_title).toBeDefined();
+    expect(tool.schema.meta_description).toBeDefined();
+    expect(tool.schema.published_at).toBeDefined();
+    expect(tool.schema.custom_excerpt).toBeDefined();
+  });
+
+  it('should update post title', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      title: 'Updated Title',
+      slug: 'test-post',
+      html: '<p>Content</p>',
+      status: 'published',
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: '123', title: 'Updated Title' });
+
+    expect(mockUpdatePost).toHaveBeenCalledWith('123', { title: 'Updated Title' });
+    expect(result.content[0].text).toContain('"title": "Updated Title"');
+  });
+
+  it('should update post content', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      title: 'Test Post',
+      html: '<p>Updated content</p>',
+      status: 'published',
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: '123', html: '<p>Updated content</p>' });
+
+    expect(mockUpdatePost).toHaveBeenCalledWith('123', { html: '<p>Updated content</p>' });
+    expect(result.content[0].text).toContain('Updated content');
+  });
+
+  it('should update post status', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      title: 'Test Post',
+      html: '<p>Content</p>',
+      status: 'published',
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: '123', status: 'published' });
+
+    expect(mockUpdatePost).toHaveBeenCalledWith('123', { status: 'published' });
+    expect(result.content[0].text).toContain('"status": "published"');
+  });
+
+  it('should update post tags', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      title: 'Test Post',
+      html: '<p>Content</p>',
+      tags: [{ name: 'tech' }, { name: 'javascript' }],
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: '123', tags: ['tech', 'javascript'] });
+
+    expect(mockUpdatePost).toHaveBeenCalledWith('123', { tags: ['tech', 'javascript'] });
+    expect(result.content[0].text).toContain('tech');
+    expect(result.content[0].text).toContain('javascript');
+  });
+
+  it('should update post featured image', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      title: 'Test Post',
+      feature_image: 'https://example.com/new-image.jpg',
+      feature_image_alt: 'New image',
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({
+      id: '123',
+      feature_image: 'https://example.com/new-image.jpg',
+      feature_image_alt: 'New image',
+    });
+
+    expect(mockUpdatePost).toHaveBeenCalledWith('123', {
+      feature_image: 'https://example.com/new-image.jpg',
+      feature_image_alt: 'New image',
+    });
+    expect(result.content[0].text).toContain('new-image.jpg');
+  });
+
+  it('should update SEO meta fields', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      title: 'Test Post',
+      meta_title: 'SEO Title',
+      meta_description: 'SEO Description',
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({
+      id: '123',
+      meta_title: 'SEO Title',
+      meta_description: 'SEO Description',
+    });
+
+    expect(mockUpdatePost).toHaveBeenCalledWith('123', {
+      meta_title: 'SEO Title',
+      meta_description: 'SEO Description',
+    });
+    expect(result.content[0].text).toContain('SEO Title');
+    expect(result.content[0].text).toContain('SEO Description');
+  });
+
+  it('should update multiple fields at once', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      title: 'Updated Title',
+      html: '<p>Updated content</p>',
+      status: 'published',
+      tags: [{ name: 'tech' }],
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({
+      id: '123',
+      title: 'Updated Title',
+      html: '<p>Updated content</p>',
+      status: 'published',
+      tags: ['tech'],
+    });
+
+    expect(mockUpdatePost).toHaveBeenCalledWith('123', {
+      title: 'Updated Title',
+      html: '<p>Updated content</p>',
+      status: 'published',
+      tags: ['tech'],
+    });
+    expect(result.content[0].text).toContain('Updated Title');
+  });
+
+  it('should handle not found errors', async () => {
+    mockUpdatePost.mockRejectedValue(new Error('Post not found'));
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: 'nonexistent', title: 'New Title' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Post not found');
+  });
+
+  it('should handle validation errors', async () => {
+    mockUpdatePost.mockRejectedValue(new Error('Validation failed: Title is required'));
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: '123', title: '' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Validation failed');
+  });
+
+  it('should handle Ghost API errors', async () => {
+    mockUpdatePost.mockRejectedValue(new Error('Ghost API error: Server timeout'));
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: '123', title: 'Updated' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Ghost API error');
+  });
+
+  it('should return formatted JSON response', async () => {
+    const mockUpdatedPost = {
+      id: '123',
+      uuid: 'uuid-123',
+      title: 'Updated Post',
+      slug: 'updated-post',
+      html: '<p>Updated content</p>',
+      status: 'published',
+      created_at: '2025-12-09T00:00:00.000Z',
+      updated_at: '2025-12-10T12:00:00.000Z',
+    };
+    mockUpdatePost.mockResolvedValue(mockUpdatedPost);
+
+    const tool = mockTools.get('ghost_update_post');
+    const result = await tool.handler({ id: '123', title: 'Updated Post' });
+
+    expect(result.content).toBeDefined();
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('"id": "123"');
+    expect(result.content[0].text).toContain('"title": "Updated Post"');
+    expect(result.content[0].text).toContain('"status": "published"');
+  });
+});
+
+describe('mcp_server_improved - ghost_delete_post tool', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Don't clear mockTools - they're registered once on module load
+    if (mockTools.size === 0) {
+      await import('../mcp_server_improved.js');
+    }
+  });
+
+  it('should register ghost_delete_post tool', () => {
+    expect(mockTools.has('ghost_delete_post')).toBe(true);
+  });
+
+  it('should have correct schema with required id field', () => {
+    const tool = mockTools.get('ghost_delete_post');
+    expect(tool).toBeDefined();
+    expect(tool.description).toContain('Deletes a post');
+    expect(tool.description).toContain('permanent');
+    expect(tool.schema).toBeDefined();
+    expect(tool.schema.id).toBeDefined();
+  });
+
+  it('should delete post by ID', async () => {
+    mockDeletePost.mockResolvedValue({ deleted: true });
+
+    const tool = mockTools.get('ghost_delete_post');
+    const result = await tool.handler({ id: '123' });
+
+    expect(mockDeletePost).toHaveBeenCalledWith('123');
+    expect(result.content[0].text).toContain('Post 123 has been successfully deleted');
+    expect(result.isError).toBeUndefined();
+  });
+
+  it('should handle not found errors', async () => {
+    mockDeletePost.mockRejectedValue(new Error('Post not found'));
+
+    const tool = mockTools.get('ghost_delete_post');
+    const result = await tool.handler({ id: 'nonexistent' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Post not found');
+  });
+
+  it('should handle Ghost API errors', async () => {
+    mockDeletePost.mockRejectedValue(new Error('Ghost API error: Permission denied'));
+
+    const tool = mockTools.get('ghost_delete_post');
+    const result = await tool.handler({ id: '123' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Ghost API error');
+  });
+
+  it('should return success message on successful deletion', async () => {
+    mockDeletePost.mockResolvedValue({ deleted: true });
+
+    const tool = mockTools.get('ghost_delete_post');
+    const result = await tool.handler({ id: 'test-post-id' });
+
+    expect(result.content).toBeDefined();
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toBe('Post test-post-id has been successfully deleted.');
+  });
+
+  it('should handle network errors', async () => {
+    mockDeletePost.mockRejectedValue(new Error('Network error: Connection refused'));
+
+    const tool = mockTools.get('ghost_delete_post');
+    const result = await tool.handler({ id: '123' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Network error');
+  });
+});

package/src/mcp_server_improved.js

@@ -272,6 +272,198 @@ server.tool(
   }
 );
 
+// Get Posts Tool
+server.tool(
+  'ghost_get_posts',
+  'Retrieves a list of posts from Ghost CMS with pagination, filtering, and sorting options.',
+  {
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe('Number of posts to retrieve (1-100). Default is 15.'),
+    page: z.number().min(1).optional().describe('Page number for pagination. Default is 1.'),
+    status: z
+      .enum(['published', 'draft', 'scheduled', 'all'])
+      .optional()
+      .describe('Filter posts by status. Options: published, draft, scheduled, all.'),
+    include: z
+      .string()
+      .optional()
+      .describe('Comma-separated list of relations to include (e.g., "tags,authors").'),
+    filter: z
+      .string()
+      .optional()
+      .describe('Ghost NQL filter string for advanced filtering (e.g., "featured:true").'),
+    order: z
+      .string()
+      .optional()
+      .describe('Sort order for results (e.g., "published_at DESC", "title ASC").'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_get_posts`);
+    try {
+      await loadServices();
+
+      // Build options object with provided parameters
+      const options = {};
+      if (input.limit !== undefined) options.limit = input.limit;
+      if (input.page !== undefined) options.page = input.page;
+      if (input.status !== undefined) options.status = input.status;
+      if (input.include !== undefined) options.include = input.include;
+      if (input.filter !== undefined) options.filter = input.filter;
+      if (input.order !== undefined) options.order = input.order;
+
+      const posts = await ghostService.getPosts(options);
+      console.error(`Retrieved ${posts.length} posts from Ghost.`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(posts, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_posts:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving posts: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Get Post Tool
+server.tool(
+  'ghost_get_post',
+  'Retrieves a single post from Ghost CMS by ID or slug.',
+  {
+    id: z.string().optional().describe('The ID of the post to retrieve.'),
+    slug: z.string().optional().describe('The slug of the post to retrieve.'),
+    include: z
+      .string()
+      .optional()
+      .describe('Comma-separated list of relations to include (e.g., "tags,authors").'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_get_post`);
+    try {
+      // Validate that at least one of id or slug is provided
+      if (!input.id && !input.slug) {
+        throw new Error('Either id or slug is required to retrieve a post');
+      }
+
+      await loadServices();
+
+      // Build options object
+      const options = {};
+      if (input.include !== undefined) options.include = input.include;
+
+      // Determine identifier (prefer ID over slug)
+      const identifier = input.id || `slug/${input.slug}`;
+
+      const post = await ghostService.getPost(identifier, options);
+      console.error(`Retrieved post: ${post.title} (ID: ${post.id})`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(post, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_post:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving post: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Update Post Tool
+server.tool(
+  'ghost_update_post',
+  'Updates an existing post in Ghost CMS. Can update title, content, status, tags, images, and SEO fields.',
+  {
+    id: z.string().describe('The ID of the post to update.'),
+    title: z.string().optional().describe('New title for the post.'),
+    html: z.string().optional().describe('New HTML content for the post.'),
+    status: z
+      .enum(['draft', 'published', 'scheduled'])
+      .optional()
+      .describe('New status for the post.'),
+    tags: z
+      .array(z.string())
+      .optional()
+      .describe('New list of tag names to associate with the post.'),
+    feature_image: z.string().optional().describe('New featured image URL.'),
+    feature_image_alt: z.string().optional().describe('New alt text for the featured image.'),
+    feature_image_caption: z.string().optional().describe('New caption for the featured image.'),
+    meta_title: z.string().optional().describe('New custom title for SEO (max 300 chars).'),
+    meta_description: z
+      .string()
+      .optional()
+      .describe('New custom description for SEO (max 500 chars).'),
+    published_at: z
+      .string()
+      .optional()
+      .describe(
+        "New publication date/time in ISO 8601 format. Required if changing status to 'scheduled'."
+      ),
+    custom_excerpt: z.string().optional().describe('New custom short summary for the post.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_update_post for post ID: ${input.id}`);
+    try {
+      await loadServices();
+
+      // Extract ID from input and build update data
+      const { id, ...updateData } = input;
+
+      // Update the post using ghostServiceImproved
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const updatedPost = await ghostServiceImproved.updatePost(id, updateData);
+      console.error(`Post updated successfully. Post ID: ${updatedPost.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(updatedPost, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_update_post:`, error);
+      return {
+        content: [{ type: 'text', text: `Error updating post: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Delete Post Tool
+server.tool(
+  'ghost_delete_post',
+  'Deletes a post from Ghost CMS by ID. This operation is permanent and cannot be undone.',
+  {
+    id: z.string().describe('The ID of the post to delete.'),
+  },
+  async ({ id }) => {
+    console.error(`Executing tool: ghost_delete_post for post ID: ${id}`);
+    try {
+      await loadServices();
+
+      // Delete the post using ghostServiceImproved
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      await ghostServiceImproved.deletePost(id);
+      console.error(`Post deleted successfully. Post ID: ${id}`);
+
+      return {
+        content: [{ type: 'text', text: `Post ${id} has been successfully deleted.` }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_delete_post:`, error);
+      return {
+        content: [{ type: 'text', text: `Error deleting post: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // --- Main Entry Point ---
 
 async function main() {
@@ -282,7 +474,7 @@ async function main() {
 
   console.error('Ghost MCP Server running on stdio transport');
   console.error(
-    'Available tools: ghost_get_tags, ghost_create_tag, ghost_upload_image, ghost_create_post'
+    'Available tools: ghost_get_tags, ghost_create_tag, ghost_upload_image, ghost_create_post, ghost_get_posts, ghost_get_post, ghost_update_post, ghost_delete_post'
   );
 }