@jgardner04/ghost-mcp-server 1.11.0 → 1.12.1

package/src/__tests__/mcp_server_pages.test.js

@@ -143,12 +143,11 @@ describe('mcp_server_improved - ghost_get_pages tool', () => {
     expect(tool).toBeDefined();
     expect(tool.description).toContain('pages');
     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();
+    expect(tool.schema.shape.limit).toBeDefined();
+    expect(tool.schema.shape.page).toBeDefined();
+    expect(tool.schema.shape.include).toBeDefined();
+    expect(tool.schema.shape.filter).toBeDefined();
+    expect(tool.schema.shape.order).toBeDefined();
   });
 
   it('should retrieve pages with default options', async () => {
@@ -180,20 +179,20 @@ describe('mcp_server_improved - ghost_get_pages tool', () => {
     const tool = mockTools.get('ghost_get_pages');
     const schema = tool.schema;
 
-    expect(schema.limit).toBeDefined();
-    expect(() => schema.limit.parse(0)).toThrow();
-    expect(() => schema.limit.parse(101)).toThrow();
-    expect(schema.limit.parse(50)).toBe(50);
+    expect(schema.shape.limit).toBeDefined();
+    expect(() => schema.shape.limit.parse(0)).toThrow();
+    expect(() => schema.shape.limit.parse(101)).toThrow();
+    expect(schema.shape.limit.parse(50)).toBe(50);
   });
 
-  it('should pass status filter', async () => {
+  it('should pass filter parameter', async () => {
     const mockPages = [{ id: '1', title: 'Published Page', status: 'published' }];
     mockGetPages.mockResolvedValue(mockPages);
 
     const tool = mockTools.get('ghost_get_pages');
-    await tool.handler({ status: 'published' });
+    await tool.handler({ filter: 'status:published' });
 
-    expect(mockGetPages).toHaveBeenCalledWith({ status: 'published' });
+    expect(mockGetPages).toHaveBeenCalledWith({ filter: 'status:published' });
   });
 
   it('should handle errors gracefully', async () => {
@@ -222,24 +221,26 @@ describe('mcp_server_improved - ghost_get_page tool', () => {
   it('should have correct schema with id and slug options', () => {
     const tool = mockTools.get('ghost_get_page');
     expect(tool).toBeDefined();
-    expect(tool.schema.id).toBeDefined();
-    expect(tool.schema.slug).toBeDefined();
-    expect(tool.schema.include).toBeDefined();
+    // ghost_get_page uses a refined schema, access via _def.schema.shape
+    const shape = tool.schema._def.schema.shape;
+    expect(shape.id).toBeDefined();
+    expect(shape.slug).toBeDefined();
+    expect(shape.include).toBeDefined();
   });
 
   it('should retrieve page by ID', async () => {
-    const mockPage = { id: 'page-123', title: 'About Us', slug: 'about-us' };
+    const mockPage = { id: '507f1f77bcf86cd799439011', title: 'About Us', slug: 'about-us' };
     mockGetPage.mockResolvedValue(mockPage);
 
     const tool = mockTools.get('ghost_get_page');
-    const result = await tool.handler({ id: 'page-123' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
-    expect(mockGetPage).toHaveBeenCalledWith('page-123', {});
+    expect(mockGetPage).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {});
     expect(result.content[0].text).toContain('About Us');
   });
 
   it('should retrieve page by slug', async () => {
-    const mockPage = { id: 'page-123', title: 'About Us', slug: 'about-us' };
+    const mockPage = { id: '507f1f77bcf86cd799439011', title: 'About Us', slug: 'about-us' };
     mockGetPage.mockResolvedValue(mockPage);
 
     const tool = mockTools.get('ghost_get_page');
@@ -249,19 +250,20 @@ describe('mcp_server_improved - ghost_get_page tool', () => {
     expect(result.content[0].text).toContain('About Us');
   });
 
-  it('should require either id or slug', async () => {
+  it('should require either id or slug', () => {
     const tool = mockTools.get('ghost_get_page');
-    const result = await tool.handler({});
-
-    expect(result.isError).toBe(true);
-    expect(result.content[0].text).toContain('Either id or slug is required');
+    // Test schema validation - the refine check requires id or slug
+    expect(() => tool.schema.parse({})).toThrow();
+    // Valid inputs should parse successfully (Ghost IDs are 24 hex chars)
+    expect(() => tool.schema.parse({ id: '507f1f77bcf86cd799439011' })).not.toThrow();
+    expect(() => tool.schema.parse({ slug: 'about-us' })).not.toThrow();
   });
 
   it('should handle errors gracefully', async () => {
     mockGetPage.mockRejectedValue(new Error('Page not found'));
 
     const tool = mockTools.get('ghost_get_page');
-    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('Error retrieving page');
@@ -283,28 +285,29 @@ describe('mcp_server_improved - ghost_create_page tool', () => {
   it('should have correct schema with required and optional fields', () => {
     const tool = mockTools.get('ghost_create_page');
     expect(tool).toBeDefined();
-    expect(tool.description).toContain('NOT support tags');
-    expect(tool.schema.title).toBeDefined();
-    expect(tool.schema.html).toBeDefined();
-    expect(tool.schema.status).toBeDefined();
-    expect(tool.schema.feature_image).toBeDefined();
-    expect(tool.schema.meta_title).toBeDefined();
-    expect(tool.schema.meta_description).toBeDefined();
-    // Should NOT have tags
-    expect(tool.schema.tags).toBeUndefined();
+    expect(tool.description).toContain('page');
+    expect(tool.schema.shape.title).toBeDefined();
+    expect(tool.schema.shape.html).toBeDefined();
+    expect(tool.schema.shape.status).toBeDefined();
+    expect(tool.schema.shape.feature_image).toBeDefined();
+    expect(tool.schema.shape.meta_title).toBeDefined();
+    expect(tool.schema.shape.meta_description).toBeDefined();
   });
 
   it('should create page with minimal input', async () => {
-    const createdPage = { id: 'page-123', title: 'New Page', status: 'draft' };
+    const createdPage = { id: '507f1f77bcf86cd799439011', title: 'New Page', status: 'draft' };
     mockCreatePageService.mockResolvedValue(createdPage);
 
     const tool = mockTools.get('ghost_create_page');
     const result = await tool.handler({ title: 'New Page', html: '<p>Content</p>' });
 
-    expect(mockCreatePageService).toHaveBeenCalledWith({
-      title: 'New Page',
-      html: '<p>Content</p>',
-    });
+    // Schema adds default values, so use objectContaining for the key fields
+    expect(mockCreatePageService).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'New Page',
+        html: '<p>Content</p>',
+      })
+    );
     expect(result.content[0].text).toContain('New Page');
   });
 
@@ -320,13 +323,14 @@ describe('mcp_server_improved - ghost_create_page tool', () => {
       meta_title: 'SEO Title',
       meta_description: 'SEO Description',
     };
-    const createdPage = { id: 'page-123', ...fullInput };
+    const createdPage = { id: '507f1f77bcf86cd799439011', ...fullInput };
     mockCreatePageService.mockResolvedValue(createdPage);
 
     const tool = mockTools.get('ghost_create_page');
     const result = await tool.handler(fullInput);
 
-    expect(mockCreatePageService).toHaveBeenCalledWith(fullInput);
+    // Schema adds default values, so use objectContaining for the key fields
+    expect(mockCreatePageService).toHaveBeenCalledWith(expect.objectContaining(fullInput));
     expect(result.content[0].text).toContain('Complete Page');
   });
 
@@ -356,39 +360,39 @@ describe('mcp_server_improved - ghost_update_page tool', () => {
   it('should have correct schema with id required and other fields optional', () => {
     const tool = mockTools.get('ghost_update_page');
     expect(tool).toBeDefined();
-    expect(tool.description).toContain('NOT support tags');
-    expect(tool.schema.id).toBeDefined();
-    expect(tool.schema.title).toBeDefined();
-    expect(tool.schema.html).toBeDefined();
-    expect(tool.schema.status).toBeDefined();
-    // Should NOT have tags
-    expect(tool.schema.tags).toBeUndefined();
+    expect(tool.description).toContain('page');
+    expect(tool.schema.shape.id).toBeDefined();
+    expect(tool.schema.shape.title).toBeDefined();
+    expect(tool.schema.shape.html).toBeDefined();
+    expect(tool.schema.shape.status).toBeDefined();
   });
 
   it('should update page with new title', async () => {
-    const updatedPage = { id: 'page-123', title: 'Updated Title' };
+    const updatedPage = { id: '507f1f77bcf86cd799439011', title: 'Updated Title' };
     mockUpdatePage.mockResolvedValue(updatedPage);
 
     const tool = mockTools.get('ghost_update_page');
-    const result = await tool.handler({ id: 'page-123', title: 'Updated Title' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011', title: 'Updated Title' });
 
-    expect(mockUpdatePage).toHaveBeenCalledWith('page-123', { title: 'Updated Title' });
+    expect(mockUpdatePage).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
+      title: 'Updated Title',
+    });
     expect(result.content[0].text).toContain('Updated Title');
   });
 
   it('should update page with multiple fields', async () => {
-    const updatedPage = { id: 'page-123', title: 'New Title', status: 'published' };
+    const updatedPage = { id: '507f1f77bcf86cd799439011', title: 'New Title', status: 'published' };
     mockUpdatePage.mockResolvedValue(updatedPage);
 
     const tool = mockTools.get('ghost_update_page');
     const result = await tool.handler({
-      id: 'page-123',
+      id: '507f1f77bcf86cd799439011',
       title: 'New Title',
       status: 'published',
       html: '<p>Updated content</p>',
     });
 
-    expect(mockUpdatePage).toHaveBeenCalledWith('page-123', {
+    expect(mockUpdatePage).toHaveBeenCalledWith('507f1f77bcf86cd799439011', {
       title: 'New Title',
       status: 'published',
       html: '<p>Updated content</p>',
@@ -400,7 +404,7 @@ describe('mcp_server_improved - ghost_update_page tool', () => {
     mockUpdatePage.mockRejectedValue(new Error('Page not found'));
 
     const tool = mockTools.get('ghost_update_page');
-    const result = await tool.handler({ id: 'nonexistent', title: 'Test' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439099', title: 'Test' });
 
     expect(result.isError).toBe(true);
     expect(result.content[0].text).toContain('Error updating page');
@@ -422,17 +426,17 @@ describe('mcp_server_improved - ghost_delete_page tool', () => {
   it('should have correct schema with id required', () => {
     const tool = mockTools.get('ghost_delete_page');
     expect(tool).toBeDefined();
-    expect(tool.schema.id).toBeDefined();
+    expect(tool.schema.shape.id).toBeDefined();
     expect(tool.description).toContain('permanent');
   });
 
   it('should delete page by ID', async () => {
-    mockDeletePage.mockResolvedValue({ id: 'page-123' });
+    mockDeletePage.mockResolvedValue({ id: '507f1f77bcf86cd799439011' });
 
     const tool = mockTools.get('ghost_delete_page');
-    const result = await tool.handler({ id: 'page-123' });
+    const result = await tool.handler({ id: '507f1f77bcf86cd799439011' });
 
-    expect(mockDeletePage).toHaveBeenCalledWith('page-123');
+    expect(mockDeletePage).toHaveBeenCalledWith('507f1f77bcf86cd799439011');
     expect(result.content[0].text).toContain('successfully deleted');
   });
 
@@ -440,7 +444,7 @@ describe('mcp_server_improved - ghost_delete_page tool', () => {
     mockDeletePage.mockRejectedValue(new Error('Page not found'));
 
     const tool = mockTools.get('ghost_delete_page');
-    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('Error deleting page');
@@ -462,9 +466,9 @@ describe('mcp_server_improved - ghost_search_pages tool', () => {
   it('should have correct schema with query required', () => {
     const tool = mockTools.get('ghost_search_pages');
     expect(tool).toBeDefined();
-    expect(tool.schema.query).toBeDefined();
-    expect(tool.schema.status).toBeDefined();
-    expect(tool.schema.limit).toBeDefined();
+    expect(tool.schema.shape.query).toBeDefined();
+    expect(tool.schema.shape.status).toBeDefined();
+    expect(tool.schema.shape.limit).toBeDefined();
   });
 
   it('should search pages with query', async () => {
@@ -502,10 +506,10 @@ describe('mcp_server_improved - ghost_search_pages tool', () => {
     const tool = mockTools.get('ghost_search_pages');
     const schema = tool.schema;
 
-    expect(schema.limit).toBeDefined();
-    expect(() => schema.limit.parse(0)).toThrow();
-    expect(() => schema.limit.parse(51)).toThrow();
-    expect(schema.limit.parse(25)).toBe(25);
+    expect(schema.shape.limit).toBeDefined();
+    expect(() => schema.shape.limit.parse(0)).toThrow();
+    expect(() => schema.shape.limit.parse(51)).toThrow();
+    expect(schema.shape.limit.parse(25)).toBe(25);
   });
 
   it('should handle errors gracefully', async () => {

package/src/errors/__tests__/index.test.js

@@ -122,6 +122,76 @@ describe('Error Handling System', () => {
         type: 'number.base',
       });
     });
+
+    it('should create validation error from Zod error', () => {
+      const zodError = {
+        errors: [
+          {
+            path: ['user', 'email'],
+            message: 'Invalid email',
+            code: 'invalid_string',
+          },
+          {
+            path: ['age'],
+            message: 'Expected number, received string',
+            code: 'invalid_type',
+          },
+        ],
+      };
+
+      const error = ValidationError.fromZod(zodError);
+
+      expect(error.message).toBe('Validation failed');
+      expect(error.errors).toHaveLength(2);
+      expect(error.errors[0]).toEqual({
+        field: 'user.email',
+        message: 'Invalid email',
+        type: 'invalid_string',
+      });
+      expect(error.errors[1]).toEqual({
+        field: 'age',
+        message: 'Expected number, received string',
+        type: 'invalid_type',
+      });
+    });
+
+    it('should create validation error from Zod error with context', () => {
+      const zodError = {
+        errors: [
+          {
+            path: ['name'],
+            message: 'String must contain at least 1 character(s)',
+            code: 'too_small',
+          },
+        ],
+      };
+
+      const error = ValidationError.fromZod(zodError, 'Tag creation');
+
+      expect(error.message).toBe('Tag creation: Validation failed');
+      expect(error.errors).toHaveLength(1);
+      expect(error.errors[0]).toEqual({
+        field: 'name',
+        message: 'String must contain at least 1 character(s)',
+        type: 'too_small',
+      });
+    });
+
+    it('should create validation error from Zod error with empty path', () => {
+      const zodError = {
+        errors: [
+          {
+            path: [],
+            message: 'Invalid input',
+            code: 'custom',
+          },
+        ],
+      };
+
+      const error = ValidationError.fromZod(zodError);
+
+      expect(error.errors[0].field).toBe('');
+    });
   });
 
   describe('AuthenticationError', () => {

package/src/errors/index.js

@@ -48,6 +48,16 @@ export class ValidationError extends BaseError {
     }));
     return new ValidationError('Validation failed', errors);
   }
+
+  static fromZod(zodError, context = '') {
+    const errors = zodError.errors.map((err) => ({
+      field: err.path.join('.'),
+      message: err.message,
+      type: err.code,
+    }));
+    const message = context ? `${context}: Validation failed` : 'Validation failed';
+    return new ValidationError(message, errors);
+  }
 }
 
 /**

package/src/mcp_server.js

@@ -14,6 +14,7 @@ import os from 'os';
 import { v4 as uuidv4 } from 'uuid';
 import { validateImageUrl, createSecureAxiosConfig } from './utils/urlValidator.js';
 import { createContextLogger } from './utils/logger.js';
+import { trackTempFile, cleanupTempFiles } from './utils/tempFileManager.js';
 
 // Load environment variables (might be redundant if loaded elsewhere, but safe)
 dotenv.config();
@@ -300,11 +301,17 @@ const uploadImageTool = new Tool({
         writer.on('finish', resolve);
         writer.on('error', reject);
       });
+      // Track temp file for cleanup on process exit
+      trackTempFile(downloadedPath);
       logger.fileOperation('download', downloadedPath);
 
       // --- 3. Process the image (Optional) ---
       // Using the service from subtask 4.2
       processedPath = await processImage(downloadedPath, tempDir);
+      // Track processed file for cleanup on process exit
+      if (processedPath !== downloadedPath) {
+        trackTempFile(processedPath);
+      }
       logger.fileOperation('process', processedPath);
 
       // --- 4. Determine Alt Text ---
@@ -327,25 +334,8 @@ const uploadImageTool = new Tool({
       // Add more specific error handling (download failed, processing failed, upload failed)
       throw new Error(`Failed to upload image from URL ${imageUrl}: ${error.message}`);
     } finally {
-      // --- 7. Cleanup temporary files ---
-      if (downloadedPath) {
-        fs.unlink(downloadedPath, (err) => {
-          if (err)
-            logger.warn('Failed to delete temporary downloaded file', {
-              file: path.basename(downloadedPath),
-              error: err.message,
-            });
-        });
-      }
-      if (processedPath && processedPath !== downloadedPath) {
-        fs.unlink(processedPath, (err) => {
-          if (err)
-            logger.warn('Failed to delete temporary processed file', {
-              file: path.basename(processedPath),
-              error: err.message,
-            });
-        });
-      }
+      // --- 7. Cleanup temporary files with proper async/await ---
+      await cleanupTempFiles([downloadedPath, processedPath], logger);
     }
   },
 });