@jgardner04/ghost-mcp-server 1.7.0 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgardner04/ghost-mcp-server",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "A Model Context Protocol (MCP) server for interacting with Ghost CMS via the Admin API",
   "author": "Jonathan Gardner",
   "type": "module",

package/src/mcp_server_improved.js

@@ -903,6 +903,122 @@ server.tool(
   }
 );
 
+// =============================================================================
+// MEMBER TOOLS
+// Member management for Ghost CMS subscribers
+// =============================================================================
+
+// Create Member Tool
+server.tool(
+  'ghost_create_member',
+  'Creates a new member (subscriber) in Ghost CMS.',
+  {
+    email: z.string().email().describe('The email address of the member (required).'),
+    name: z.string().optional().describe('The name of the member.'),
+    note: z.string().optional().describe('A note about the member.'),
+    labels: z.array(z.string()).optional().describe('List of label names to assign to the member.'),
+    newsletters: z
+      .array(z.object({ id: z.string() }))
+      .optional()
+      .describe('List of newsletter objects with id field to subscribe the member to.'),
+    subscribed: z
+      .boolean()
+      .optional()
+      .describe('Whether the member is subscribed to emails. Defaults to true.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_create_member with email: ${input.email}`);
+    try {
+      await loadServices();
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const createdMember = await ghostServiceImproved.createMember(input);
+      console.error(`Member created successfully. Member ID: ${createdMember.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(createdMember, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_create_member:`, error);
+      return {
+        content: [{ type: 'text', text: `Error creating member: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Update Member Tool
+server.tool(
+  'ghost_update_member',
+  'Updates an existing member in Ghost CMS. All fields except id are optional.',
+  {
+    id: z.string().describe('The ID of the member to update.'),
+    email: z.string().email().optional().describe('New email address for the member.'),
+    name: z.string().optional().describe('New name for the member.'),
+    note: z.string().optional().describe('New note about the member.'),
+    labels: z
+      .array(z.string())
+      .optional()
+      .describe('New list of label names to assign to the member.'),
+    newsletters: z
+      .array(z.object({ id: z.string() }))
+      .optional()
+      .describe('New list of newsletter objects with id field to subscribe the member to.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_update_member for member ID: ${input.id}`);
+    try {
+      await loadServices();
+
+      const { id, ...updateData } = input;
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const updatedMember = await ghostServiceImproved.updateMember(id, updateData);
+      console.error(`Member updated successfully. Member ID: ${updatedMember.id}`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(updatedMember, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_update_member:`, error);
+      return {
+        content: [{ type: 'text', text: `Error updating member: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Delete Member Tool
+server.tool(
+  'ghost_delete_member',
+  'Deletes a member from Ghost CMS by ID. This operation is permanent and cannot be undone.',
+  {
+    id: z.string().describe('The ID of the member to delete.'),
+  },
+  async ({ id }) => {
+    console.error(`Executing tool: ghost_delete_member for member ID: ${id}`);
+    try {
+      await loadServices();
+
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      await ghostServiceImproved.deleteMember(id);
+      console.error(`Member deleted successfully. Member ID: ${id}`);
+
+      return {
+        content: [{ type: 'text', text: `Member ${id} has been successfully deleted.` }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_delete_member:`, error);
+      return {
+        content: [{ type: 'text', text: `Error deleting member: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // =============================================================================
 // NEWSLETTER TOOLS
 // =============================================================================
@@ -1108,6 +1224,7 @@ async function main() {
     '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_create_member, ghost_update_member, ghost_delete_member, ' +
       'ghost_get_newsletters, ghost_get_newsletter, ghost_create_newsletter, ghost_update_newsletter, ghost_delete_newsletter'
   );
 }

package/src/schemas/__tests__/common.test.js

@@ -0,0 +1,275 @@
+import { describe, it, expect } from 'vitest';
+import {
+  emailSchema,
+  urlSchema,
+  isoDateSchema,
+  slugSchema,
+  ghostIdSchema,
+  nqlFilterSchema,
+  limitSchema,
+  pageSchema,
+  postStatusSchema,
+  visibilitySchema,
+  htmlContentSchema,
+  titleSchema,
+  excerptSchema,
+  metaTitleSchema,
+  metaDescriptionSchema,
+  featuredSchema,
+  featureImageSchema,
+  featureImageAltSchema,
+  tagNameSchema,
+} from '../common.js';
+
+describe('Common Schemas', () => {
+  describe('emailSchema', () => {
+    it('should accept valid email addresses', () => {
+      expect(() => emailSchema.parse('test@example.com')).not.toThrow();
+      expect(() => emailSchema.parse('user.name+tag@example.co.uk')).not.toThrow();
+    });
+
+    it('should reject invalid email addresses', () => {
+      expect(() => emailSchema.parse('not-an-email')).toThrow();
+      expect(() => emailSchema.parse('missing@domain')).toThrow();
+      expect(() => emailSchema.parse('@example.com')).toThrow();
+    });
+  });
+
+  describe('urlSchema', () => {
+    it('should accept valid URLs', () => {
+      expect(() => urlSchema.parse('https://example.com')).not.toThrow();
+      expect(() => urlSchema.parse('http://localhost:3000/path')).not.toThrow();
+    });
+
+    it('should reject invalid URLs', () => {
+      expect(() => urlSchema.parse('not-a-url')).toThrow();
+      expect(() => urlSchema.parse('://invalid')).toThrow();
+    });
+  });
+
+  describe('isoDateSchema', () => {
+    it('should accept valid ISO 8601 datetime strings', () => {
+      expect(() => isoDateSchema.parse('2024-01-15T10:30:00Z')).not.toThrow();
+      expect(() => isoDateSchema.parse('2024-01-15T10:30:00.000Z')).not.toThrow();
+    });
+
+    it('should reject invalid datetime strings', () => {
+      expect(() => isoDateSchema.parse('2024-01-15')).toThrow();
+      expect(() => isoDateSchema.parse('not-a-date')).toThrow();
+    });
+  });
+
+  describe('slugSchema', () => {
+    it('should accept valid slugs', () => {
+      expect(() => slugSchema.parse('my-blog-post')).not.toThrow();
+      expect(() => slugSchema.parse('post-123')).not.toThrow();
+      expect(() => slugSchema.parse('simple')).not.toThrow();
+    });
+
+    it('should reject invalid slugs', () => {
+      expect(() => slugSchema.parse('My Post')).toThrow(); // spaces
+      expect(() => slugSchema.parse('post_123')).toThrow(); // underscores
+      expect(() => slugSchema.parse('Post-123')).toThrow(); // uppercase
+      expect(() => slugSchema.parse('post!')).toThrow(); // special chars
+    });
+  });
+
+  describe('ghostIdSchema', () => {
+    it('should accept valid Ghost IDs', () => {
+      expect(() => ghostIdSchema.parse('507f1f77bcf86cd799439011')).not.toThrow();
+      expect(() => ghostIdSchema.parse('abcdef1234567890abcdef12')).not.toThrow();
+    });
+
+    it('should reject invalid Ghost IDs', () => {
+      expect(() => ghostIdSchema.parse('short')).toThrow(); // too short
+      expect(() => ghostIdSchema.parse('507f1f77bcf86cd799439011abc')).toThrow(); // too long
+      expect(() => ghostIdSchema.parse('507f1f77bcf86cd79943901G')).toThrow(); // invalid char
+      expect(() => ghostIdSchema.parse('507F1F77BCF86CD799439011')).toThrow(); // uppercase
+    });
+  });
+
+  describe('nqlFilterSchema', () => {
+    it('should accept valid NQL filter strings', () => {
+      expect(() => nqlFilterSchema.parse('status:published')).not.toThrow();
+      expect(() => nqlFilterSchema.parse('tag:news+featured:true')).not.toThrow();
+      expect(() => nqlFilterSchema.parse("author:'John Doe'")).not.toThrow();
+    });
+
+    it('should reject NQL strings with disallowed characters', () => {
+      expect(() => nqlFilterSchema.parse('status;DROP TABLE')).toThrow();
+      expect(() => nqlFilterSchema.parse('test&invalid')).toThrow();
+    });
+
+    it('should allow undefined/optional', () => {
+      expect(() => nqlFilterSchema.parse(undefined)).not.toThrow();
+    });
+  });
+
+  describe('limitSchema', () => {
+    it('should accept valid limits', () => {
+      expect(limitSchema.parse(1)).toBe(1);
+      expect(limitSchema.parse(50)).toBe(50);
+      expect(limitSchema.parse(100)).toBe(100);
+    });
+
+    it('should reject invalid limits', () => {
+      expect(() => limitSchema.parse(0)).toThrow();
+      expect(() => limitSchema.parse(101)).toThrow();
+      expect(() => limitSchema.parse(-1)).toThrow();
+      expect(() => limitSchema.parse(1.5)).toThrow();
+    });
+
+    it('should use default value', () => {
+      expect(limitSchema.parse(undefined)).toBe(15);
+    });
+  });
+
+  describe('pageSchema', () => {
+    it('should accept valid page numbers', () => {
+      expect(pageSchema.parse(1)).toBe(1);
+      expect(pageSchema.parse(100)).toBe(100);
+    });
+
+    it('should reject invalid page numbers', () => {
+      expect(() => pageSchema.parse(0)).toThrow();
+      expect(() => pageSchema.parse(-1)).toThrow();
+      expect(() => pageSchema.parse(1.5)).toThrow();
+    });
+
+    it('should use default value', () => {
+      expect(pageSchema.parse(undefined)).toBe(1);
+    });
+  });
+
+  describe('postStatusSchema', () => {
+    it('should accept valid statuses', () => {
+      expect(() => postStatusSchema.parse('draft')).not.toThrow();
+      expect(() => postStatusSchema.parse('published')).not.toThrow();
+      expect(() => postStatusSchema.parse('scheduled')).not.toThrow();
+    });
+
+    it('should reject invalid statuses', () => {
+      expect(() => postStatusSchema.parse('invalid')).toThrow();
+      expect(() => postStatusSchema.parse('DRAFT')).toThrow();
+    });
+  });
+
+  describe('visibilitySchema', () => {
+    it('should accept valid visibility values', () => {
+      expect(() => visibilitySchema.parse('public')).not.toThrow();
+      expect(() => visibilitySchema.parse('members')).not.toThrow();
+      expect(() => visibilitySchema.parse('paid')).not.toThrow();
+      expect(() => visibilitySchema.parse('tiers')).not.toThrow();
+    });
+
+    it('should reject invalid visibility values', () => {
+      expect(() => visibilitySchema.parse('private')).toThrow();
+      expect(() => visibilitySchema.parse('PUBLIC')).toThrow();
+    });
+  });
+
+  describe('htmlContentSchema', () => {
+    it('should accept non-empty HTML strings', () => {
+      expect(() => htmlContentSchema.parse('<p>Hello World</p>')).not.toThrow();
+      expect(() => htmlContentSchema.parse('Plain text')).not.toThrow();
+    });
+
+    it('should reject empty strings', () => {
+      expect(() => htmlContentSchema.parse('')).toThrow();
+    });
+  });
+
+  describe('titleSchema', () => {
+    it('should accept valid titles', () => {
+      expect(() => titleSchema.parse('My Blog Post')).not.toThrow();
+      expect(() => titleSchema.parse('A'.repeat(255))).not.toThrow();
+    });
+
+    it('should reject invalid titles', () => {
+      expect(() => titleSchema.parse('')).toThrow();
+      expect(() => titleSchema.parse('A'.repeat(256))).toThrow();
+    });
+  });
+
+  describe('excerptSchema', () => {
+    it('should accept valid excerpts', () => {
+      expect(() => excerptSchema.parse('A short description')).not.toThrow();
+      expect(() => excerptSchema.parse('A'.repeat(500))).not.toThrow();
+      expect(() => excerptSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject too long excerpts', () => {
+      expect(() => excerptSchema.parse('A'.repeat(501))).toThrow();
+    });
+  });
+
+  describe('metaTitleSchema', () => {
+    it('should accept valid meta titles', () => {
+      expect(() => metaTitleSchema.parse('SEO Title')).not.toThrow();
+      expect(() => metaTitleSchema.parse('A'.repeat(300))).not.toThrow();
+      expect(() => metaTitleSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject too long meta titles', () => {
+      expect(() => metaTitleSchema.parse('A'.repeat(301))).toThrow();
+    });
+  });
+
+  describe('metaDescriptionSchema', () => {
+    it('should accept valid meta descriptions', () => {
+      expect(() => metaDescriptionSchema.parse('SEO description')).not.toThrow();
+      expect(() => metaDescriptionSchema.parse('A'.repeat(500))).not.toThrow();
+      expect(() => metaDescriptionSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject too long meta descriptions', () => {
+      expect(() => metaDescriptionSchema.parse('A'.repeat(501))).toThrow();
+    });
+  });
+
+  describe('featuredSchema', () => {
+    it('should accept boolean values', () => {
+      expect(featuredSchema.parse(true)).toBe(true);
+      expect(featuredSchema.parse(false)).toBe(false);
+    });
+
+    it('should use default value', () => {
+      expect(featuredSchema.parse(undefined)).toBe(false);
+    });
+  });
+
+  describe('featureImageSchema', () => {
+    it('should accept valid image URLs', () => {
+      expect(() => featureImageSchema.parse('https://example.com/image.jpg')).not.toThrow();
+      expect(() => featureImageSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject invalid URLs', () => {
+      expect(() => featureImageSchema.parse('not-a-url')).toThrow();
+    });
+  });
+
+  describe('featureImageAltSchema', () => {
+    it('should accept valid alt text', () => {
+      expect(() => featureImageAltSchema.parse('Image description')).not.toThrow();
+      expect(() => featureImageAltSchema.parse('A'.repeat(125))).not.toThrow();
+      expect(() => featureImageAltSchema.parse(undefined)).not.toThrow();
+    });
+
+    it('should reject too long alt text', () => {
+      expect(() => featureImageAltSchema.parse('A'.repeat(126))).toThrow();
+    });
+  });
+
+  describe('tagNameSchema', () => {
+    it('should accept valid tag names', () => {
+      expect(() => tagNameSchema.parse('Technology')).not.toThrow();
+      expect(() => tagNameSchema.parse('A'.repeat(191))).not.toThrow();
+    });
+
+    it('should reject invalid tag names', () => {
+      expect(() => tagNameSchema.parse('')).toThrow();
+      expect(() => tagNameSchema.parse('A'.repeat(192))).toThrow();
+    });
+  });
+});

package/src/schemas/__tests__/postSchemas.test.js

@@ -0,0 +1,194 @@
+import { describe, it, expect } from 'vitest';
+import {
+  createPostSchema,
+  updatePostSchema,
+  postQuerySchema,
+  postIdSchema,
+  postOutputSchema,
+} from '../postSchemas.js';
+
+describe('Post Schemas', () => {
+  describe('createPostSchema', () => {
+    it('should accept valid post creation data', () => {
+      const validPost = {
+        title: 'My Blog Post',
+        html: '<p>This is the content of the post.</p>',
+        status: 'draft',
+      };
+
+      expect(() => createPostSchema.parse(validPost)).not.toThrow();
+    });
+
+    it('should accept minimal post creation data', () => {
+      const minimalPost = {
+        title: 'Title',
+        html: '<p>Content</p>',
+      };
+
+      const result = createPostSchema.parse(minimalPost);
+      expect(result.title).toBe('Title');
+      expect(result.status).toBe('draft'); // default
+      expect(result.visibility).toBe('public'); // default
+      expect(result.featured).toBe(false); // default
+    });
+
+    it('should accept post with all fields', () => {
+      const fullPost = {
+        title: 'Complete Post',
+        html: '<p>Full content</p>',
+        slug: 'complete-post',
+        status: 'published',
+        visibility: 'members',
+        featured: true,
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Image description',
+        feature_image_caption: 'Photo caption',
+        excerpt: 'Brief summary',
+        custom_excerpt: 'Custom summary',
+        meta_title: 'SEO Title',
+        meta_description: 'SEO Description',
+        tags: ['tech', 'news'],
+        authors: ['author@example.com'],
+        published_at: '2024-01-15T10:30:00.000Z',
+        canonical_url: 'https://example.com/original',
+      };
+
+      expect(() => createPostSchema.parse(fullPost)).not.toThrow();
+    });
+
+    it('should reject post without title', () => {
+      const invalidPost = {
+        html: '<p>Content</p>',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+
+    it('should reject post without html', () => {
+      const invalidPost = {
+        title: 'Title',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+
+    it('should reject post with invalid status', () => {
+      const invalidPost = {
+        title: 'Title',
+        html: '<p>Content</p>',
+        status: 'invalid',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+
+    it('should reject post with too long title', () => {
+      const invalidPost = {
+        title: 'A'.repeat(256),
+        html: '<p>Content</p>',
+      };
+
+      expect(() => createPostSchema.parse(invalidPost)).toThrow();
+    });
+  });
+
+  describe('updatePostSchema', () => {
+    it('should accept partial post updates', () => {
+      const update = {
+        title: 'Updated Title',
+      };
+
+      expect(() => updatePostSchema.parse(update)).not.toThrow();
+    });
+
+    it('should accept empty update object', () => {
+      expect(() => updatePostSchema.parse({})).not.toThrow();
+    });
+  });
+
+  describe('postQuerySchema', () => {
+    it('should accept valid query parameters', () => {
+      const query = {
+        limit: 20,
+        page: 2,
+        filter: 'status:published+featured:true',
+      };
+
+      expect(() => postQuerySchema.parse(query)).not.toThrow();
+    });
+
+    it('should accept query with include parameter', () => {
+      const query = {
+        include: 'tags,authors',
+      };
+
+      expect(() => postQuerySchema.parse(query)).not.toThrow();
+    });
+
+    it('should accept empty query object', () => {
+      const result = postQuerySchema.parse({});
+      expect(result).toBeDefined();
+      // Note: optional fields with defaults don't apply when field is omitted
+    });
+  });
+
+  describe('postIdSchema', () => {
+    it('should accept valid Ghost ID', () => {
+      const validId = {
+        id: '507f1f77bcf86cd799439011',
+      };
+
+      expect(() => postIdSchema.parse(validId)).not.toThrow();
+    });
+
+    it('should reject invalid Ghost ID', () => {
+      const invalidId = {
+        id: 'invalid-id',
+      };
+
+      expect(() => postIdSchema.parse(invalidId)).toThrow();
+    });
+  });
+
+  describe('postOutputSchema', () => {
+    it('should accept valid post output from Ghost API', () => {
+      const apiPost = {
+        id: '507f1f77bcf86cd799439011',
+        uuid: '550e8400-e29b-41d4-a716-446655440000',
+        title: 'My Post',
+        slug: 'my-post',
+        html: '<p>Content</p>',
+        comment_id: null,
+        feature_image: 'https://example.com/image.jpg',
+        feature_image_alt: 'Alt text',
+        feature_image_caption: 'Caption',
+        featured: false,
+        status: 'published',
+        visibility: 'public',
+        created_at: '2024-01-15T10:30:00.000Z',
+        updated_at: '2024-01-15T10:30:00.000Z',
+        published_at: '2024-01-15T10:30:00.000Z',
+        custom_excerpt: 'Excerpt',
+        codeinjection_head: null,
+        codeinjection_foot: null,
+        custom_template: null,
+        canonical_url: null,
+        url: 'https://example.com/my-post',
+        excerpt: 'Auto excerpt',
+        reading_time: 5,
+        email_only: false,
+        og_image: null,
+        og_title: null,
+        og_description: null,
+        twitter_image: null,
+        twitter_title: null,
+        twitter_description: null,
+        meta_title: null,
+        meta_description: null,
+        email_subject: null,
+      };
+
+      expect(() => postOutputSchema.parse(apiPost)).not.toThrow();
+    });
+  });
+});