@jgardner04/ghost-mcp-server 1.11.0 → 1.12.1

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

@@ -0,0 +1,316 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+
+// Mock fs modules before importing the module under test
+vi.mock('fs', async () => {
+  const actual = await vi.importActual('fs');
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      unlinkSync: vi.fn(),
+    },
+    unlinkSync: vi.fn(),
+  };
+});
+
+vi.mock('fs/promises', () => ({
+  default: {
+    unlink: vi.fn(),
+  },
+  unlink: vi.fn(),
+}));
+
+// Import after mocking
+import {
+  trackTempFile,
+  untrackTempFile,
+  cleanupTempFile,
+  cleanupTempFiles,
+  cleanupAllTrackedFilesSync,
+  getTrackedFiles,
+  clearTracking,
+} from '../tempFileManager.js';
+
+describe('tempFileManager', () => {
+  beforeEach(() => {
+    // Clear tracking and reset mocks before each test
+    clearTracking();
+    vi.clearAllMocks();
+  });
+
+  describe('trackTempFile', () => {
+    it('should add file path to tracking set', () => {
+      trackTempFile('/tmp/test-file.jpg');
+
+      const tracked = getTrackedFiles();
+      expect(tracked.has('/tmp/test-file.jpg')).toBe(true);
+    });
+
+    it('should handle null gracefully', () => {
+      expect(() => trackTempFile(null)).not.toThrow();
+      expect(getTrackedFiles().size).toBe(0);
+    });
+
+    it('should handle undefined gracefully', () => {
+      expect(() => trackTempFile(undefined)).not.toThrow();
+      expect(getTrackedFiles().size).toBe(0);
+    });
+
+    it('should handle empty string gracefully', () => {
+      expect(() => trackTempFile('')).not.toThrow();
+      expect(getTrackedFiles().size).toBe(0);
+    });
+
+    it('should not add duplicate paths', () => {
+      trackTempFile('/tmp/test-file.jpg');
+      trackTempFile('/tmp/test-file.jpg');
+
+      const tracked = getTrackedFiles();
+      expect(tracked.size).toBe(1);
+    });
+
+    it('should track multiple different files', () => {
+      trackTempFile('/tmp/file1.jpg');
+      trackTempFile('/tmp/file2.jpg');
+      trackTempFile('/tmp/file3.jpg');
+
+      const tracked = getTrackedFiles();
+      expect(tracked.size).toBe(3);
+    });
+  });
+
+  describe('untrackTempFile', () => {
+    it('should remove file path from tracking set', () => {
+      trackTempFile('/tmp/test-file.jpg');
+      untrackTempFile('/tmp/test-file.jpg');
+
+      const tracked = getTrackedFiles();
+      expect(tracked.has('/tmp/test-file.jpg')).toBe(false);
+    });
+
+    it('should handle non-existent paths gracefully', () => {
+      expect(() => untrackTempFile('/tmp/non-existent.jpg')).not.toThrow();
+    });
+
+    it('should handle null gracefully', () => {
+      expect(() => untrackTempFile(null)).not.toThrow();
+    });
+
+    it('should handle undefined gracefully', () => {
+      expect(() => untrackTempFile(undefined)).not.toThrow();
+    });
+  });
+
+  describe('cleanupTempFile', () => {
+    it('should delete file and untrack it', async () => {
+      fsPromises.unlink.mockResolvedValueOnce(undefined);
+      trackTempFile('/tmp/test-file.jpg');
+
+      await cleanupTempFile('/tmp/test-file.jpg');
+
+      expect(fsPromises.unlink).toHaveBeenCalledWith('/tmp/test-file.jpg');
+      expect(getTrackedFiles().has('/tmp/test-file.jpg')).toBe(false);
+    });
+
+    it('should resolve when file does not exist (ENOENT)', async () => {
+      const error = new Error('File not found');
+      error.code = 'ENOENT';
+      fsPromises.unlink.mockRejectedValueOnce(error);
+
+      await expect(cleanupTempFile('/tmp/non-existent.jpg')).resolves.toBeUndefined();
+    });
+
+    it('should not log warning for ENOENT errors', async () => {
+      const error = new Error('File not found');
+      error.code = 'ENOENT';
+      fsPromises.unlink.mockRejectedValueOnce(error);
+      const mockLogger = { warn: vi.fn() };
+
+      await cleanupTempFile('/tmp/non-existent.jpg', mockLogger);
+
+      expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+
+    it('should log warning on other errors but still resolve', async () => {
+      const error = new Error('Permission denied');
+      error.code = 'EACCES';
+      fsPromises.unlink.mockRejectedValueOnce(error);
+      const mockLogger = { warn: vi.fn() };
+
+      await expect(cleanupTempFile('/tmp/test.jpg', mockLogger)).resolves.toBeUndefined();
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        'Failed to delete temp file',
+        expect.objectContaining({ file: '/tmp/test.jpg' })
+      );
+    });
+
+    it('should handle null path', async () => {
+      await expect(cleanupTempFile(null)).resolves.toBeUndefined();
+      expect(fsPromises.unlink).not.toHaveBeenCalled();
+    });
+
+    it('should handle undefined path', async () => {
+      await expect(cleanupTempFile(undefined)).resolves.toBeUndefined();
+      expect(fsPromises.unlink).not.toHaveBeenCalled();
+    });
+
+    it('should handle empty string path', async () => {
+      await expect(cleanupTempFile('')).resolves.toBeUndefined();
+      expect(fsPromises.unlink).not.toHaveBeenCalled();
+    });
+
+    it('should untrack file even on error', async () => {
+      const error = new Error('Permission denied');
+      error.code = 'EACCES';
+      fsPromises.unlink.mockRejectedValueOnce(error);
+      trackTempFile('/tmp/test.jpg');
+      const mockLogger = { warn: vi.fn() };
+
+      await cleanupTempFile('/tmp/test.jpg', mockLogger);
+
+      expect(getTrackedFiles().has('/tmp/test.jpg')).toBe(false);
+    });
+
+    it('should work with default console logger', async () => {
+      fsPromises.unlink.mockResolvedValueOnce(undefined);
+
+      // Should not throw when using default logger
+      await expect(cleanupTempFile('/tmp/test.jpg')).resolves.toBeUndefined();
+    });
+  });
+
+  describe('cleanupTempFiles', () => {
+    it('should clean up multiple files in parallel', async () => {
+      fsPromises.unlink.mockResolvedValue(undefined);
+
+      await cleanupTempFiles(['/tmp/file1.jpg', '/tmp/file2.jpg', '/tmp/file3.jpg']);
+
+      expect(fsPromises.unlink).toHaveBeenCalledTimes(3);
+      expect(fsPromises.unlink).toHaveBeenCalledWith('/tmp/file1.jpg');
+      expect(fsPromises.unlink).toHaveBeenCalledWith('/tmp/file2.jpg');
+      expect(fsPromises.unlink).toHaveBeenCalledWith('/tmp/file3.jpg');
+    });
+
+    it('should handle mixed success/failure scenarios', async () => {
+      fsPromises.unlink
+        .mockResolvedValueOnce(undefined)
+        .mockRejectedValueOnce(new Error('Failed'))
+        .mockResolvedValueOnce(undefined);
+      const mockLogger = { warn: vi.fn() };
+
+      // Should resolve even with failures
+      await expect(
+        cleanupTempFiles(['/tmp/file1.jpg', '/tmp/file2.jpg', '/tmp/file3.jpg'], mockLogger)
+      ).resolves.toBeUndefined();
+    });
+
+    it('should filter out null and undefined paths', async () => {
+      fsPromises.unlink.mockResolvedValue(undefined);
+
+      await cleanupTempFiles(['/tmp/file1.jpg', null, undefined, '/tmp/file2.jpg']);
+
+      expect(fsPromises.unlink).toHaveBeenCalledTimes(2);
+    });
+
+    it('should filter out empty string paths', async () => {
+      fsPromises.unlink.mockResolvedValue(undefined);
+
+      await cleanupTempFiles(['/tmp/file1.jpg', '', '/tmp/file2.jpg']);
+
+      expect(fsPromises.unlink).toHaveBeenCalledTimes(2);
+    });
+
+    it('should deduplicate paths', async () => {
+      fsPromises.unlink.mockResolvedValue(undefined);
+
+      await cleanupTempFiles(['/tmp/file1.jpg', '/tmp/file1.jpg', '/tmp/file2.jpg']);
+
+      expect(fsPromises.unlink).toHaveBeenCalledTimes(2);
+    });
+
+    it('should handle empty file list', async () => {
+      await expect(cleanupTempFiles([])).resolves.toBeUndefined();
+      expect(fsPromises.unlink).not.toHaveBeenCalled();
+    });
+
+    it('should handle list with only null/undefined', async () => {
+      await expect(cleanupTempFiles([null, undefined, ''])).resolves.toBeUndefined();
+      expect(fsPromises.unlink).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('cleanupAllTrackedFilesSync', () => {
+    it('should clean up all currently tracked files', () => {
+      fs.unlinkSync.mockImplementation(() => {});
+      trackTempFile('/tmp/file1.jpg');
+      trackTempFile('/tmp/file2.jpg');
+
+      cleanupAllTrackedFilesSync();
+
+      expect(fs.unlinkSync).toHaveBeenCalledWith('/tmp/file1.jpg');
+      expect(fs.unlinkSync).toHaveBeenCalledWith('/tmp/file2.jpg');
+    });
+
+    it('should clear the tracking set after cleanup', () => {
+      fs.unlinkSync.mockImplementation(() => {});
+      trackTempFile('/tmp/file1.jpg');
+
+      cleanupAllTrackedFilesSync();
+
+      expect(getTrackedFiles().size).toBe(0);
+    });
+
+    it('should handle empty tracking set gracefully', () => {
+      expect(() => cleanupAllTrackedFilesSync()).not.toThrow();
+    });
+
+    it('should continue cleanup even if one file fails', () => {
+      fs.unlinkSync
+        .mockImplementationOnce(() => {
+          throw new Error('Failed');
+        })
+        .mockImplementationOnce(() => {});
+      trackTempFile('/tmp/file1.jpg');
+      trackTempFile('/tmp/file2.jpg');
+
+      expect(() => cleanupAllTrackedFilesSync()).not.toThrow();
+      expect(fs.unlinkSync).toHaveBeenCalledTimes(2);
+    });
+
+    it('should clear tracking set even on errors', () => {
+      fs.unlinkSync.mockImplementation(() => {
+        throw new Error('Failed');
+      });
+      trackTempFile('/tmp/file1.jpg');
+
+      cleanupAllTrackedFilesSync();
+
+      expect(getTrackedFiles().size).toBe(0);
+    });
+  });
+
+  describe('getTrackedFiles', () => {
+    it('should return a copy of the tracking set', () => {
+      trackTempFile('/tmp/test.jpg');
+
+      const tracked = getTrackedFiles();
+      tracked.add('/tmp/hacked.jpg'); // Try to modify
+
+      // Original set should not be affected
+      expect(getTrackedFiles().has('/tmp/hacked.jpg')).toBe(false);
+    });
+  });
+
+  describe('clearTracking', () => {
+    it('should clear all tracked files', () => {
+      trackTempFile('/tmp/file1.jpg');
+      trackTempFile('/tmp/file2.jpg');
+
+      clearTracking();
+
+      expect(getTrackedFiles().size).toBe(0);
+    });
+  });
+});

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

@@ -0,0 +1,163 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import { validateToolInput } from '../validation.js';
+
+describe('validateToolInput', () => {
+  const testSchema = z.object({
+    name: z.string().min(1),
+    count: z.number().int().positive(),
+  });
+
+  describe('valid input', () => {
+    it('should return success with validated data for valid input', () => {
+      const result = validateToolInput(testSchema, { name: 'test', count: 5 }, 'test_tool');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({ name: 'test', count: 5 });
+    });
+
+    it('should not include errorResponse on success', () => {
+      const result = validateToolInput(testSchema, { name: 'test', count: 5 }, 'test_tool');
+
+      expect(result.success).toBe(true);
+      expect(result).not.toHaveProperty('errorResponse');
+    });
+  });
+
+  describe('invalid input', () => {
+    it('should return error response for invalid input', () => {
+      const result = validateToolInput(testSchema, { name: '', count: -1 }, 'test_tool');
+
+      expect(result.success).toBe(false);
+      expect(result.errorResponse.isError).toBe(true);
+      expect(result.errorResponse.content[0].type).toBe('text');
+    });
+
+    it('should include tool name in error context', () => {
+      const result = validateToolInput(testSchema, {}, 'ghost_create_tag');
+
+      expect(result.success).toBe(false);
+      const errorText = result.errorResponse.content[0].text;
+      expect(errorText).toContain('ghost_create_tag');
+      expect(errorText).toContain('Validation failed');
+    });
+
+    it('should include VALIDATION_ERROR code in response', () => {
+      const result = validateToolInput(testSchema, { name: '' }, 'test_tool');
+
+      expect(result.success).toBe(false);
+      const errorText = result.errorResponse.content[0].text;
+      expect(errorText).toContain('VALIDATION_ERROR');
+    });
+
+    it('should include structured error information', () => {
+      const result = validateToolInput(testSchema, { name: '' }, 'test_tool');
+
+      expect(result.success).toBe(false);
+      const errorObj = JSON.parse(result.errorResponse.content[0].text);
+      expect(errorObj.name).toBe('ValidationError');
+      expect(errorObj.code).toBe('VALIDATION_ERROR');
+      expect(errorObj.statusCode).toBe(400);
+      expect(errorObj.message).toContain('Validation failed');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle undefined input', () => {
+      const result = validateToolInput(testSchema, undefined, 'test_tool');
+
+      expect(result.success).toBe(false);
+      expect(result.errorResponse.isError).toBe(true);
+    });
+
+    it('should handle null input', () => {
+      const result = validateToolInput(testSchema, null, 'test_tool');
+
+      expect(result.success).toBe(false);
+      expect(result.errorResponse.isError).toBe(true);
+    });
+
+    it('should handle empty object input', () => {
+      const result = validateToolInput(testSchema, {}, 'test_tool');
+
+      expect(result.success).toBe(false);
+      expect(result.errorResponse.isError).toBe(true);
+    });
+  });
+
+  describe('schema transforms', () => {
+    it('should apply schema transforms and return transformed data', () => {
+      const transformSchema = z.object({
+        value: z.string().transform((s) => s.toUpperCase()),
+      });
+      const result = validateToolInput(transformSchema, { value: 'test' }, 'test_tool');
+
+      expect(result.success).toBe(true);
+      expect(result.data.value).toBe('TEST');
+    });
+
+    it('should apply default values from schema', () => {
+      const defaultSchema = z.object({
+        name: z.string(),
+        enabled: z.boolean().default(true),
+      });
+      const result = validateToolInput(defaultSchema, { name: 'test' }, 'test_tool');
+
+      expect(result.success).toBe(true);
+      expect(result.data.enabled).toBe(true);
+    });
+  });
+
+  describe('partial schemas', () => {
+    it('should work with partial schemas', () => {
+      const partialSchema = testSchema.partial();
+      const result = validateToolInput(partialSchema, {}, 'test_tool');
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({});
+    });
+
+    it('should still validate provided fields in partial schemas', () => {
+      const partialSchema = testSchema.partial();
+      const result = validateToolInput(partialSchema, { count: -1 }, 'test_tool');
+
+      expect(result.success).toBe(false);
+      expect(result.errorResponse.isError).toBe(true);
+    });
+  });
+
+  describe('refinement schemas', () => {
+    it('should handle schema refinements and return error', () => {
+      const refinedSchema = z
+        .object({
+          id: z.string().optional(),
+          slug: z.string().optional(),
+        })
+        .refine((data) => data.id || data.slug, {
+          message: 'Either id or slug is required',
+        });
+
+      const result = validateToolInput(refinedSchema, {}, 'test_tool');
+
+      expect(result.success).toBe(false);
+      expect(result.errorResponse.isError).toBe(true);
+      const errorObj = JSON.parse(result.errorResponse.content[0].text);
+      expect(errorObj.code).toBe('VALIDATION_ERROR');
+    });
+
+    it('should pass validation when refinement is satisfied', () => {
+      const refinedSchema = z
+        .object({
+          id: z.string().optional(),
+          slug: z.string().optional(),
+        })
+        .refine((data) => data.id || data.slug, {
+          message: 'Either id or slug is required',
+        });
+
+      const result = validateToolInput(refinedSchema, { id: 'abc123' }, 'test_tool');
+
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/src/utils/tempFileManager.js

@@ -0,0 +1,113 @@
+/**
+ * Temp File Manager
+ *
+ * Provides robust temp file tracking and cleanup with:
+ * - Async cleanup using fs.promises.unlink with await
+ * - Parallel cleanup using Promise.allSettled
+ * - Process exit handlers for orphaned file cleanup
+ */
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+
+// Global Set to track temp files for cleanup
+const tempFilesToCleanup = new Set();
+
+/**
+ * Track a temp file for cleanup
+ * @param {string|null|undefined} filePath - Path to track
+ */
+export const trackTempFile = (filePath) => {
+  if (filePath) {
+    tempFilesToCleanup.add(filePath);
+  }
+};
+
+/**
+ * Untrack a temp file (remove from cleanup tracking)
+ * @param {string|null|undefined} filePath - Path to untrack
+ */
+export const untrackTempFile = (filePath) => {
+  if (filePath) {
+    tempFilesToCleanup.delete(filePath);
+  }
+};
+
+/**
+ * Clean up a single temp file asynchronously
+ * @param {string|null|undefined} filePath - Path to delete
+ * @param {object} logger - Logger with warn method (default: console)
+ * @returns {Promise<void>}
+ */
+export const cleanupTempFile = async (filePath, logger = console) => {
+  if (!filePath) return;
+
+  try {
+    await fsPromises.unlink(filePath);
+  } catch (err) {
+    // ENOENT means file already deleted - not an error
+    if (err.code !== 'ENOENT') {
+      logger.warn?.('Failed to delete temp file', { file: filePath, error: err.message });
+    }
+  }
+  // Always untrack, even on error
+  untrackTempFile(filePath);
+};
+
+/**
+ * Clean up multiple temp files in parallel
+ * @param {Array<string|null|undefined>} filePaths - Paths to delete
+ * @param {object} logger - Logger with warn method (default: console)
+ * @returns {Promise<void>}
+ */
+export const cleanupTempFiles = async (filePaths, logger = console) => {
+  // Filter out falsy values and deduplicate
+  const uniquePaths = [...new Set(filePaths.filter(Boolean))];
+
+  if (uniquePaths.length === 0) return;
+
+  // Use Promise.allSettled to ensure all cleanups attempt even if some fail
+  await Promise.allSettled(uniquePaths.map((p) => cleanupTempFile(p, logger)));
+};
+
+/**
+ * Synchronously clean up all currently tracked files
+ * Used for process exit handlers where async is not possible
+ */
+export const cleanupAllTrackedFilesSync = () => {
+  for (const file of tempFilesToCleanup) {
+    try {
+      fs.unlinkSync(file);
+    } catch (_) {
+      // Ignore errors during exit cleanup
+    }
+  }
+  tempFilesToCleanup.clear();
+};
+
+/**
+ * Get a copy of currently tracked files (for testing)
+ * @returns {Set<string>}
+ */
+export const getTrackedFiles = () => new Set(tempFilesToCleanup);
+
+/**
+ * Clear all tracking (for testing)
+ */
+export const clearTracking = () => {
+  tempFilesToCleanup.clear();
+};
+
+// Register process exit handlers
+// 'exit' event fires synchronously, so we must use sync cleanup
+process.on('exit', cleanupAllTrackedFilesSync);
+
+// SIGINT (Ctrl+C) and SIGTERM need to call process.exit to trigger the 'exit' handler
+process.on('SIGINT', () => {
+  cleanupAllTrackedFilesSync();
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  cleanupAllTrackedFilesSync();
+  process.exit(0);
+});

package/src/utils/validation.js

@@ -0,0 +1,28 @@
+/**
+ * Validation utilities for MCP tool handlers
+ * Provides explicit Zod validation to ensure input is validated at handler entry points.
+ */
+import { ValidationError } from '../errors/index.js';
+
+/**
+ * Validates tool input against a Zod schema and returns a structured result.
+ *
+ * @param {import('zod').ZodSchema} schema - The Zod schema to validate against
+ * @param {unknown} input - The raw input to validate
+ * @param {string} toolName - The tool name for error context
+ * @returns {{ success: true, data: unknown } | { success: false, errorResponse: object }}
+ */
+export const validateToolInput = (schema, input, toolName) => {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const error = ValidationError.fromZod(result.error, toolName);
+    return {
+      success: false,
+      errorResponse: {
+        content: [{ type: 'text', text: JSON.stringify(error.toJSON(), null, 2) }],
+        isError: true,
+      },
+    };
+  }
+  return { success: true, data: result.data };
+};