@jgardner04/ghost-mcp-server 1.10.0 → 1.12.0

package/src/__tests__/mcp_server_improved.test.js

@@ -91,15 +91,21 @@ vi.mock('axios', () => ({
 }));
 
 // 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 tempFileManager
+const mockTrackTempFile = vi.fn();
+const mockCleanupTempFiles = vi.fn().mockResolvedValue(undefined);
+vi.mock('../utils/tempFileManager.js', () => ({
+  trackTempFile: (...args) => mockTrackTempFile(...args),
+  cleanupTempFiles: (...args) => mockCleanupTempFiles(...args),
+}));
+
 // Mock os
 vi.mock('os', () => ({
   default: { tmpdir: vi.fn().mockReturnValue('/tmp') },
@@ -133,12 +139,13 @@ describe('mcp_server_improved - ghost_get_posts tool', () => {
     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();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.limit).toBeDefined();
+    expect(tool.schema.shape.page).toBeDefined();
+    expect(tool.schema.shape.status).toBeDefined();
+    expect(tool.schema.shape.include).toBeDefined();
+    expect(tool.schema.shape.filter).toBeDefined();
+    expect(tool.schema.shape.order).toBeDefined();
   });
 
   it('should retrieve posts with default options', async () => {
@@ -168,22 +175,24 @@ describe('mcp_server_improved - ghost_get_posts tool', () => {
 
   it('should validate limit is between 1 and 100', () => {
     const tool = mockTools.get('ghost_get_posts');
-    const schema = tool.schema;
+    // Zod schemas store field definitions in schema.shape
+    const shape = tool.schema.shape;
 
     // 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);
+    expect(shape.limit).toBeDefined();
+    expect(() => shape.limit.parse(0)).toThrow();
+    expect(() => shape.limit.parse(101)).toThrow();
+    expect(shape.limit.parse(50)).toBe(50);
   });
 
   it('should validate page is at least 1', () => {
     const tool = mockTools.get('ghost_get_posts');
-    const schema = tool.schema;
+    // Zod schemas store field definitions in schema.shape
+    const shape = tool.schema.shape;
 
-    expect(schema.page).toBeDefined();
-    expect(() => schema.page.parse(0)).toThrow();
-    expect(schema.page.parse(1)).toBe(1);
+    expect(shape.page).toBeDefined();
+    expect(() => shape.page.parse(0)).toThrow();
+    expect(shape.page.parse(1)).toBe(1);
   });
 
   it('should pass status filter', async () => {
@@ -198,14 +207,15 @@ describe('mcp_server_improved - ghost_get_posts tool', () => {
 
   it('should validate status enum values', () => {
     const tool = mockTools.get('ghost_get_posts');
-    const schema = tool.schema;
+    // Zod schemas store field definitions in schema.shape
+    const shape = tool.schema.shape;
 
-    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');
+    expect(shape.status).toBeDefined();
+    expect(() => shape.status.parse('invalid')).toThrow();
+    expect(shape.status.parse('published')).toBe('published');
+    expect(shape.status.parse('draft')).toBe('draft');
+    expect(shape.status.parse('scheduled')).toBe('scheduled');
+    expect(shape.status.parse('all')).toBe('all');
   });
 
   it('should pass include parameter', async () => {
@@ -322,14 +332,15 @@ describe('mcp_server_improved - ghost_get_post tool', () => {
     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();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.id).toBeDefined();
+    expect(tool.schema.shape.slug).toBeDefined();
+    expect(tool.schema.shape.include).toBeDefined();
   });
 
   it('should retrieve post by ID', async () => {
     const mockPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Test Post',
       slug: 'test-post',
       html: '<p>Content</p>',
@@ -338,16 +349,16 @@ describe('mcp_server_improved - ghost_get_post tool', () => {
     mockGetPost.mockResolvedValue(mockPost);
 
     const tool = mockTools.get('ghost_get_post');
-    const result = await tool.handler({ id: '123' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
-    expect(mockGetPost).toHaveBeenCalledWith('123', {});
-    expect(result.content[0].text).toContain('"id": "123"');
+    expect(mockGetPost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {});
+    expect(result.content[0].text).toContain('"id": "507f1f77bcf86cd799439011"');
     expect(result.content[0].text).toContain('"title": "Test Post"');
   });
 
   it('should retrieve post by slug', async () => {
     const mockPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Test Post',
       slug: 'test-post',
       html: '<p>Content</p>',
@@ -364,7 +375,7 @@ describe('mcp_server_improved - ghost_get_post tool', () => {
 
   it('should pass include parameter with ID', async () => {
     const mockPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Post with relations',
       tags: [{ name: 'tech' }],
       authors: [{ name: 'John' }],
@@ -372,14 +383,16 @@ describe('mcp_server_improved - ghost_get_post tool', () => {
     mockGetPost.mockResolvedValue(mockPost);
 
     const tool = mockTools.get('ghost_get_post');
-    await tool.handler({ id: '123', include: 'tags,authors' });
+    await tool.handler({ id: '507f1f77bcf86cd799439011', include: 'tags,authors' });
 
-    expect(mockGetPost).toHaveBeenCalledWith('123', { include: 'tags,authors' });
+    expect(mockGetPost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
+      include: 'tags,authors',
+    });
   });
 
   it('should pass include parameter with slug', async () => {
     const mockPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Post with relations',
       slug: 'test-post',
       tags: [{ name: 'tech' }],
@@ -393,20 +406,20 @@ describe('mcp_server_improved - ghost_get_post tool', () => {
   });
 
   it('should prefer ID over slug when both provided', async () => {
-    const mockPost = { id: '123', title: 'Test Post', slug: 'test-post' };
+    const mockPost = { id: '507f1f77bcf86cd799439011', title: 'Test Post', slug: 'test-post' };
     mockGetPost.mockResolvedValue(mockPost);
 
     const tool = mockTools.get('ghost_get_post');
-    await tool.handler({ id: '123', slug: 'wrong-slug' });
+    await tool.handler({ id: '507f1f77bcf86cd799439011', slug: 'wrong-slug' });
 
-    expect(mockGetPost).toHaveBeenCalledWith('123', {});
+    expect(mockGetPost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {});
   });
 
   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' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439099' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Post not found');
@@ -424,7 +437,7 @@ describe('mcp_server_improved - ghost_get_post tool', () => {
 
   it('should return formatted JSON response', async () => {
     const mockPost = {
-      id: '1',
+      id: '507f1f77bcf86cd799439011',
       uuid: 'uuid-123',
       title: 'Test Post',
       slug: 'test-post',
@@ -436,11 +449,11 @@ describe('mcp_server_improved - ghost_get_post tool', () => {
     mockGetPost.mockResolvedValue(mockPost);
 
     const tool = mockTools.get('ghost_get_post');
-    const result = await tool.handler({ id: '1' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
     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('"id": "507f1f77bcf86cd799439011"');
     expect(result.content[0].text).toContain('"title": "Test Post"');
     expect(result.content[0].text).toContain('"status": "published"');
   });
@@ -472,23 +485,24 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     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();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.id).toBeDefined();
+    expect(tool.schema.shape.title).toBeDefined();
+    expect(tool.schema.shape.html).toBeDefined();
+    expect(tool.schema.shape.status).toBeDefined();
+    expect(tool.schema.shape.tags).toBeDefined();
+    expect(tool.schema.shape.feature_image).toBeDefined();
+    expect(tool.schema.shape.feature_image_alt).toBeDefined();
+    expect(tool.schema.shape.feature_image_caption).toBeDefined();
+    expect(tool.schema.shape.meta_title).toBeDefined();
+    expect(tool.schema.shape.meta_description).toBeDefined();
+    expect(tool.schema.shape.published_at).toBeDefined();
+    expect(tool.schema.shape.custom_excerpt).toBeDefined();
   });
 
   it('should update post title', async () => {
     const mockUpdatedPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Updated Title',
       slug: 'test-post',
       html: '<p>Content</p>',
@@ -498,15 +512,17 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     mockUpdatePost.mockResolvedValue(mockUpdatedPost);
 
     const tool = mockTools.get('ghost_update_post');
-    const result = await tool.handler({ id: '123', title: 'Updated Title' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', title: 'Updated Title' });
 
-    expect(mockUpdatePost).toHaveBeenCalledWith('123', { title: 'Updated Title' });
+    expect(mockUpdatePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
+      title: 'Updated Title',
+    });
     expect(result.content[0].text).toContain('"title": "Updated Title"');
   });
 
   it('should update post content', async () => {
     const mockUpdatedPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Test Post',
       html: '<p>Updated content</p>',
       status: 'published',
@@ -515,15 +531,20 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     mockUpdatePost.mockResolvedValue(mockUpdatedPost);
 
     const tool = mockTools.get('ghost_update_post');
-    const result = await tool.handler({ id: '123', html: '<p>Updated content</p>' });
+    const result = await tool.handler({
+      id: '507f1f77bcf86cd799439011',
+      html: '<p>Updated content</p>',
+    });
 
-    expect(mockUpdatePost).toHaveBeenCalledWith('123', { html: '<p>Updated content</p>' });
+    expect(mockUpdatePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
+      html: '<p>Updated content</p>',
+    });
     expect(result.content[0].text).toContain('Updated content');
   });
 
   it('should update post status', async () => {
     const mockUpdatedPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Test Post',
       html: '<p>Content</p>',
       status: 'published',
@@ -532,15 +553,17 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     mockUpdatePost.mockResolvedValue(mockUpdatedPost);
 
     const tool = mockTools.get('ghost_update_post');
-    const result = await tool.handler({ id: '123', status: 'published' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', status: 'published' });
 
-    expect(mockUpdatePost).toHaveBeenCalledWith('123', { status: 'published' });
+    expect(mockUpdatePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
+      status: 'published',
+    });
     expect(result.content[0].text).toContain('"status": "published"');
   });
 
   it('should update post tags', async () => {
     const mockUpdatedPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Test Post',
       html: '<p>Content</p>',
       tags: [{ name: 'tech' }, { name: 'javascript' }],
@@ -549,16 +572,21 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     mockUpdatePost.mockResolvedValue(mockUpdatedPost);
 
     const tool = mockTools.get('ghost_update_post');
-    const result = await tool.handler({ id: '123', tags: ['tech', 'javascript'] });
+    const result = await tool.handler({
+      id: '507f1f77bcf86cd799439011',
+      tags: ['tech', 'javascript'],
+    });
 
-    expect(mockUpdatePost).toHaveBeenCalledWith('123', { tags: ['tech', 'javascript'] });
+    expect(mockUpdatePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
+      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',
+      id: '507f1f77bcf86cd799439011',
       title: 'Test Post',
       feature_image: 'https://example.com/new-image.jpg',
       feature_image_alt: 'New image',
@@ -568,12 +596,12 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
 
     const tool = mockTools.get('ghost_update_post');
     const result = await tool.handler({
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       feature_image: 'https://example.com/new-image.jpg',
       feature_image_alt: 'New image',
     });
 
-    expect(mockUpdatePost).toHaveBeenCalledWith('123', {
+    expect(mockUpdatePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
       feature_image: 'https://example.com/new-image.jpg',
       feature_image_alt: 'New image',
     });
@@ -582,7 +610,7 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
 
   it('should update SEO meta fields', async () => {
     const mockUpdatedPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Test Post',
       meta_title: 'SEO Title',
       meta_description: 'SEO Description',
@@ -592,12 +620,12 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
 
     const tool = mockTools.get('ghost_update_post');
     const result = await tool.handler({
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       meta_title: 'SEO Title',
       meta_description: 'SEO Description',
     });
 
-    expect(mockUpdatePost).toHaveBeenCalledWith('123', {
+    expect(mockUpdatePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
       meta_title: 'SEO Title',
       meta_description: 'SEO Description',
     });
@@ -607,7 +635,7 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
 
   it('should update multiple fields at once', async () => {
     const mockUpdatedPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Updated Title',
       html: '<p>Updated content</p>',
       status: 'published',
@@ -618,14 +646,14 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
 
     const tool = mockTools.get('ghost_update_post');
     const result = await tool.handler({
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       title: 'Updated Title',
       html: '<p>Updated content</p>',
       status: 'published',
       tags: ['tech'],
     });
 
-    expect(mockUpdatePost).toHaveBeenCalledWith('123', {
+    expect(mockUpdatePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
       title: 'Updated Title',
       html: '<p>Updated content</p>',
       status: 'published',
@@ -638,7 +666,7 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     mockUpdatePost.mockRejectedValue(new Error('Post not found'));
 
     const tool = mockTools.get('ghost_update_post');
-    const result = await tool.handler({ id: 'nonexistent', title: 'New Title' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439099', title: 'New Title' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Post not found');
@@ -648,7 +676,7 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     mockUpdatePost.mockRejectedValue(new Error('Validation failed: Title is required'));
 
     const tool = mockTools.get('ghost_update_post');
-    const result = await tool.handler({ id: '123', title: '' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', title: '' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Validation failed');
@@ -658,7 +686,7 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     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' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', title: 'Updated' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Ghost API error');
@@ -666,7 +694,7 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
 
   it('should return formatted JSON response', async () => {
     const mockUpdatedPost = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       uuid: 'uuid-123',
       title: 'Updated Post',
       slug: 'updated-post',
@@ -678,11 +706,11 @@ describe('mcp_server_improved - ghost_update_post tool', () => {
     mockUpdatePost.mockResolvedValue(mockUpdatedPost);
 
     const tool = mockTools.get('ghost_update_post');
-    const result = await tool.handler({ id: '123', title: 'Updated Post' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', 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('"id": "507f1f77bcf86cd799439011"');
     expect(result.content[0].text).toContain('"title": "Updated Post"');
     expect(result.content[0].text).toContain('"status": "published"');
   });
@@ -707,17 +735,20 @@ describe('mcp_server_improved - ghost_delete_post tool', () => {
     expect(tool.description).toContain('Deletes a post');
     expect(tool.description).toContain('permanent');
     expect(tool.schema).toBeDefined();
-    expect(tool.schema.id).toBeDefined();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.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' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
-    expect(mockDeletePost).toHaveBeenCalledWith('123');
-    expect(result.content[0].text).toContain('Post 123 has been successfully deleted');
+    expect(mockDeletePost).toHaveBeenCalledWith('507f1f77bcf86cd799439011');
+    expect(result.content[0].text).toContain(
+      'Post 507f1f77bcf86cd799439011 has been successfully deleted'
+    );
     expect(result.isError).toBeUndefined();
   });
 
@@ -725,7 +756,7 @@ describe('mcp_server_improved - ghost_delete_post tool', () => {
     mockDeletePost.mockRejectedValue(new Error('Post not found'));
 
     const tool = mockTools.get('ghost_delete_post');
-    const result = await tool.handler({ id: 'nonexistent' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439099' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Post not found');
@@ -735,7 +766,7 @@ describe('mcp_server_improved - ghost_delete_post tool', () => {
     mockDeletePost.mockRejectedValue(new Error('Ghost API error: Permission denied'));
 
     const tool = mockTools.get('ghost_delete_post');
-    const result = await tool.handler({ id: '123' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Ghost API error');
@@ -745,18 +776,20 @@ describe('mcp_server_improved - ghost_delete_post tool', () => {
     mockDeletePost.mockResolvedValue({ deleted: true });
 
     const tool = mockTools.get('ghost_delete_post');
-    const result = await tool.handler({ id: 'test-post-id' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
     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.');
+    expect(result.content[0].text).toBe(
+      'Post 507f1f77bcf86cd799439011 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' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439012' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Network error');
@@ -781,9 +814,10 @@ describe('mcp_server_improved - ghost_search_posts tool', () => {
     expect(tool).toBeDefined();
     expect(tool.description).toContain('Search');
     expect(tool.schema).toBeDefined();
-    expect(tool.schema.query).toBeDefined();
-    expect(tool.schema.status).toBeDefined();
-    expect(tool.schema.limit).toBeDefined();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.query).toBeDefined();
+    expect(tool.schema.shape.status).toBeDefined();
+    expect(tool.schema.shape.limit).toBeDefined();
   });
 
   it('should search posts with query only', async () => {
@@ -825,24 +859,26 @@ describe('mcp_server_improved - ghost_search_posts tool', () => {
 
   it('should validate limit is between 1 and 50', () => {
     const tool = mockTools.get('ghost_search_posts');
-    const schema = tool.schema;
+    // Zod schemas store field definitions in schema.shape
+    const shape = tool.schema.shape;
 
-    expect(schema.limit).toBeDefined();
-    expect(() => schema.limit.parse(0)).toThrow();
-    expect(() => schema.limit.parse(51)).toThrow();
-    expect(schema.limit.parse(25)).toBe(25);
+    expect(shape.limit).toBeDefined();
+    expect(() => shape.limit.parse(0)).toThrow();
+    expect(() => shape.limit.parse(51)).toThrow();
+    expect(shape.limit.parse(25)).toBe(25);
   });
 
   it('should validate status enum values', () => {
     const tool = mockTools.get('ghost_search_posts');
-    const schema = tool.schema;
+    // Zod schemas store field definitions in schema.shape
+    const shape = tool.schema.shape;
 
-    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');
+    expect(shape.status).toBeDefined();
+    expect(() => shape.status.parse('invalid')).toThrow();
+    expect(shape.status.parse('published')).toBe('published');
+    expect(shape.status.parse('draft')).toBe('draft');
+    expect(shape.status.parse('scheduled')).toBe('scheduled');
+    expect(shape.status.parse('all')).toBe('all');
   });
 
   it('should pass all parameters combined', async () => {
@@ -863,13 +899,12 @@ describe('mcp_server_improved - ghost_search_posts tool', () => {
   });
 
   it('should handle errors from searchPosts', async () => {
-    mockSearchPosts.mockRejectedValue(new Error('Search query is required'));
-
+    // Empty query is now caught by Zod validation
     const tool = mockTools.get('ghost_search_posts');
     const result = await tool.handler({ query: '' });
 
     expect(result.isError).toBe(true);
-    expect(result.content[0].text).toContain('Search query is required');
+    expect(result.content[0].text).toContain('VALIDATION_ERROR');
   });
 
   it('should handle Ghost API errors', async () => {
@@ -930,14 +965,15 @@ describe('ghost_get_tag', () => {
 
   it('should have correct schema with id and slug as optional', () => {
     const tool = mockTools.get('ghost_get_tag');
-    expect(tool.schema.id).toBeDefined();
-    expect(tool.schema.slug).toBeDefined();
-    expect(tool.schema.include).toBeDefined();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.id).toBeDefined();
+    expect(tool.schema.shape.slug).toBeDefined();
+    expect(tool.schema.shape.include).toBeDefined();
   });
 
   it('should retrieve tag by ID', async () => {
     const mockTag = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Test Tag',
       slug: 'test-tag',
       description: 'A test tag',
@@ -945,18 +981,18 @@ describe('ghost_get_tag', () => {
     mockGetTag.mockResolvedValue(mockTag);
 
     const tool = mockTools.get('ghost_get_tag');
-    const result = await tool.handler({ id: '123' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
-    expect(mockGetTag).toHaveBeenCalledWith('123', {});
+    expect(mockGetTag).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {});
     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('"id": "507f1f77bcf86cd799439011"');
     expect(result.content[0].text).toContain('"name": "Test Tag"');
   });
 
   it('should retrieve tag by slug', async () => {
     const mockTag = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Test Tag',
       slug: 'test-tag',
       description: 'A test tag',
@@ -972,7 +1008,7 @@ describe('ghost_get_tag', () => {
 
   it('should support include parameter for post count', async () => {
     const mockTag = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Test Tag',
       slug: 'test-tag',
       count: { posts: 5 },
@@ -980,9 +1016,9 @@ describe('ghost_get_tag', () => {
     mockGetTag.mockResolvedValue(mockTag);
 
     const tool = mockTools.get('ghost_get_tag');
-    const result = await tool.handler({ id: '123', include: 'count.posts' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', include: 'count.posts' });
 
-    expect(mockGetTag).toHaveBeenCalledWith('123', { include: 'count.posts' });
+    expect(mockGetTag).toHaveBeenCalledWith('507f1f77bcf86cd799439011', { include: 'count.posts' });
     expect(result.content[0].text).toContain('"count"');
   });
 
@@ -999,7 +1035,7 @@ describe('ghost_get_tag', () => {
     mockGetTag.mockRejectedValue(new Error('Tag not found'));
 
     const tool = mockTools.get('ghost_get_tag');
-    const result = await tool.handler({ id: '999' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439099' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Tag not found');
@@ -1022,48 +1058,54 @@ describe('ghost_update_tag', () => {
 
   it('should have correct schema with all update fields', () => {
     const tool = mockTools.get('ghost_update_tag');
-    expect(tool.schema.id).toBeDefined();
-    expect(tool.schema.name).toBeDefined();
-    expect(tool.schema.slug).toBeDefined();
-    expect(tool.schema.description).toBeDefined();
-    expect(tool.schema.feature_image).toBeDefined();
-    expect(tool.schema.meta_title).toBeDefined();
-    expect(tool.schema.meta_description).toBeDefined();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.id).toBeDefined();
+    expect(tool.schema.shape.name).toBeDefined();
+    expect(tool.schema.shape.slug).toBeDefined();
+    expect(tool.schema.shape.description).toBeDefined();
+    expect(tool.schema.shape.feature_image).toBeDefined();
+    expect(tool.schema.shape.meta_title).toBeDefined();
+    expect(tool.schema.shape.meta_description).toBeDefined();
   });
 
   it('should update tag name', async () => {
     const mockUpdatedTag = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Updated Tag',
       slug: 'updated-tag',
     };
     mockUpdateTag.mockResolvedValue(mockUpdatedTag);
 
     const tool = mockTools.get('ghost_update_tag');
-    const result = await tool.handler({ id: '123', name: 'Updated Tag' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', name: 'Updated Tag' });
 
-    expect(mockUpdateTag).toHaveBeenCalledWith('123', { name: 'Updated Tag' });
+    expect(mockUpdateTag).toHaveBeenCalledWith('507f1f77bcf86cd799439011', { name: 'Updated Tag' });
     expect(result.content[0].text).toContain('"name": "Updated Tag"');
   });
 
   it('should update tag description', async () => {
     const mockUpdatedTag = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Test Tag',
       description: 'New description',
     };
     mockUpdateTag.mockResolvedValue(mockUpdatedTag);
 
     const tool = mockTools.get('ghost_update_tag');
-    const result = await tool.handler({ id: '123', description: 'New description' });
+    const result = await tool.handler({
+      id: '507f1f77bcf86cd799439011',
+      description: 'New description',
+    });
 
-    expect(mockUpdateTag).toHaveBeenCalledWith('123', { description: 'New description' });
+    expect(mockUpdateTag).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
+      description: 'New description',
+    });
     expect(result.content[0].text).toContain('"description": "New description"');
   });
 
   it('should update multiple fields at once', async () => {
     const mockUpdatedTag = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Updated Tag',
       slug: 'updated-tag',
       description: 'Updated description',
@@ -1073,13 +1115,13 @@ describe('ghost_update_tag', () => {
 
     const tool = mockTools.get('ghost_update_tag');
     await tool.handler({
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Updated Tag',
       description: 'Updated description',
       meta_title: 'Updated Meta',
     });
 
-    expect(mockUpdateTag).toHaveBeenCalledWith('123', {
+    expect(mockUpdateTag).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
       name: 'Updated Tag',
       description: 'Updated description',
       meta_title: 'Updated Meta',
@@ -1088,7 +1130,7 @@ describe('ghost_update_tag', () => {
 
   it('should update tag feature image', async () => {
     const mockUpdatedTag = {
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       name: 'Test Tag',
       feature_image: 'https://example.com/image.jpg',
     };
@@ -1096,11 +1138,11 @@ describe('ghost_update_tag', () => {
 
     const tool = mockTools.get('ghost_update_tag');
     await tool.handler({
-      id: '123',
+      id: '507f1f77bcf86cd799439011',
       feature_image: 'https://example.com/image.jpg',
     });
 
-    expect(mockUpdateTag).toHaveBeenCalledWith('123', {
+    expect(mockUpdateTag).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
       feature_image: 'https://example.com/image.jpg',
     });
   });
@@ -1110,14 +1152,14 @@ describe('ghost_update_tag', () => {
     const result = await tool.handler({ name: 'Test' });
 
     expect(result.isError).toBe(true);
-    expect(result.content[0].text).toContain('Tag ID is required');
+    expect(result.content[0].text).toContain('VALIDATION_ERROR');
   });
 
   it('should handle validation error', async () => {
     mockUpdateTag.mockRejectedValue(new Error('Validation failed'));
 
     const tool = mockTools.get('ghost_update_tag');
-    const result = await tool.handler({ id: '123', name: '' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', name: '' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Validation failed');
@@ -1127,7 +1169,7 @@ describe('ghost_update_tag', () => {
     mockUpdateTag.mockRejectedValue(new Error('Tag not found'));
 
     const tool = mockTools.get('ghost_update_tag');
-    const result = await tool.handler({ id: '999', name: 'Test' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439099', name: 'Test' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Tag not found');
@@ -1150,16 +1192,17 @@ describe('ghost_delete_tag', () => {
 
   it('should have correct schema with id field', () => {
     const tool = mockTools.get('ghost_delete_tag');
-    expect(tool.schema.id).toBeDefined();
+    // Zod schemas store field definitions in schema.shape
+    expect(tool.schema.shape.id).toBeDefined();
   });
 
   it('should delete tag successfully', async () => {
     mockDeleteTag.mockResolvedValue({ success: true });
 
     const tool = mockTools.get('ghost_delete_tag');
-    const result = await tool.handler({ id: '123' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
-    expect(mockDeleteTag).toHaveBeenCalledWith('123');
+    expect(mockDeleteTag).toHaveBeenCalledWith('507f1f77bcf86cd799439011');
     expect(result.content[0].text).toContain('successfully deleted');
     expect(result.isError).toBeUndefined();
   });
@@ -1169,14 +1212,14 @@ describe('ghost_delete_tag', () => {
     const result = await tool.handler({});
 
     expect(result.isError).toBe(true);
-    expect(result.content[0].text).toContain('Tag ID is required');
+    expect(result.content[0].text).toContain('VALIDATION_ERROR');
   });
 
   it('should handle not found error', async () => {
     mockDeleteTag.mockRejectedValue(new Error('Tag not found'));
 
     const tool = mockTools.get('ghost_delete_tag');
-    const result = await tool.handler({ id: '999' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439099' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Tag not found');
@@ -1186,7 +1229,7 @@ describe('ghost_delete_tag', () => {
     mockDeleteTag.mockRejectedValue(new Error('Failed to delete tag'));
 
     const tool = mockTools.get('ghost_delete_tag');
-    const result = await tool.handler({ id: '123' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Failed to delete tag');