@jgardner04/ghost-mcp-server 1.5.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.5.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',
@@ -780,6 +903,198 @@ server.tool(
   }
 );
 
+// =============================================================================
+// NEWSLETTER TOOLS
+// =============================================================================
+
+// Get Newsletters Tool
+server.tool(
+  'ghost_get_newsletters',
+  'Retrieves a list of newsletters from Ghost CMS with optional filtering.',
+  {
+    limit: z
+      .number()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe('Number of newsletters to retrieve (1-100). Default is all.'),
+    filter: z.string().optional().describe('Ghost NQL filter string for advanced filtering.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_get_newsletters`);
+    try {
+      await loadServices();
+
+      const options = {};
+      if (input.limit !== undefined) options.limit = input.limit;
+      if (input.filter !== undefined) options.filter = input.filter;
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const newsletters = await ghostServiceImproved.getNewsletters(options);
+      console.error(`Retrieved ${newsletters.length} newsletters from Ghost.`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(newsletters, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_newsletters:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving newsletters: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Get Newsletter Tool
+server.tool(
+  'ghost_get_newsletter',
+  'Retrieves a single newsletter from Ghost CMS by ID.',
+  {
+    id: z.string().describe('The ID of the newsletter to retrieve.'),
+  },
+  async ({ id }) => {
+    console.error(`Executing tool: ghost_get_newsletter for ID: ${id}`);
+    try {
+      await loadServices();
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const newsletter = await ghostServiceImproved.getNewsletter(id);
+      console.error(`Retrieved newsletter: ${newsletter.name} (ID: ${newsletter.id})`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(newsletter, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_get_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error retrieving newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Create Newsletter Tool
+server.tool(
+  'ghost_create_newsletter',
+  'Creates a new newsletter in Ghost CMS with customizable sender settings and display options.',
+  {
+    name: z.string().describe('The name of the newsletter.'),
+    description: z.string().optional().describe('A description for the newsletter.'),
+    sender_name: z.string().optional().describe('The sender name for newsletter emails.'),
+    sender_email: z
+      .string()
+      .email()
+      .optional()
+      .describe('The sender email address for newsletter emails.'),
+    sender_reply_to: z
+      .enum(['newsletter', 'support'])
+      .optional()
+      .describe('Reply-to address setting. Options: newsletter, support.'),
+    subscribe_on_signup: z
+      .boolean()
+      .optional()
+      .describe('Whether new members are automatically subscribed to this newsletter on signup.'),
+    show_header_icon: z
+      .boolean()
+      .optional()
+      .describe('Whether to show the site icon in the newsletter header.'),
+    show_header_title: z
+      .boolean()
+      .optional()
+      .describe('Whether to show the site title in the newsletter header.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_create_newsletter with name: ${input.name}`);
+    try {
+      await loadServices();
+
+      const newsletterService = await import('./services/newsletterService.js');
+      const createdNewsletter = await newsletterService.createNewsletterService(input);
+      console.error(`Newsletter created successfully. Newsletter ID: ${createdNewsletter.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(createdNewsletter, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_create_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error creating newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Update Newsletter Tool
+server.tool(
+  'ghost_update_newsletter',
+  'Updates an existing newsletter in Ghost CMS. Can update name, description, sender settings, and display options.',
+  {
+    id: z.string().describe('The ID of the newsletter to update.'),
+    name: z.string().optional().describe('New name for the newsletter.'),
+    description: z.string().optional().describe('New description for the newsletter.'),
+    sender_name: z.string().optional().describe('New sender name for newsletter emails.'),
+    sender_email: z.string().email().optional().describe('New sender email address.'),
+    subscribe_on_signup: z
+      .boolean()
+      .optional()
+      .describe('Whether new members are automatically subscribed to this newsletter on signup.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_update_newsletter for newsletter ID: ${input.id}`);
+    try {
+      await loadServices();
+
+      const { id, ...updateData } = input;
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const updatedNewsletter = await ghostServiceImproved.updateNewsletter(id, updateData);
+      console.error(`Newsletter updated successfully. Newsletter ID: ${updatedNewsletter.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(updatedNewsletter, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_update_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error updating newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Delete Newsletter Tool
+server.tool(
+  'ghost_delete_newsletter',
+  'Deletes a newsletter from Ghost CMS by ID. This operation is permanent and cannot be undone.',
+  {
+    id: z.string().describe('The ID of the newsletter to delete.'),
+  },
+  async ({ id }) => {
+    console.error(`Executing tool: ghost_delete_newsletter for newsletter ID: ${id}`);
+    try {
+      await loadServices();
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      await ghostServiceImproved.deleteNewsletter(id);
+      console.error(`Newsletter deleted successfully. Newsletter ID: ${id}`);
+
+      return {
+        content: [{ type: 'text', text: `Newsletter ${id} has been successfully deleted.` }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_delete_newsletter:`, error);
+      return {
+        content: [{ type: 'text', text: `Error deleting newsletter: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // --- Main Entry Point ---
 
 async function main() {
@@ -790,9 +1105,10 @@ 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_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'
   );
 }