@dalcontak/blogger-mcp-server 1.0.0 → 1.0.2

package/src/server.ts

@@ -1,43 +1,37 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { ServerConfig, ToolDefinition } from './types';
+import { ServerConfig, ToolDefinition, ToolResult } from './types';
 import { BloggerService } from './bloggerService';
 import { z } from 'zod';
 
-/**
- * Creates the tool definitions for the Blogger MCP server
- * @param bloggerService Blogger service to interact with the API
- * @returns Array of tool definitions
- */
+function createToolHandler(
+  toolName: string,
+  fn: () => Promise<unknown>
+): () => Promise<ToolResult> {
+  return async () => {
+    try {
+      const result = await fn();
+      return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+      };
+    } catch (error) {
+      console.error(`Error in ${toolName}:`, error);
+      return {
+        content: [{ type: 'text', text: `Error in ${toolName}: ${error}` }],
+        isError: true
+      };
+    }
+  };
+}
+
 export function createToolDefinitions(bloggerService: BloggerService): ToolDefinition[] {
   return [
     {
       name: 'list_blogs',
       description: 'Lists all accessible blogs',
       args: z.object({}),
-      handler: async (_args, _extra) => {
-        try {
-          const blogs = await bloggerService.listBlogs();
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ blogs }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error('Error fetching blogs:', error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error fetching blogs: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: createToolHandler('list_blogs', () => {
+        return bloggerService.listBlogs().then(blogs => ({ blogs }));
+      })
     },
     {
       name: 'get_blog',
@@ -45,30 +39,9 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
       args: z.object({
         blogId: z.string().describe('Blog ID')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const blog = await bloggerService.getBlog(args.blogId);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ blog }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error fetching blog ${args.blogId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error fetching blog: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('get_blog', () => {
+        return bloggerService.getBlog(args.blogId).then(blog => ({ blog }));
+      })()
     },
     {
       name: 'get_blog_by_url',
@@ -76,49 +49,9 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
       args: z.object({
         url: z.string().describe('Blog URL')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const blog = await bloggerService.getBlogByUrl(args.url);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ blog }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error fetching blog by URL ${args.url}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error fetching blog by URL: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    },
-    {
-      name: 'create_blog',
-      description: 'Creates a new blog (not supported by the Blogger API)',
-      args: z.object({
-        name: z.string().describe('Blog name'),
-        description: z.string().optional().describe('Blog description')
-      }),
-      handler: async (_args, _extra) => {
-        return {
-          content: [
-            {
-              type: 'text',
-              text: 'Blog creation is not supported by the Blogger API. Please create a blog via the Blogger web interface.'
-            }
-          ],
-          isError: true
-        };
-      }
+      handler: (args) => createToolHandler('get_blog_by_url', () => {
+        return bloggerService.getBlogByUrl(args.url).then(blog => ({ blog }));
+      })()
     },
     {
       name: 'list_posts',
@@ -127,30 +60,9 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
         blogId: z.string().describe('Blog ID'),
         maxResults: z.number().optional().describe('Maximum number of results to return')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const posts = await bloggerService.listPosts(args.blogId, args.maxResults);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ posts }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error fetching posts for blog ${args.blogId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error fetching posts: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('list_posts', () => {
+        return bloggerService.listPosts(args.blogId, args.maxResults).then(posts => ({ posts }));
+      })()
     },
     {
       name: 'search_posts',
@@ -160,30 +72,9 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
         query: z.string().describe('Search term'),
         maxResults: z.number().optional().describe('Maximum number of results to return')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const posts = await bloggerService.searchPosts(args.blogId, args.query, args.maxResults);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ posts }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error searching posts in blog ${args.blogId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error searching posts: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('search_posts', () => {
+        return bloggerService.searchPosts(args.blogId, args.query, args.maxResults).then(posts => ({ posts }));
+      })()
     },
     {
       name: 'get_post',
@@ -192,30 +83,9 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
         blogId: z.string().describe('Blog ID'),
         postId: z.string().describe('Post ID')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const post = await bloggerService.getPost(args.blogId, args.postId);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ post }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error fetching post ${args.postId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error fetching post: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('get_post', () => {
+        return bloggerService.getPost(args.blogId, args.postId).then(post => ({ post }));
+      })()
     },
     {
       name: 'create_post',
@@ -226,34 +96,13 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
         content: z.string().describe('Post content'),
         labels: z.array(z.string()).optional().describe('Labels to associate with the post')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const post = await bloggerService.createPost(args.blogId, { 
-            title: args.title, 
-            content: args.content, 
-            labels: args.labels 
-          });
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ post }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error creating post in blog ${args.blogId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error creating post: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('create_post', () => {
+        return bloggerService.createPost(args.blogId, {
+          title: args.title,
+          content: args.content,
+          labels: args.labels
+        }).then(post => ({ post }));
+      })()
     },
     {
       name: 'update_post',
@@ -265,34 +114,13 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
         content: z.string().optional().describe('New post content'),
         labels: z.array(z.string()).optional().describe('New labels to associate with the post')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const post = await bloggerService.updatePost(args.blogId, args.postId, { 
-            title: args.title, 
-            content: args.content, 
-            labels: args.labels 
-          });
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ post }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error updating post ${args.postId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error updating post: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('update_post', () => {
+        return bloggerService.updatePost(args.blogId, args.postId, {
+          title: args.title,
+          content: args.content,
+          labels: args.labels
+        }).then(post => ({ post }));
+      })()
     },
     {
       name: 'delete_post',
@@ -301,30 +129,9 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
         blogId: z.string().describe('Blog ID'),
         postId: z.string().describe('Post ID')
       }),
-      handler: async (args, _extra) => {
-        try {
-          await bloggerService.deletePost(args.blogId, args.postId);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ success: true }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error deleting post ${args.postId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error deleting post: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('delete_post', () => {
+        return bloggerService.deletePost(args.blogId, args.postId).then(() => ({ success: true }));
+      })()
     },
     {
       name: 'list_labels',
@@ -332,30 +139,9 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
       args: z.object({
         blogId: z.string().describe('Blog ID')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const labels = await bloggerService.listLabels(args.blogId);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ labels }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error fetching labels for blog ${args.blogId}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error fetching labels: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('list_labels', () => {
+        return bloggerService.listLabels(args.blogId).then(labels => ({ labels: labels.items }));
+      })()
     },
     {
       name: 'get_label',
@@ -364,79 +150,24 @@ export function createToolDefinitions(bloggerService: BloggerService): ToolDefin
         blogId: z.string().describe('Blog ID'),
         labelName: z.string().describe('Label name')
       }),
-      handler: async (args, _extra) => {
-        try {
-          const label = await bloggerService.getLabel(args.blogId, args.labelName);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify({ label }, null, 2)
-              }
-            ]
-          };
-        } catch (error) {
-          console.error(`Error fetching label ${args.labelName}:`, error);
-          return {
-            content: [
-              {
-                type: 'text',
-                text: `Error fetching label: ${error}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
+      handler: (args) => createToolHandler('get_label', () => {
+        return bloggerService.getLabel(args.blogId, args.labelName).then(label => ({ label }));
+      })()
     }
   ];
 }
 
-/**
- * Initializes the MCP server with all Blogger tools
- * @param bloggerService Blogger service to interact with the API
- * @param config Server configuration
- * @returns MCP server instance
- */
 export function initMCPServer(bloggerService: BloggerService, config: ServerConfig): McpServer {
-  // Create a new MCP server instance with server information
   const server = new McpServer({
     name: "Blogger MCP Server",
     version: "1.0.4",
     vendor: "mcproadev"
   });
 
-  // Get all tool definitions
   const toolDefinitions = createToolDefinitions(bloggerService);
 
-  // Register each tool with the MCP server
   for (const tool of toolDefinitions) {
-    // We can't directly pass the schema object if it's already a Zod object in our definition,
-    // The MCP SDK expects the shape, not the Zod object itself for the 'args' parameter in server.tool()
-    // However, looking at the previous code:
-    // server.tool('name', 'desc', { param: z.string() }, handler)
-    // The previous code passed an object with Zod schemas as values.
-    // Our ToolDefinition.args is a z.ZodType<any>, which is likely a z.object({...}).
-    // We need to extract the shape from the z.object to pass it to server.tool if we want to match the signature.
-    
-    // Actually, looking at the SDK, server.tool takes:
-    // name: string, description: string, args: ToolArgs, handler: ToolCallback
-    // where ToolArgs is Record<string, ZodType<any>>
-    
-    // So my ToolDefinition.args should probably be Record<string, ZodType<any>> instead of z.ZodType<any> 
-    // to make it easier to spread.
-    
-    // Let's adjust the implementation in the loop.
-    // Since I defined args as z.ZodType<any> (which is z.object({...})), I can cast it or access .shape if it's a ZodObject.
-    
-    if (tool.args instanceof z.ZodObject) {
-       server.tool(tool.name, tool.description, tool.args.shape, tool.handler);
-    } else {
-       // Fallback for empty objects or other schemas if we had them (list_blogs has empty object)
-       // If it's not a ZodObject, we might have issues if the SDK expects a shape map.
-       // list_blogs used {} which is compatible with Record<string, ZodType>
-       server.tool(tool.name, tool.description, {}, tool.handler);
-    }
+    server.tool(tool.name, tool.description, tool.args.shape, tool.handler as never);
   }
 
   return server;

package/src/types.ts

@@ -1,79 +1,32 @@
 import { z } from 'zod';
+import { blogger_v3 } from 'googleapis';
 
-/**
- * Types used in the MCP server for Blogger
- */
-
-// Tool definition type
-export interface ToolDefinition {
-  name: string;
-  description: string;
-  args: z.ZodType<any>;
-  handler: (args: any, extra?: any) => Promise<any>;
+export interface ToolResult {
+  content: Array<{ type: string; text: string }>;
+  isError?: boolean;
 }
 
-// Blog type
-export interface BloggerBlog {
-  id: string;
+export interface ToolDefinition<T extends z.ZodRawShape = z.ZodRawShape> {
   name: string;
-  description?: string;
-  url: string;
-  status?: string;
-  posts?: BloggerPost[];
-  labels?: BloggerLabel[];
-}
-
-// Post type
-export interface BloggerPost {
-  id: string;
-  blogId: string;
-  title: string;
-  content: string;
-  url?: string;
-  published?: string;
-  updated?: string;
-  author?: {
-    id: string;
-    displayName: string;
-    url: string;
-    image?: {
-      url: string;
-    };
-  };
-  labels?: string[];
-}
-
-// Label type
-export interface BloggerLabel {
-  id?: string;
-  name: string;
-}
-
-// Search parameters type
-export interface SearchParams {
-  query: string;
-  maxResults?: number;
+  description: string;
+  args: z.ZodObject<T>;
+  handler: (args: z.infer<z.ZodObject<T>>) => Promise<ToolResult>;
 }
 
-// Pagination parameters type
-export interface PaginationParams {
-  pageToken?: string;
-  maxResults?: number;
-}
+export type BloggerBlog = blogger_v3.Schema$Blog;
+export type BloggerPost = blogger_v3.Schema$Post;
+export type BloggerLabel = { name: string };
 
-// Server operating modes type
 export type ServerMode =
   | { type: 'stdio' }
-  | { type: 'http', host: string, port: number };
+  | { type: 'http'; host: string; port: number };
 
-// OAuth2 configuration type
 export interface OAuth2Config {
   clientId?: string;
   clientSecret?: string;
   refreshToken?: string;
 }
 
-// Server configuration type
 export interface ServerConfig {
   mode: ServerMode;
   blogger: {
@@ -87,7 +40,6 @@ export interface ServerConfig {
   };
 }
 
-// UI types
 export interface ServerStatus {
   running: boolean;
   mode: string;

package/src/ui-manager.ts

@@ -4,7 +4,6 @@ import { Server as HttpServer } from 'http';
 import { Server as SocketIOServer } from 'socket.io';
 import { ServerStatus, ClientConnection, ServerStats } from './types';
 
-// UI manager interface
 export interface UIManager {
   start(port: number): Promise<void>;
   stop(): Promise<void>;
@@ -13,7 +12,6 @@ export interface UIManager {
   updateStats(stats: ServerStats): void;
 }
 
-// UI manager implementation
 export class WebUIManager implements UIManager {
   private app: express.Application;
   private server: HttpServer | null = null;
@@ -35,51 +33,44 @@ export class WebUIManager implements UIManager {
 
   constructor() {
     this.app = express();
-    
-    // Express configuration
+
     this.app.use(express.json());
     this.app.use(express.static(path.join(__dirname, '../public')));
-    
-    // API routes
-    this.app.get('/api/status', (req, res) => {
+
+    this.app.get('/api/status', (_req, res) => {
       res.json(this.status);
     });
-    
-    this.app.get('/api/connections', (req, res) => {
+
+    this.app.get('/api/connections', (_req, res) => {
       res.json(this.connections);
     });
-    
-    this.app.get('/api/stats', (req, res) => {
+
+    this.app.get('/api/stats', (_req, res) => {
       res.json(this.stats);
     });
-    
-    // Main route for the UI - wildcard route fix
-    this.app.get('/', (req, res) => {
+
+    this.app.get('/', (_req, res) => {
       res.sendFile(path.join(__dirname, '../public/index.html'));
     });
   }
 
   async start(port: number): Promise<void> {
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
       this.server = new HttpServer(this.app);
       this.io = new SocketIOServer(this.server);
-      
-      // Socket.IO configuration
+
+      this.server.on('error', (err) => {
+        reject(err);
+      });
+
       this.io.on('connection', (socket) => {
         console.log('New UI connection:', socket.id);
-        
-        // Send initial data
+
         socket.emit('status', this.status);
         socket.emit('connections', this.connections);
         socket.emit('stats', this.stats);
-        
-        // Handle user actions
-        socket.on('restart-server', () => {
-          console.log('Server restart request received');
-          // Restart logic to be implemented
-        });
       });
-      
+
       this.server.listen(port, () => {
         console.log(`Web UI started on port ${port}`);
         resolve();