@dalcontak/blogger-mcp-server 1.0.0

package/dist/bloggerService.js

@@ -0,0 +1,323 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BloggerService = void 0;
+const googleapis_1 = require("googleapis");
+const config_1 = require("./config");
+/**
+ * Google Blogger API interaction service
+ *
+ * Supports two authentication modes:
+ * - OAuth2 (GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET + GOOGLE_REFRESH_TOKEN):
+ *   full access (read + write). Required for listBlogs, createPost, updatePost, deletePost.
+ * - API Key (BLOGGER_API_KEY): read-only access to public blogs.
+ *   Works for getBlog, listPosts, getPost, searchPosts, listLabels, getLabel.
+ *
+ * If both are configured, OAuth2 is used (it covers all operations).
+ */
+class BloggerService {
+    /**
+     * Initializes the Blogger service with OAuth2 or API key
+     */
+    constructor() {
+        const { oauth2 } = config_1.config;
+        const hasOAuth2 = !!(oauth2.clientId && oauth2.clientSecret && oauth2.refreshToken);
+        if (hasOAuth2) {
+            const oauth2Client = new googleapis_1.google.auth.OAuth2(oauth2.clientId, oauth2.clientSecret);
+            oauth2Client.setCredentials({ refresh_token: oauth2.refreshToken });
+            this.blogger = googleapis_1.google.blogger({
+                version: 'v3',
+                auth: oauth2Client,
+                timeout: config_1.config.blogger.timeout
+            });
+            this.isOAuth2 = true;
+            console.log('BloggerService initialized with OAuth2 (full access)');
+        }
+        else if (config_1.config.blogger.apiKey) {
+            this.blogger = googleapis_1.google.blogger({
+                version: 'v3',
+                auth: config_1.config.blogger.apiKey,
+                timeout: config_1.config.blogger.timeout
+            });
+            this.isOAuth2 = false;
+            console.log('BloggerService initialized with API Key (read-only)');
+        }
+        else {
+            throw new Error('No authentication configured. ' +
+                'Set BLOGGER_API_KEY (read-only) or ' +
+                'GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET + GOOGLE_REFRESH_TOKEN (full access).');
+        }
+    }
+    /**
+     * Checks that OAuth2 authentication is available.
+     * Throws an explicit error if the operation requires OAuth2 and we are in API key mode.
+     */
+    requireOAuth2(operation) {
+        if (!this.isOAuth2) {
+            throw new Error(`Operation "${operation}" requires OAuth2 authentication. ` +
+                'API Key mode only allows reading public blogs. ' +
+                'Configure GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET and GOOGLE_REFRESH_TOKEN.');
+        }
+    }
+    /**
+     * Lists all blogs for the authenticated user.
+     * Requires OAuth2 (blogs.listByUser with userId: 'self').
+     * @returns Blog list
+     */
+    async listBlogs() {
+        this.requireOAuth2('list_blogs');
+        try {
+            const response = await this.blogger.blogs.listByUser({
+                userId: 'self'
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error('Error fetching blogs:', error);
+            throw error;
+        }
+    }
+    /**
+     * Retrieves details of a specific blog
+     * @param blogId ID of the blog to retrieve
+     * @returns Blog details
+     */
+    async getBlog(blogId) {
+        try {
+            const response = await this.blogger.blogs.get({
+                blogId
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error fetching blog ${blogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Retrieves a blog by its URL
+     * @param url Blog URL
+     * @returns Blog details
+     */
+    async getBlogByUrl(url) {
+        try {
+            const response = await this.blogger.blogs.getByUrl({
+                url
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error fetching blog by URL ${url}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Simulates blog creation.
+     * Note: The Blogger API does not actually allow creating a blog via API.
+     * This method simulates the functionality and returns an explanatory error message.
+     *
+     * @param blogData Blog data to create
+     * @returns Explanatory error message
+     */
+    async createBlog(blogData) {
+        // Simulate a delay to make the response more realistic
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Return an explanatory error message
+        return {
+            error: true,
+            message: "The Google Blogger API does not allow creating a new blog via API. Please create a blog manually on blogger.com.",
+            details: "This limitation is documented by Google. Blogs must be created via the Blogger web interface.",
+            suggestedAction: "Create a blog at https://www.blogger.com, then use its ID with this MCP server."
+        };
+    }
+    /**
+     * Lists posts from a blog
+     * @param blogId Blog ID
+     * @param maxResults Maximum number of results to return
+     * @returns Post list
+     */
+    async listPosts(blogId, maxResults) {
+        try {
+            const response = await this.blogger.posts.list({
+                blogId,
+                maxResults: maxResults || config_1.config.blogger.maxResults
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error fetching posts for blog ${blogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Searches posts in a blog using the native posts.search endpoint of the Blogger API
+     * @param blogId Blog ID
+     * @param query Search term
+     * @param maxResults Maximum number of results to return
+     * @returns List of matching posts
+     */
+    async searchPosts(blogId, query, maxResults) {
+        try {
+            const response = await this.blogger.posts.search({
+                blogId,
+                q: query,
+                fetchBodies: true
+            });
+            // The search endpoint does not support maxResults directly,
+            // so we truncate client-side if needed
+            const items = response.data.items || [];
+            const limit = maxResults || config_1.config.blogger.maxResults;
+            return {
+                kind: response.data.kind,
+                items: items.slice(0, limit)
+            };
+        }
+        catch (error) {
+            console.error(`Error searching posts in blog ${blogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Retrieves a specific post
+     * @param blogId Blog ID
+     * @param postId Post ID
+     * @returns Post details
+     */
+    async getPost(blogId, postId) {
+        try {
+            const response = await this.blogger.posts.get({
+                blogId,
+                postId
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error fetching post ${postId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Creates a new post in a blog.
+     * Requires OAuth2.
+     * @param blogId Blog ID
+     * @param postData Post data to create
+     * @returns Created post
+     */
+    async createPost(blogId, postData) {
+        this.requireOAuth2('create_post');
+        try {
+            const response = await this.blogger.posts.insert({
+                blogId,
+                requestBody: postData
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error creating post in blog ${blogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Updates an existing post.
+     * Requires OAuth2.
+     * @param blogId Blog ID
+     * @param postId Post ID
+     * @param postData Post data to update
+     * @returns Updated post
+     */
+    async updatePost(blogId, postId, postData) {
+        this.requireOAuth2('update_post');
+        try {
+            // Convert types to avoid compilation errors
+            const requestBody = {
+                title: postData.title,
+                content: postData.content,
+                labels: postData.labels
+            };
+            const response = await this.blogger.posts.update({
+                blogId,
+                postId,
+                requestBody
+            });
+            return response.data;
+        }
+        catch (error) {
+            console.error(`Error updating post ${postId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Deletes a post.
+     * Requires OAuth2.
+     * @param blogId Blog ID
+     * @param postId Post ID
+     * @returns Deletion status
+     */
+    async deletePost(blogId, postId) {
+        this.requireOAuth2('delete_post');
+        try {
+            await this.blogger.posts.delete({
+                blogId,
+                postId
+            });
+        }
+        catch (error) {
+            console.error(`Error deleting post ${postId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Lists labels from a blog
+     * @param blogId Blog ID
+     * @returns Label list
+     */
+    async listLabels(blogId) {
+        try {
+            // The Blogger API does not provide a direct endpoint to list labels
+            // We fetch all posts and extract unique labels
+            const response = await this.blogger.posts.list({
+                blogId,
+                maxResults: 50 // Fetch enough posts to extract labels
+            });
+            const posts = response.data.items || [];
+            const labelSet = new Set();
+            // Extract all unique labels from posts
+            posts.forEach(post => {
+                const postLabels = post.labels || [];
+                postLabels.forEach(label => labelSet.add(label));
+            });
+            // Convert to expected format
+            const labels = Array.from(labelSet).map(name => ({ name }));
+            return {
+                kind: 'blogger#labelList',
+                items: labels
+            };
+        }
+        catch (error) {
+            console.error(`Error fetching labels for blog ${blogId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Retrieves a specific label
+     * @param blogId Blog ID
+     * @param labelName Label name
+     * @returns Label details
+     */
+    async getLabel(blogId, labelName) {
+        try {
+            // The Blogger API does not provide a direct endpoint to retrieve a label
+            // We check if the label exists by listing all labels
+            const labels = await this.listLabels(blogId);
+            const label = labels.items?.find(l => l.name === labelName);
+            if (!label) {
+                throw new Error(`Label ${labelName} not found`);
+            }
+            return label;
+        }
+        catch (error) {
+            console.error(`Error fetching label ${labelName}:`, error);
+            throw error;
+        }
+    }
+}
+exports.BloggerService = BloggerService;

package/dist/config.d.ts

@@ -0,0 +1,20 @@
+export declare const config: {
+    mode: string;
+    http: {
+        host: string;
+        port: number;
+    };
+    blogger: {
+        apiKey: string | undefined;
+        maxResults: number;
+        timeout: number;
+    };
+    oauth2: {
+        clientId: string | undefined;
+        clientSecret: string | undefined;
+        refreshToken: string | undefined;
+    };
+    logging: {
+        level: string;
+    };
+};

package/dist/config.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+// MCP server configuration for Blogger
+exports.config = {
+    // Server operating mode (stdio or http)
+    mode: process.env.MCP_MODE || 'stdio',
+    // HTTP mode configuration (if used)
+    http: {
+        host: process.env.MCP_HTTP_HOST || '0.0.0.0',
+        port: parseInt(process.env.MCP_HTTP_PORT || '3000', 10)
+    },
+    // Blogger API configuration
+    blogger: {
+        apiKey: process.env.BLOGGER_API_KEY,
+        // Default maximum number of results for list queries
+        maxResults: parseInt(process.env.BLOGGER_MAX_RESULTS || '10', 10),
+        // API request timeout in milliseconds
+        timeout: parseInt(process.env.BLOGGER_API_TIMEOUT || '30000', 10)
+    },
+    // OAuth2 configuration for authenticated operations (create, update, delete)
+    // If these variables are not set, the server runs in read-only mode (API key)
+    oauth2: {
+        clientId: process.env.GOOGLE_CLIENT_ID,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+        refreshToken: process.env.GOOGLE_REFRESH_TOKEN
+    },
+    // Logging configuration
+    logging: {
+        level: process.env.LOG_LEVEL || 'info'
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("./config");
+const bloggerService_1 = require("./bloggerService");
+const server_1 = require("./server");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const http_1 = require("http");
+const ui_manager_1 = require("./ui-manager");
+/**
+ * Main entry point for the Blogger MCP server
+ */
+async function main() {
+    try {
+        console.log('Starting Blogger MCP server...');
+        // Verify that at least one authentication method is configured
+        const hasOAuth2 = !!(config_1.config.oauth2.clientId && config_1.config.oauth2.clientSecret && config_1.config.oauth2.refreshToken);
+        const hasApiKey = !!config_1.config.blogger.apiKey;
+        if (!hasOAuth2 && !hasApiKey) {
+            console.error('ERROR: No authentication configured.\n' +
+                'Set BLOGGER_API_KEY (read-only) or\n' +
+                'GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET + GOOGLE_REFRESH_TOKEN (full access).');
+            process.exit(1);
+        }
+        if (hasOAuth2) {
+            console.log('Authentication mode: OAuth2 (full access)');
+        }
+        else {
+            console.log('Authentication mode: API Key (read-only)');
+        }
+        // Initialize the Blogger service
+        const bloggerService = new bloggerService_1.BloggerService();
+        // Convert configuration to the format expected by the server
+        const serverMode = config_1.config.mode === 'http'
+            ? { type: 'http', host: config_1.config.http.host, port: config_1.config.http.port }
+            : { type: 'stdio' };
+        const serverConfig = {
+            mode: serverMode,
+            blogger: config_1.config.blogger,
+            oauth2: config_1.config.oauth2,
+            logging: config_1.config.logging
+        };
+        // Initialize the MCP server with all tools
+        const server = (0, server_1.initMCPServer)(bloggerService, serverConfig);
+        // Get tool definitions for direct access in HTTP mode and stats
+        const toolDefinitions = (0, server_1.createToolDefinitions)(bloggerService);
+        const toolMap = new Map(toolDefinitions.map(t => [t.name, t]));
+        const serverTools = toolDefinitions.map(t => t.name);
+        // Initialize the Web UI only if UI_PORT is set
+        let uiManager;
+        let uiPort;
+        if (process.env.UI_PORT) {
+            const parsedPort = parseInt(process.env.UI_PORT);
+            if (!isNaN(parsedPort) && parsedPort > 0 && parsedPort < 65536) {
+                uiManager = new ui_manager_1.WebUIManager();
+                uiPort = parsedPort;
+                await uiManager.start(uiPort);
+            }
+        }
+        // Initialize server statistics and status
+        let serverStatus = {
+            running: true,
+            mode: serverMode.type,
+            startTime: new Date(),
+            connections: 0,
+            tools: serverTools
+        };
+        const serverStats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            averageResponseTime: 0,
+            toolUsage: serverTools.reduce((acc, tool) => {
+                acc[tool] = 0;
+                return acc;
+            }, {})
+        };
+        if (uiManager) {
+            uiManager.updateStatus(serverStatus);
+            uiManager.updateStats(serverStats);
+        }
+        // Configure the appropriate transport based on the mode
+        let httpServer;
+        if (serverMode.type === 'http') {
+            // For HTTP mode, we use Node.js HTTP server directly
+            // since the official MCP SDK does not have an HttpServerTransport equivalent
+            const httpMode = serverMode;
+            httpServer = new http_1.Server((req, res) => {
+                if (req.method === 'OPTIONS') {
+                    res.writeHead(200, {
+                        'Access-Control-Allow-Origin': '*',
+                        'Access-Control-Allow-Methods': 'POST, OPTIONS',
+                        'Access-Control-Allow-Headers': 'Content-Type'
+                    });
+                    res.end();
+                    return;
+                }
+                if (req.method !== 'POST') {
+                    res.writeHead(405, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Method not allowed' }));
+                    return;
+                }
+                let body = '';
+                let bodySize = 0;
+                const MAX_BODY_SIZE = 1024 * 1024; // 1MB limit
+                req.on('data', chunk => {
+                    bodySize += chunk.length;
+                    if (bodySize > MAX_BODY_SIZE) {
+                        res.writeHead(413, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Request entity too large' }));
+                        req.destroy(); // Stop receiving data
+                        return;
+                    }
+                    body += chunk.toString();
+                });
+                req.on('end', async () => {
+                    if (req.destroyed)
+                        return;
+                    try {
+                        const request = JSON.parse(body);
+                        const { tool, params } = request;
+                        // Add client connection
+                        const clientIp = req.socket.remoteAddress || 'unknown';
+                        updateConnections(req.socket.remotePort?.toString() || 'client', clientIp);
+                        // Call the appropriate tool
+                        try {
+                            const startTime = Date.now();
+                            const toolDef = toolMap.get(tool);
+                            if (!toolDef) {
+                                throw new Error(`Unknown tool: ${tool}`);
+                            }
+                            // Validate parameters using Zod schema
+                            let validatedParams;
+                            try {
+                                validatedParams = toolDef.args.parse(params || {});
+                            }
+                            catch (validationError) {
+                                throw new Error(`Invalid parameters: ${validationError}`);
+                            }
+                            // Execute tool handler
+                            const result = await toolDef.handler(validatedParams);
+                            const duration = Date.now() - startTime;
+                            // Update success statistics
+                            updateStats(tool, true, duration);
+                            // If the handler returned an isError: true, we might want to return 400 or just return the error object 
+                            // as per MCP protocol. Here we are in HTTP mode, let's just return 200 with the result object which contains the error message.
+                            // But strictly speaking, if it's an error, we should probably update stats as failed? 
+                            // The handler catches exceptions and returns { isError: true, ... }. 
+                            // So if result.isError is true, we should count it as failed?
+                            // The previous implementation counted catch block as failed. 
+                            // Let's stick to the previous logic: if handler throws, it's a failure. If handler returns result (even error result), it's success execution of the tool.
+                            res.writeHead(200, {
+                                'Content-Type': 'application/json',
+                                'Access-Control-Allow-Origin': '*'
+                            });
+                            // MCP Tools return { content: [...] }, but the previous HTTP implementation returned simplified objects like { blogs: [...] }.
+                            // To maintain backward compatibility with the previous HTTP API (if any clients rely on it), 
+                            // we might need to transform the MCP result format back to the simplified format?
+                            // The previous switch statement returned `result = { blogs }`.
+                            // The tool handlers now return `{ content: [{ type: 'text', text: JSON.stringify({ blogs }) }] }`.
+                            // We should probably parse the JSON text back if we want to return JSON.
+                            // OR, we just return the MCP result directly. 
+                            // Given that this is an MCP server, clients should expect MCP format.
+                            // HOWEVER, the `index.ts` HTTP implementation seemed to be a custom JSON API wrapper around the tools.
+                            // Let's try to parse the response text if possible to match previous behavior, 
+                            // OR better: accept that the response format changes to MCP standard or keep it simple.
+                            // The previous implementation was: `res.end(JSON.stringify(result))` where result was `{ blogs: ... }`.
+                            // The tool handlers return `{ content: [{ text: "{\"blogs\":...}" }] }`.
+                            // Let's unwrap it for HTTP mode to keep it friendly, or just return the text.
+                            // If we want to return pure JSON like before:
+                            try {
+                                const textContent = result.content[0].text;
+                                // If the text is JSON, parse it and return that.
+                                const parsedContent = JSON.parse(textContent);
+                                res.end(JSON.stringify(parsedContent));
+                            }
+                            catch (e) {
+                                // If not JSON, return as is wrapped
+                                res.end(JSON.stringify(result));
+                            }
+                        }
+                        catch (error) {
+                            // Update failure statistics
+                            updateStats(tool, false);
+                            res.writeHead(400, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({
+                                error: `Error executing tool: ${error}`
+                            }));
+                        }
+                    }
+                    catch (error) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: `Parsing error: ${error}` }));
+                    }
+                });
+            });
+            httpServer.listen(httpMode.port, httpMode.host, () => {
+                console.log(`Blogger MCP server started in HTTP mode`);
+                console.log(`Listening on ${httpMode.host}:${httpMode.port}`);
+                if (uiPort) {
+                    console.log(`Web UI available at http://localhost:${uiPort}`);
+                }
+            });
+        }
+        else {
+            // For stdio mode, we use the official MCP SDK transport
+            const transport = new stdio_js_1.StdioServerTransport();
+            await server.connect(transport);
+            console.log(`Blogger MCP server started in stdio mode`);
+            if (uiPort) {
+                console.log(`Web UI available at http://localhost:${uiPort}`);
+            }
+        }
+        // Functions to update statistics and connections
+        const connections = {};
+        let stats = {
+            totalRequests: 0,
+            successfulRequests: 0,
+            failedRequests: 0,
+            totalResponseTime: 0,
+            toolUsage: serverTools.reduce((acc, tool) => {
+                acc[tool] = 0;
+                return acc;
+            }, {})
+        };
+        function updateStats(tool, success = true, duration = 0) {
+            stats.totalRequests++;
+            if (success) {
+                stats.successfulRequests++;
+                stats.totalResponseTime += duration;
+            }
+            if (stats.toolUsage[tool] !== undefined) {
+                stats.toolUsage[tool]++;
+            }
+            const updatedStats = {
+                totalRequests: stats.totalRequests,
+                successfulRequests: stats.successfulRequests,
+                failedRequests: stats.totalRequests - stats.successfulRequests,
+                averageResponseTime: stats.successfulRequests > 0
+                    ? Math.round(stats.totalResponseTime / stats.successfulRequests)
+                    : 0,
+                toolUsage: stats.toolUsage
+            };
+            if (uiManager) {
+                uiManager.updateStats(updatedStats);
+            }
+        }
+        function updateConnections(clientId, clientIp) {
+            const now = new Date();
+            if (!connections[clientId]) {
+                connections[clientId] = {
+                    id: clientId,
+                    ip: clientIp,
+                    connectedAt: now,
+                    lastActivity: now,
+                    requestCount: 1
+                };
+            }
+            else {
+                connections[clientId].lastActivity = now;
+                connections[clientId].requestCount++;
+            }
+            // Clean up inactive connections (older than 5 minutes)
+            const fiveMinutesAgo = new Date(now.getTime() - 5 * 60 * 1000);
+            Object.keys(connections).forEach(id => {
+                if (connections[id].lastActivity < fiveMinutesAgo) {
+                    delete connections[id];
+                }
+            });
+            if (uiManager) {
+                uiManager.updateConnections(Object.values(connections));
+            }
+            // Update status with connection count
+            // FIX: Update the variable and then send it
+            serverStatus = {
+                ...serverStatus,
+                connections: Object.keys(connections).length
+            };
+            if (uiManager) {
+                uiManager.updateStatus(serverStatus);
+            }
+        }
+        // Graceful shutdown
+        const shutdown = async () => {
+            console.log('Shutting down...');
+            serverStatus = { ...serverStatus, running: false };
+            if (uiManager) {
+                uiManager.updateStatus(serverStatus);
+            }
+            if (httpServer) {
+                httpServer.close();
+            }
+            // Allow time for cleanup if needed
+            setTimeout(() => process.exit(0), 1000);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (error) {
+        console.error('Error starting Blogger MCP server:', error);
+        process.exit(1);
+    }
+}
+// Run main function
+main();