@dalcontak/blogger-mcp-server 1.0.1 → 1.0.3

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_1 = require("./config");
@@ -6,13 +7,9 @@ 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) {
@@ -21,15 +18,8 @@ async function main() {
                 '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
+        console.log(`Authentication mode: ${hasOAuth2 ? 'OAuth2 (full access)' : 'API Key (read-only)'}`);
         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' };
@@ -39,24 +29,17 @@ async function main() {
             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);
-            }
+        if (config_1.config.ui.port > 0 && config_1.config.ui.port < 65536) {
+            uiManager = new ui_manager_1.WebUIManager();
+            uiPort = config_1.config.ui.port;
+            await uiManager.start(uiPort);
         }
-        // Initialize server statistics and status
         let serverStatus = {
             running: true,
             mode: serverMode.type,
@@ -64,25 +47,77 @@ async function main() {
             connections: 0,
             tools: serverTools
         };
-        const serverStats = {
+        const connections = {};
+        const stats = {
             totalRequests: 0,
             successfulRequests: 0,
-            failedRequests: 0,
-            averageResponseTime: 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
+            };
+            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++;
+            }
+            const fiveMinutesAgo = new Date(now.getTime() - 5 * 60 * 1000);
+            Object.keys(connections).forEach(id => {
+                if (connections[id].lastActivity < fiveMinutesAgo) {
+                    delete connections[id];
+                }
+            });
+            uiManager?.updateConnections(Object.values(connections));
+            serverStatus = {
+                ...serverStatus,
+                connections: Object.keys(connections).length
+            };
+            uiManager?.updateStatus(serverStatus);
+        }
         if (uiManager) {
+            const initialStats = {
+                totalRequests: 0,
+                successfulRequests: 0,
+                failedRequests: 0,
+                averageResponseTime: 0,
+                toolUsage: stats.toolUsage
+            };
             uiManager.updateStatus(serverStatus);
-            uiManager.updateStats(serverStats);
+            uiManager.updateStats(initialStats);
         }
-        // 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') {
@@ -101,13 +136,13 @@ async function main() {
                 }
                 let body = '';
                 let bodySize = 0;
-                const MAX_BODY_SIZE = 1024 * 1024; // 1MB limit
+                const MAX_BODY_SIZE = 1024 * 1024;
                 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
+                        req.destroy();
                         return;
                     }
                     body += chunk.toString();
@@ -118,73 +153,40 @@ async function main() {
                     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 validatedParams = toolDef.args.parse(params || {});
                             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));
+                            const textContent = result.content[0]?.text;
+                            if (textContent) {
+                                try {
+                                    const parsedContent = JSON.parse(textContent);
+                                    res.end(JSON.stringify(parsedContent));
+                                }
+                                catch {
+                                    res.end(JSON.stringify(result));
+                                }
                             }
-                            catch (e) {
-                                // If not JSON, return as is wrapped
+                            else {
                                 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}`
-                            }));
+                            res.end(JSON.stringify({ error: `Error executing tool: ${error}` }));
                         }
                     }
                     catch (error) {
@@ -202,94 +204,20 @@ async function main() {
             });
         }
         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`);
+            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);
-            }
+            uiManager?.updateStatus(serverStatus);
             if (httpServer) {
                 httpServer.close();
             }
-            // Allow time for cleanup if needed
             setTimeout(() => process.exit(0), 1000);
         };
         process.on('SIGINT', shutdown);
@@ -300,5 +228,4 @@ async function main() {
         process.exit(1);
     }
 }
-// Run main function
 main();

package/dist/server.d.ts

@@ -1,16 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { ServerConfig, ToolDefinition } from './types';
 import { BloggerService } from './bloggerService';
-/**
- * Creates the tool definitions for the Blogger MCP server
- * @param bloggerService Blogger service to interact with the API
- * @returns Array of tool definitions
- */
 export declare function createToolDefinitions(bloggerService: BloggerService): ToolDefinition[];
-/**
- * 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 declare function initMCPServer(bloggerService: BloggerService, config: ServerConfig): McpServer;