@dalcontak/blogger-mcp-server 1.0.0 → 1.0.2

package/dist/server.js

@@ -4,42 +4,32 @@ exports.createToolDefinitions = createToolDefinitions;
 exports.initMCPServer = initMCPServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("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, fn) {
+    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
+            };
+        }
+    };
+}
 function createToolDefinitions(bloggerService) {
     return [
         {
             name: 'list_blogs',
             description: 'Lists all accessible blogs',
             args: zod_1.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',
@@ -47,31 +37,9 @@ function createToolDefinitions(bloggerService) {
             args: zod_1.z.object({
                 blogId: zod_1.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',
@@ -79,50 +47,9 @@ function createToolDefinitions(bloggerService) {
             args: zod_1.z.object({
                 url: zod_1.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: zod_1.z.object({
-                name: zod_1.z.string().describe('Blog name'),
-                description: zod_1.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',
@@ -131,31 +58,9 @@ function createToolDefinitions(bloggerService) {
                 blogId: zod_1.z.string().describe('Blog ID'),
                 maxResults: zod_1.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',
@@ -165,31 +70,9 @@ function createToolDefinitions(bloggerService) {
                 query: zod_1.z.string().describe('Search term'),
                 maxResults: zod_1.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',
@@ -198,31 +81,9 @@ function createToolDefinitions(bloggerService) {
                 blogId: zod_1.z.string().describe('Blog ID'),
                 postId: zod_1.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',
@@ -233,35 +94,13 @@ function createToolDefinitions(bloggerService) {
                 content: zod_1.z.string().describe('Post content'),
                 labels: zod_1.z.array(zod_1.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',
@@ -273,35 +112,13 @@ function createToolDefinitions(bloggerService) {
                 content: zod_1.z.string().optional().describe('New post content'),
                 labels: zod_1.z.array(zod_1.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',
@@ -310,31 +127,9 @@ function createToolDefinitions(bloggerService) {
                 blogId: zod_1.z.string().describe('Blog ID'),
                 postId: zod_1.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',
@@ -342,31 +137,9 @@ function createToolDefinitions(bloggerService) {
             args: zod_1.z.object({
                 blogId: zod_1.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',
@@ -375,74 +148,21 @@ function createToolDefinitions(bloggerService) {
                 blogId: zod_1.z.string().describe('Blog ID'),
                 labelName: zod_1.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
- */
 function initMCPServer(bloggerService, config) {
-    // Create a new MCP server instance with server information
     const server = new mcp_js_1.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 zod_1.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);
     }
     return server;
 }

package/dist/types.d.ts

@@ -1,52 +1,23 @@
 import { z } from 'zod';
-/**
- * Types used in the MCP server for Blogger
- */
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    args: z.ZodType<any>;
-    handler: (args: any, extra?: any) => Promise<any>;
+import { blogger_v3 } from 'googleapis';
+export interface ToolResult {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError?: boolean;
 }
-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[];
-}
-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[];
+    description: string;
+    args: z.ZodObject<T>;
+    handler: (args: z.infer<z.ZodObject<T>>) => Promise<ToolResult>;
 }
-export interface BloggerLabel {
-    id?: string;
+export type BloggerBlog = blogger_v3.Schema$Blog;
+export type BloggerPost = blogger_v3.Schema$Post;
+export type BloggerLabel = {
     name: string;
-}
-export interface SearchParams {
-    query: string;
-    maxResults?: number;
-}
-export interface PaginationParams {
-    pageToken?: string;
-    maxResults?: number;
-}
+};
 export type ServerMode = {
     type: 'stdio';
 } | {

package/dist/ui-manager.js

@@ -8,7 +8,6 @@ const express_1 = __importDefault(require("express"));
 const path_1 = __importDefault(require("path"));
 const http_1 = require("http");
 const socket_io_1 = require("socket.io");
-// UI manager implementation
 class WebUIManager {
     constructor() {
         this.server = null;
@@ -28,40 +27,33 @@ class WebUIManager {
             toolUsage: {}
         };
         this.app = (0, express_1.default)();
-        // Express configuration
         this.app.use(express_1.default.json());
         this.app.use(express_1.default.static(path_1.default.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_1.default.join(__dirname, '../public/index.html'));
         });
     }
     async start(port) {
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             this.server = new http_1.Server(this.app);
             this.io = new socket_io_1.Server(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}`);

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@dalcontak/blogger-mcp-server",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "private": false,
   "description": "MCP Server for Blogger API",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dalcontak/blogger-mcp-server.git"
+  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/bloggerService.test.ts

@@ -361,7 +361,11 @@ describe('write operations (OAuth2)', () => {
       const result = await service.createPost('blog1', newPost);
       expect(mockPostsInsert).toHaveBeenCalledWith({
         blogId: 'blog1',
-        requestBody: newPost
+        requestBody: {
+          title: 'New',
+          content: '<p>Hello</p>',
+          labels: ['test']
+        }
       });
       expect(result.title).toBe('New');
     });