@jgardner04/ghost-mcp-server 1.3.0 → 1.4.0

package/package.json

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

@@ -49,6 +49,7 @@ const mockValidateImageUrl = vi.fn();
 const mockCreateSecureAxiosConfig = vi.fn();
 const mockUpdatePost = vi.fn();
 const mockDeletePost = vi.fn();
+const mockSearchPosts = vi.fn();
 
 vi.mock('../services/ghostService.js', () => ({
   getPosts: (...args) => mockGetPosts(...args),
@@ -65,6 +66,7 @@ vi.mock('../services/postService.js', () => ({
 vi.mock('../services/ghostServiceImproved.js', () => ({
   updatePost: (...args) => mockUpdatePost(...args),
   deletePost: (...args) => mockDeletePost(...args),
+  searchPosts: (...args) => mockSearchPosts(...args),
 }));
 
 vi.mock('../services/imageProcessingService.js', () => ({
@@ -754,3 +756,154 @@ describe('mcp_server_improved - ghost_delete_post tool', () => {
     expect(result.content[0].text).toContain('Network error');
   });
 });
+
+describe('mcp_server_improved - ghost_search_posts tool', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    // Don't clear mockTools - they're registered once on module load
+    if (mockTools.size === 0) {
+      await import('../mcp_server_improved.js');
+    }
+  });
+
+  it('should register ghost_search_posts tool', () => {
+    expect(mockTools.has('ghost_search_posts')).toBe(true);
+  });
+
+  it('should have correct schema with required query and optional parameters', () => {
+    const tool = mockTools.get('ghost_search_posts');
+    expect(tool).toBeDefined();
+    expect(tool.description).toContain('Search');
+    expect(tool.schema).toBeDefined();
+    expect(tool.schema.query).toBeDefined();
+    expect(tool.schema.status).toBeDefined();
+    expect(tool.schema.limit).toBeDefined();
+  });
+
+  it('should search posts with query only', async () => {
+    const mockPosts = [
+      { id: '1', title: 'JavaScript Tips', slug: 'javascript-tips', status: 'published' },
+      { id: '2', title: 'JavaScript Tricks', slug: 'javascript-tricks', status: 'published' },
+    ];
+    mockSearchPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_search_posts');
+    const result = await tool.handler({ query: 'JavaScript' });
+
+    expect(mockSearchPosts).toHaveBeenCalledWith('JavaScript', {});
+    expect(result.content[0].text).toContain('JavaScript Tips');
+    expect(result.content[0].text).toContain('JavaScript Tricks');
+  });
+
+  it('should search posts with query and status filter', async () => {
+    const mockPosts = [
+      { id: '1', title: 'Published Post', slug: 'published-post', status: 'published' },
+    ];
+    mockSearchPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_search_posts');
+    await tool.handler({ query: 'test', status: 'published' });
+
+    expect(mockSearchPosts).toHaveBeenCalledWith('test', { status: 'published' });
+  });
+
+  it('should search posts with query and limit', async () => {
+    const mockPosts = [{ id: '1', title: 'Test Post', slug: 'test-post' }];
+    mockSearchPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_search_posts');
+    await tool.handler({ query: 'test', limit: 10 });
+
+    expect(mockSearchPosts).toHaveBeenCalledWith('test', { limit: 10 });
+  });
+
+  it('should validate limit is between 1 and 50', () => {
+    const tool = mockTools.get('ghost_search_posts');
+    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);
+  });
+
+  it('should validate status enum values', () => {
+    const tool = mockTools.get('ghost_search_posts');
+    const schema = tool.schema;
+
+    expect(schema.status).toBeDefined();
+    expect(() => schema.status.parse('invalid')).toThrow();
+    expect(schema.status.parse('published')).toBe('published');
+    expect(schema.status.parse('draft')).toBe('draft');
+    expect(schema.status.parse('scheduled')).toBe('scheduled');
+    expect(schema.status.parse('all')).toBe('all');
+  });
+
+  it('should pass all parameters combined', async () => {
+    const mockPosts = [{ id: '1', title: 'Test Post' }];
+    mockSearchPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_search_posts');
+    await tool.handler({
+      query: 'JavaScript',
+      status: 'published',
+      limit: 20,
+    });
+
+    expect(mockSearchPosts).toHaveBeenCalledWith('JavaScript', {
+      status: 'published',
+      limit: 20,
+    });
+  });
+
+  it('should handle errors from searchPosts', async () => {
+    mockSearchPosts.mockRejectedValue(new Error('Search query is required'));
+
+    const tool = mockTools.get('ghost_search_posts');
+    const result = await tool.handler({ query: '' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Search query is required');
+  });
+
+  it('should handle Ghost API errors', async () => {
+    mockSearchPosts.mockRejectedValue(new Error('Ghost API error'));
+
+    const tool = mockTools.get('ghost_search_posts');
+    const result = await tool.handler({ query: 'test' });
+
+    expect(result.isError).toBe(true);
+    expect(result.content[0].text).toContain('Ghost API error');
+  });
+
+  it('should return formatted JSON response', async () => {
+    const mockPosts = [
+      {
+        id: '1',
+        title: 'Test Post',
+        slug: 'test-post',
+        html: '<p>Content</p>',
+        status: 'published',
+      },
+    ];
+    mockSearchPosts.mockResolvedValue(mockPosts);
+
+    const tool = mockTools.get('ghost_search_posts');
+    const result = await tool.handler({ query: 'Test' });
+
+    expect(result.content).toBeDefined();
+    expect(result.content[0].type).toBe('text');
+    expect(result.content[0].text).toContain('"id": "1"');
+    expect(result.content[0].text).toContain('"title": "Test Post"');
+  });
+
+  it('should return empty array when no results found', async () => {
+    mockSearchPosts.mockResolvedValue([]);
+
+    const tool = mockTools.get('ghost_search_posts');
+    const result = await tool.handler({ query: 'nonexistent' });
+
+    expect(result.content[0].text).toBe('[]');
+    expect(result.isError).toBeUndefined();
+  });
+});

package/src/mcp_server_improved.js

@@ -376,6 +376,51 @@ server.tool(
   }
 );
 
+// Search Posts Tool
+server.tool(
+  'ghost_search_posts',
+  'Search for posts in Ghost CMS by query string with optional status filtering.',
+  {
+    query: z.string().describe('Search query to find in post titles.'),
+    status: z
+      .enum(['published', 'draft', 'scheduled', 'all'])
+      .optional()
+      .describe('Filter by post status. Default searches all statuses.'),
+    limit: z
+      .number()
+      .min(1)
+      .max(50)
+      .optional()
+      .describe('Maximum number of results (1-50). Default is 15.'),
+  },
+  async (input) => {
+    console.error(`Executing tool: ghost_search_posts with query: ${input.query}`);
+    try {
+      await loadServices();
+
+      // Build options object with provided parameters
+      const options = {};
+      if (input.status !== undefined) options.status = input.status;
+      if (input.limit !== undefined) options.limit = input.limit;
+
+      // Search posts using ghostServiceImproved
+      const ghostServiceImproved = await import('./services/ghostServiceImproved.js');
+      const posts = await ghostServiceImproved.searchPosts(input.query, options);
+      console.error(`Found ${posts.length} posts matching "${input.query}".`);
+
+      return {
+        content: [{ type: 'text', text: JSON.stringify(posts, null, 2) }],
+      };
+    } catch (error) {
+      console.error(`Error in ghost_search_posts:`, error);
+      return {
+        content: [{ type: 'text', text: `Error searching posts: ${error.message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
 // Update Post Tool
 server.tool(
   'ghost_update_post',

package/src/services/ghostServiceImproved.js

@@ -336,6 +336,37 @@ export async function getPosts(options = {}) {
   }
 }
 
+export async function searchPosts(query, options = {}) {
+  // Validate query
+  if (!query || query.trim().length === 0) {
+    throw new ValidationError('Search query is required');
+  }
+
+  // Sanitize query - escape special NQL characters to prevent injection
+  const sanitizedQuery = query.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+
+  // Build filter with fuzzy title match using Ghost NQL
+  const filterParts = [`title:~'${sanitizedQuery}'`];
+
+  // Add status filter if provided and not 'all'
+  if (options.status && options.status !== 'all') {
+    filterParts.push(`status:${options.status}`);
+  }
+
+  const searchOptions = {
+    limit: options.limit || 15,
+    include: 'tags,authors',
+    filter: filterParts.join('+'),
+  };
+
+  try {
+    return await handleApiRequest('posts', 'browse', {}, searchOptions);
+  } catch (error) {
+    console.error('Failed to search posts:', error);
+    throw error;
+  }
+}
+
 export async function uploadImage(imagePath) {
   // Validate input
   await validators.validateImagePath(imagePath);
@@ -495,6 +526,7 @@ export default {
   deletePost,
   getPost,
   getPosts,
+  searchPosts,
   uploadImage,
   createTag,
   getTags,