@jgardner04/ghost-mcp-server 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.6.0",
+  "version": "1.7.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

@@ -41,7 +41,10 @@ vi.mock('crypto', () => ({
 const mockGetPosts = vi.fn();
 const mockGetPost = vi.fn();
 const mockGetTags = vi.fn();
+const mockGetTag = vi.fn();
 const mockCreateTag = vi.fn();
+const mockUpdateTag = vi.fn();
+const mockDeleteTag = vi.fn();
 const mockUploadImage = vi.fn();
 const mockCreatePostService = vi.fn();
 const mockProcessImage = vi.fn();
@@ -67,6 +70,9 @@ vi.mock('../services/ghostServiceImproved.js', () => ({
   updatePost: (...args) => mockUpdatePost(...args),
   deletePost: (...args) => mockDeletePost(...args),
   searchPosts: (...args) => mockSearchPosts(...args),
+  getTag: (...args) => mockGetTag(...args),
+  updateTag: (...args) => mockUpdateTag(...args),
+  deleteTag: (...args) => mockDeleteTag(...args),
 }));
 
 vi.mock('../services/imageProcessingService.js', () => ({
@@ -907,3 +913,282 @@ describe('mcp_server_improved - ghost_search_posts tool', () => {
     expect(result.isError).toBeUndefined();
   });
 });
+
+describe('ghost_get_tag', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should be registered as a tool', () => {
+    expect(mockTools.has('ghost_get_tag')).toBe(true);
+    const tool = mockTools.get('ghost_get_tag');
+    expect(tool.name).toBe('ghost_get_tag');
+    expect(tool.description).toBeDefined();
+    expect(tool.schema).toBeDefined();
+    expect(tool.handler).toBeDefined();
+  });
+
+  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();
+  });
+
+  it('should retrieve tag by ID', async () => {
+    const mockTag = {
+      id: '123',
+      name: 'Test Tag',
+      slug: 'test-tag',
+      description: 'A test tag',
+    };
+    mockGetTag.mockResolvedValue(mockTag);
+
+    const tool = mockTools.get('ghost_get_tag');
+    const result = await tool.handler({ id: '123' });
+
+    expect(mockGetTag).toHaveBeenCalledWith('123', {});
+    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('"name": "Test Tag"');
+  });
+
+  it('should retrieve tag by slug', async () => {
+    const mockTag = {
+      id: '123',
+      name: 'Test Tag',
+      slug: 'test-tag',
+      description: 'A test tag',
+    };
+    mockGetTag.mockResolvedValue(mockTag);
+
+    const tool = mockTools.get('ghost_get_tag');
+    const result = await tool.handler({ slug: 'test-tag' });
+
+    expect(mockGetTag).toHaveBeenCalledWith('slug/test-tag', {});
+    expect(result.content[0].text).toContain('"slug": "test-tag"');
+  });
+
+  it('should support include parameter for post count', async () => {
+    const mockTag = {
+      id: '123',
+      name: 'Test Tag',
+      slug: 'test-tag',
+      count: { posts: 5 },
+    };
+    mockGetTag.mockResolvedValue(mockTag);
+
+    const tool = mockTools.get('ghost_get_tag');
+    const result = await tool.handler({ id: '123', include: 'count.posts' });
+
+    expect(mockGetTag).toHaveBeenCalledWith('123', { include: 'count.posts' });
+    expect(result.content[0].text).toContain('"count"');
+  });
+
+  it('should return error when neither id nor slug provided', async () => {
+    const tool = mockTools.get('ghost_get_tag');
+    const result = await tool.handler({});
+
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('Either id or slug must be provided');
+    expect(result.isError).toBe(true);
+  });
+
+  it('should handle not found error', async () => {
+    mockGetTag.mockRejectedValue(new Error('Tag not found'));
+
+    const tool = mockTools.get('ghost_get_tag');
+    const result = await tool.handler({ id: '999' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Tag not found');
+  });
+});
+
+describe('ghost_update_tag', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should be registered as a tool', () => {
+    expect(mockTools.has('ghost_update_tag')).toBe(true);
+    const tool = mockTools.get('ghost_update_tag');
+    expect(tool.name).toBe('ghost_update_tag');
+    expect(tool.description).toBeDefined();
+    expect(tool.schema).toBeDefined();
+    expect(tool.handler).toBeDefined();
+  });
+
+  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();
+  });
+
+  it('should update tag name', async () => {
+    const mockUpdatedTag = {
+      id: '123',
+      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' });
+
+    expect(mockUpdateTag).toHaveBeenCalledWith('123', { name: 'Updated Tag' });
+    expect(result.content[0].text).toContain('"name": "Updated Tag"');
+  });
+
+  it('should update tag description', async () => {
+    const mockUpdatedTag = {
+      id: '123',
+      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' });
+
+    expect(mockUpdateTag).toHaveBeenCalledWith('123', { description: 'New description' });
+    expect(result.content[0].text).toContain('"description": "New description"');
+  });
+
+  it('should update multiple fields at once', async () => {
+    const mockUpdatedTag = {
+      id: '123',
+      name: 'Updated Tag',
+      slug: 'updated-tag',
+      description: 'Updated description',
+      meta_title: 'Updated Meta',
+    };
+    mockUpdateTag.mockResolvedValue(mockUpdatedTag);
+
+    const tool = mockTools.get('ghost_update_tag');
+    await tool.handler({
+      id: '123',
+      name: 'Updated Tag',
+      description: 'Updated description',
+      meta_title: 'Updated Meta',
+    });
+
+    expect(mockUpdateTag).toHaveBeenCalledWith('123', {
+      name: 'Updated Tag',
+      description: 'Updated description',
+      meta_title: 'Updated Meta',
+    });
+  });
+
+  it('should update tag feature image', async () => {
+    const mockUpdatedTag = {
+      id: '123',
+      name: 'Test Tag',
+      feature_image: 'https://example.com/image.jpg',
+    };
+    mockUpdateTag.mockResolvedValue(mockUpdatedTag);
+
+    const tool = mockTools.get('ghost_update_tag');
+    await tool.handler({
+      id: '123',
+      feature_image: 'https://example.com/image.jpg',
+    });
+
+    expect(mockUpdateTag).toHaveBeenCalledWith('123', {
+      feature_image: 'https://example.com/image.jpg',
+    });
+  });
+
+  it('should return error when id is missing', async () => {
+    const tool = mockTools.get('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');
+  });
+
+  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: '' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Validation failed');
+  });
+
+  it('should handle not found error', async () => {
+    mockUpdateTag.mockRejectedValue(new Error('Tag not found'));
+
+    const tool = mockTools.get('ghost_update_tag');
+    const result = await tool.handler({ id: '999', name: 'Test' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Tag not found');
+  });
+});
+
+describe('ghost_delete_tag', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should be registered as a tool', () => {
+    expect(mockTools.has('ghost_delete_tag')).toBe(true);
+    const tool = mockTools.get('ghost_delete_tag');
+    expect(tool.name).toBe('ghost_delete_tag');
+    expect(tool.description).toBeDefined();
+    expect(tool.schema).toBeDefined();
+    expect(tool.handler).toBeDefined();
+  });
+
+  it('should have correct schema with id field', () => {
+    const tool = mockTools.get('ghost_delete_tag');
+    expect(tool.schema.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' });
+
+    expect(mockDeleteTag).toHaveBeenCalledWith('123');
+    expect(result.content[0].text).toContain('successfully deleted');
+    expect(result.isError).toBeUndefined();
+  });
+
+  it('should return error when id is missing', async () => {
+    const tool = mockTools.get('ghost_delete_tag');
+    const result = await tool.handler({});
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Tag ID is required');
+  });
+
+  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' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Tag not found');
+  });
+
+  it('should handle deletion error', async () => {
+    mockDeleteTag.mockRejectedValue(new Error('Failed to delete tag'));
+
+    const tool = mockTools.get('ghost_delete_tag');
+    const result = await tool.handler({ id: '123' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Failed to delete tag');
+  });
+});

package/src/mcp_server_improved.js

@@ -122,6 +122,129 @@ server.tool(
   }
 );
 
+// Get Tag Tool
+server.tool(
+  'ghost_get_tag',
+  'Retrieves a single tag from Ghost CMS by ID or slug.',
+  {
+    id: z.string().optional().describe('The ID of the tag to retrieve.'),
+    slug: z.string().optional().describe('The slug of the tag to retrieve.'),
+    include: z
+      .string()
+      .optional()
+      .describe('Additional resources to include (e.g., "count.posts").'),
+  },
+  async ({ id, slug, include }) => {
+    console.error(`Executing tool: ghost_get_tag`);
+    try {
+      if (!id && !slug) {
+        throw new Error('Either id or slug must be provided');
+      }
+
+      await loadServices();
+
+      // If slug is provided, use the slug/slug-name format
+      const identifier = slug ? `slug/${slug}` : id;
+      const options = include ? { include } : {};
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const tag = await ghostServiceImproved.getTag(identifier, options);
+      console.error(`Tag retrieved successfully. Tag ID: ${tag.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(tag, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_tag:`, error);
+      return {
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Update Tag Tool
+server.tool(
+  'ghost_update_tag',
+  'Updates an existing tag in Ghost CMS.',
+  {
+    id: z.string().describe('The ID of the tag to update.'),
+    name: z.string().optional().describe('The new name for the tag.'),
+    slug: z.string().optional().describe('The new slug for the tag.'),
+    description: z.string().optional().describe('The new description for the tag.'),
+    feature_image: z.string().url().optional().describe('URL of the feature image for the tag.'),
+    meta_title: z.string().optional().describe('SEO meta title for the tag.'),
+    meta_description: z.string().optional().describe('SEO meta description for the tag.'),
+  },
+  async ({ id, name, slug, description, feature_image, meta_title, meta_description }) => {
+    console.error(`Executing tool: ghost_update_tag for ID: ${id}`);
+    try {
+      if (!id) {
+        throw new Error('Tag ID is required');
+      }
+
+      await loadServices();
+
+      // Build update data object with only provided fields
+      const updateData = {};
+      if (name !== undefined) updateData.name = name;
+      if (slug !== undefined) updateData.slug = slug;
+      if (description !== undefined) updateData.description = description;
+      if (feature_image !== undefined) updateData.feature_image = feature_image;
+      if (meta_title !== undefined) updateData.meta_title = meta_title;
+      if (meta_description !== undefined) updateData.meta_description = meta_description;
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const updatedTag = await ghostServiceImproved.updateTag(id, updateData);
+      console.error(`Tag updated successfully. Tag ID: ${updatedTag.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(updatedTag, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_update_tag:`, error);
+      return {
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Delete Tag Tool
+server.tool(
+  'ghost_delete_tag',
+  'Deletes a tag from Ghost CMS by ID. This operation is permanent.',
+  {
+    id: z.string().describe('The ID of the tag to delete.'),
+  },
+  async ({ id }) => {
+    console.error(`Executing tool: ghost_delete_tag for ID: ${id}`);
+    try {
+      if (!id) {
+        throw new Error('Tag ID is required');
+      }
+
+      await loadServices();
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      await ghostServiceImproved.deleteTag(id);
+      console.error(`Tag deleted successfully. Tag ID: ${id}`);
+
+      return {
+        content: [{ type: 'text', text: `Tag with ID ${id} has been successfully deleted.` }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_delete_tag:`, error);
+      return {
+        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // Upload Image Tool
 server.tool(
   'ghost_upload_image',
@@ -982,7 +1105,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, ' +
+    'Available tools: ghost_get_tags, ghost_create_tag, ghost_get_tag, ghost_update_tag, ghost_delete_tag, ghost_upload_image, ' +
       'ghost_create_post, ghost_get_posts, ghost_get_post, ghost_search_posts, ghost_update_post, ghost_delete_post, ' +
       'ghost_get_pages, ghost_get_page, ghost_create_page, ghost_update_page, ghost_delete_page, ghost_search_pages, ' +
       'ghost_get_newsletters, ghost_get_newsletter, ghost_create_newsletter, ghost_update_newsletter, ghost_delete_newsletter'

package/src/services/ghostServiceImproved.js

@@ -173,6 +173,27 @@ const validators = {
     }
   },
 
+  validateTagUpdateData(updateData) {
+    const errors = [];
+
+    // Name is optional in updates, but if provided, it cannot be empty
+    if (updateData.name !== undefined && updateData.name.trim().length === 0) {
+      errors.push({ field: 'name', message: 'Tag name cannot be empty' });
+    }
+
+    // Validate slug format if provided
+    if (updateData.slug && !/^[a-z0-9-]+$/.test(updateData.slug)) {
+      errors.push({
+        field: 'slug',
+        message: 'Slug must contain only lowercase letters, numbers, and hyphens',
+      });
+    }
+
+    if (errors.length > 0) {
+      throw new ValidationError('Tag update validation failed', errors);
+    }
+  },
+
   async validateImagePath(imagePath) {
     if (!imagePath || typeof imagePath !== 'string') {
       throw new ValidationError('Image path is required and must be a string');
@@ -693,13 +714,13 @@ export async function getTags(name) {
   }
 }
 
-export async function getTag(tagId) {
+export async function getTag(tagId, options = {}) {
   if (!tagId) {
     throw new ValidationError('Tag ID is required');
   }
 
   try {
-    return await handleApiRequest('tags', 'read', { id: tagId });
+    return await handleApiRequest('tags', 'read', { id: tagId }, options);
   } catch (error) {
     if (error instanceof GhostAPIError && error.ghostStatusCode === 404) {
       throw new NotFoundError('Tag', tagId);
@@ -713,7 +734,7 @@ export async function updateTag(tagId, updateData) {
     throw new ValidationError('Tag ID is required for update');
   }
 
-  validators.validateTagData({ name: 'dummy', ...updateData }); // Validate update data
+  validators.validateTagUpdateData(updateData); // Validate update data
 
   try {
     const existingTag = await getTag(tagId);