@dalcontak/blogger-mcp-server 1.0.0

package/dist/server.js

@@ -0,0 +1,448 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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
+                    };
+                }
+            }
+        },
+        {
+            name: 'get_blog',
+            description: 'Retrieves details of a specific blog',
+            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
+                    };
+                }
+            }
+        },
+        {
+            name: 'get_blog_by_url',
+            description: 'Retrieves a blog by its URL (useful for discovering blog ID)',
+            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
+                };
+            }
+        },
+        {
+            name: 'list_posts',
+            description: 'Lists all posts from a blog',
+            args: zod_1.z.object({
+                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
+                    };
+                }
+            }
+        },
+        {
+            name: 'search_posts',
+            description: 'Searches posts in a blog',
+            args: zod_1.z.object({
+                blogId: zod_1.z.string().describe('Blog ID'),
+                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
+                    };
+                }
+            }
+        },
+        {
+            name: 'get_post',
+            description: 'Retrieves details of a specific post',
+            args: zod_1.z.object({
+                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
+                    };
+                }
+            }
+        },
+        {
+            name: 'create_post',
+            description: 'Creates a new post in a blog',
+            args: zod_1.z.object({
+                blogId: zod_1.z.string().describe('Blog ID'),
+                title: zod_1.z.string().describe('Post title'),
+                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
+                    };
+                }
+            }
+        },
+        {
+            name: 'update_post',
+            description: 'Updates an existing post',
+            args: zod_1.z.object({
+                blogId: zod_1.z.string().describe('Blog ID'),
+                postId: zod_1.z.string().describe('Post ID'),
+                title: zod_1.z.string().optional().describe('New post title'),
+                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
+                    };
+                }
+            }
+        },
+        {
+            name: 'delete_post',
+            description: 'Deletes a post',
+            args: zod_1.z.object({
+                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
+                    };
+                }
+            }
+        },
+        {
+            name: 'list_labels',
+            description: 'Lists all labels from a blog',
+            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
+                    };
+                }
+            }
+        },
+        {
+            name: 'get_label',
+            description: 'Retrieves details of a specific label',
+            args: zod_1.z.object({
+                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
+                    };
+                }
+            }
+        }
+    ];
+}
+/**
+ * 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);
+        }
+    }
+    return server;
+}

package/dist/types.d.ts

@@ -0,0 +1,94 @@
+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>;
+}
+export interface BloggerBlog {
+    id: string;
+    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[];
+}
+export interface BloggerLabel {
+    id?: string;
+    name: string;
+}
+export interface SearchParams {
+    query: string;
+    maxResults?: number;
+}
+export interface PaginationParams {
+    pageToken?: string;
+    maxResults?: number;
+}
+export type ServerMode = {
+    type: 'stdio';
+} | {
+    type: 'http';
+    host: string;
+    port: number;
+};
+export interface OAuth2Config {
+    clientId?: string;
+    clientSecret?: string;
+    refreshToken?: string;
+}
+export interface ServerConfig {
+    mode: ServerMode;
+    blogger: {
+        apiKey?: string;
+        maxResults: number;
+        timeout: number;
+    };
+    oauth2: OAuth2Config;
+    logging: {
+        level: string;
+    };
+}
+export interface ServerStatus {
+    running: boolean;
+    mode: string;
+    startTime?: Date;
+    connections: number;
+    tools: string[];
+}
+export interface ClientConnection {
+    id: string;
+    ip?: string;
+    connectedAt: Date;
+    lastActivity: Date;
+    requestCount: number;
+}
+export interface ServerStats {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    averageResponseTime: number;
+    toolUsage: Record<string, number>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui-manager.d.ts

@@ -0,0 +1,22 @@
+import { ServerStatus, ClientConnection, ServerStats } from './types';
+export interface UIManager {
+    start(port: number): Promise<void>;
+    stop(): Promise<void>;
+    updateStatus(status: ServerStatus): void;
+    updateConnections(connections: ClientConnection[]): void;
+    updateStats(stats: ServerStats): void;
+}
+export declare class WebUIManager implements UIManager {
+    private app;
+    private server;
+    private io;
+    private status;
+    private connections;
+    private stats;
+    constructor();
+    start(port: number): Promise<void>;
+    stop(): Promise<void>;
+    updateStatus(status: ServerStatus): void;
+    updateConnections(connections: ClientConnection[]): void;
+    updateStats(stats: ServerStats): void;
+}

package/dist/ui-manager.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebUIManager = void 0;
+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;
+        this.io = null;
+        this.status = {
+            running: false,
+            mode: 'stopped',
+            connections: 0,
+            tools: []
+        };
+        this.connections = [];
+        this.stats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            averageResponseTime: 0,
+            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) => {
+            res.json(this.status);
+        });
+        this.app.get('/api/connections', (req, res) => {
+            res.json(this.connections);
+        });
+        this.app.get('/api/stats', (req, res) => {
+            res.json(this.stats);
+        });
+        // Main route for the UI - wildcard route fix
+        this.app.get('/', (req, res) => {
+            res.sendFile(path_1.default.join(__dirname, '../public/index.html'));
+        });
+    }
+    async start(port) {
+        return new Promise((resolve) => {
+            this.server = new http_1.Server(this.app);
+            this.io = new socket_io_1.Server(this.server);
+            // Socket.IO configuration
+            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();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (this.server) {
+                this.server.close((err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        this.server = null;
+                        this.io = null;
+                        resolve();
+                    }
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    updateStatus(status) {
+        this.status = status;
+        if (this.io) {
+            this.io.emit('status', status);
+        }
+    }
+    updateConnections(connections) {
+        this.connections = connections;
+        if (this.io) {
+            this.io.emit('connections', connections);
+        }
+    }
+    updateStats(stats) {
+        this.stats = stats;
+        if (this.io) {
+            this.io.emit('stats', stats);
+        }
+    }
+}
+exports.WebUIManager = WebUIManager;

package/jest.config.js

@@ -0,0 +1,7 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/*.test.ts'],
+};