optimize: code of --host and add logger (#211)

* refactor: optimize --host code

* feat: update _meta description

* refactor: server code

* feat: add logger

Author: hustcc

src/index.ts

@@ -7,7 +7,7 @@ import {
 } from "./server";
 
 // Parse command line arguments
-const parsed = parseArgs({
+const { values } = parseArgs({
   options: {
     transport: {
       type: "string",
@@ -24,7 +24,6 @@ const parsed = parseArgs({
       short: "p",
       default: "1122",
     },
-    
     endpoint: {
       type: "string",
       short: "e",
@@ -35,40 +34,7 @@ const parsed = parseArgs({
       short: "H",
     },
   },
-  allowPositionals: true,
-  tokens: true,
 });
-// Initialize default host value
-let host = "localhost";
-// Flag to track if we're expecting a host value in the next token
-let isHostValue = false;
-
-// Iterate through parsed command line tokens to extract host value
-for (const item of parsed.tokens) {
-  // If current token is the host option flag
-  if (item.kind === "option" && item.name === "host") {
-    isHostValue = true;
-    continue;
-  }
-  // If we're expecting a host value (previous token was --host flag)
-  if (isHostValue) {
-    // Deep copy the token to avoid reference issues
-    const temp = JSON.parse(JSON.stringify(item));
-    // Extract host value or default to "0.0.0.0"
-    host = temp.value || "0.0.0.0";
-    isHostValue = false;
-    break;
-  }
-}
-
-// If --host flag was set but no value followed it, use "0.0.0.0" as default
-if (isHostValue) {
-  host = "0.0.0.0";
-}
-
-// Create a deep copy of parsed values and assign the determined host
-const values = JSON.parse(JSON.stringify(parsed.values));
-values.host = host;
 
 // Display help information if requested
 if (values.help) {

src/server.ts

@@ -11,6 +11,7 @@ import {
 } from "./services";
 import { callTool } from "./utils/callTool";
 import { getDisabledTools } from "./utils/env";
+import { logger } from "./utils/logger";
 
 /**
  * Creates and configures an MCP server for chart generation.
@@ -30,8 +31,12 @@ export function createServer(): Server {
 
   setupToolHandlers(server);
 
-  server.onerror = (error: Error) => console.error("[MCP Error]", error);
+  server.onerror = (e: Error) => {
+    logger.error("Server encountered an error, shutting down", e);
+  };
+
   process.on("SIGINT", async () => {
+    logger.info("SIGINT received, shutting down server...");
     await server.close();
     process.exit(0);
   });
@@ -57,13 +62,18 @@ function getEnabledTools() {
  * Sets up tool handlers for the MCP server.
  */
 function setupToolHandlers(server: Server): void {
+  logger.info("setting up tool handlers...");
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: getEnabledTools().map((chart) => chart.tool),
   }));
 
+  // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
+    logger.info("calling tool", request.params.name, request.params.arguments);
+
     return await callTool(request.params.name, request.params.arguments);
   });
+  logger.info("tool handlers set up");
 }
 
 /**

src/services/sse.ts

@@ -1,6 +1,7 @@
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import express, { Request, Response } from "express";
+import express, { type Request, type Response } from "express";
+import { logger } from "../utils/logger";
 
 export const startSSEMcpServer = async (
   server: Server,
@@ -14,32 +15,41 @@ export const startSSEMcpServer = async (
   const transports: Record<string, SSEServerTransport> = {};
 
   app.get(endpoint, async (req: Request, res: Response) => {
-    try {
-      const transport = new SSEServerTransport("/messages", res);
-      transports[transport.sessionId] = transport;
-      transport.onclose = () => delete transports[transport.sessionId];
-      await server.connect(transport);
-    } catch (error) {
-      if (!res.headersSent)
-        res.status(500).send("Error establishing SSE stream");
-    }
+    const transport = new SSEServerTransport("/messages", res);
+    transports[transport.sessionId] = transport;
+
+    transport.onclose = () => {
+      delete transports[transport.sessionId];
+      logger.info(`SSE Server disconnected: sessionId=${transport.sessionId}`);
+    };
+
+    await server.connect(transport);
+    logger.info(`SSE Server connected: sessionId=${transport.sessionId}`);
   });
 
-  app.post('/messages', async (req: Request, res: Response) => {
+  app.post("/messages", async (req: Request, res: Response) => {
     const sessionId = req.query.sessionId as string;
-    if (!sessionId) return res.status(400).send("Missing sessionId parameter");
+    if (!sessionId) {
+      logger.warn("SSE Server sessionId parameter is missing");
+      return res.status(400).send("Missing sessionId parameter");
+    }
 
     const transport = transports[sessionId];
-    if (!transport) return res.status(404).send("Session not found");
+    if (!transport) {
+      logger.warn(`SSE Server session not found: sessionId=${sessionId}`);
+      return res.status(404).send("Session not found");
+    }
 
     try {
+      logger.info(`SSE Server handling message: sessionId=${sessionId}`);
       await transport.handlePostMessage(req, res, req.body);
-    } catch (error) {
+    } catch (e) {
+      logger.error("SSE Server error handling message", e);
       if (!res.headersSent) res.status(500).send("Error handling request");
     }
   });
 
   app.listen(port, host, () => {
-    console.log(`SSE Server listening on http://${host}:${port}${endpoint}`);
+    logger.success(`SSE Server listening on http://${host}:${port}${endpoint}`);
   });
 };

src/services/stdio.ts

@@ -1,7 +1,9 @@
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { logger } from "../utils/logger";
 
 export async function startStdioMcpServer(server: Server): Promise<void> {
   const transport = new StdioServerTransport();
   await server.connect(transport);
+  logger.success("Stdio MCP Server started");
 }

src/services/streamable.ts

@@ -1,7 +1,8 @@
 import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import express, { Request, Response } from "express";
 import cors from "cors";
+import express, { type Request, type Response } from "express";
+import { logger } from "../utils/logger";
 
 export const startHTTPStreamableServer = async (
   createServer: () => Server,
@@ -14,18 +15,27 @@ export const startHTTPStreamableServer = async (
   app.use(cors({ origin: "*", exposedHeaders: ["Mcp-Session-Id"] }));
 
   app.post(endpoint, async (req: Request, res: Response) => {
+    // In stateless mode, create a new transport for each request to prevent
+    // request ID collisions. Different clients may use the same JSON-RPC request IDs,
+    // which would cause responses to be routed to the wrong HTTP connections if
+    // the transport state is shared.
     try {
       const server = createServer();
       const transport = new StreamableHTTPServerTransport({
         sessionIdGenerator: undefined,
+        enableJsonResponse: true,
       });
+
       res.on("close", () => {
         transport.close();
-        server.close();
+        logger.info("HTTP Streamable Server response closed");
       });
+
       await server.connect(transport);
       await transport.handleRequest(req, res, req.body);
-    } catch (error) {
+      logger.info("HTTP Streamable Server response connected");
+    } catch (e) {
+      logger.error("HTTP Streamable Server response error", e);
       if (!res.headersSent) {
         res.status(500).json({
           jsonrpc: "2.0",
@@ -36,24 +46,8 @@ export const startHTTPStreamableServer = async (
     }
   });
 
-  app.get(endpoint, (req: Request, res: Response) => {
-    res.status(405).json({
-      jsonrpc: "2.0",
-      error: { code: -32000, message: "Method not allowed" },
-      id: null,
-    });
-  });
-
-  app.delete(endpoint, (req: Request, res: Response) => {
-    res.status(405).json({
-      jsonrpc: "2.0",
-      error: { code: -32000, message: "Method not allowed" },
-      id: null,
-    });
-  });
-
   app.listen(port, host, () => {
-    console.log(
+    logger.success(
       `Streamable HTTP Server listening on http://${host}:${port}${endpoint}`,
     );
   });

src/utils/callTool.ts

@@ -2,6 +2,7 @@ import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import * as Charts from "../charts";
 import { generateChartUrl, generateMap } from "./generate";
+import { logger } from "./logger";
 import { ValidateError } from "./validator";
 
 // Chart type mapping
@@ -40,9 +41,11 @@ const CHART_TYPE_MAP = {
  * @returns
  */
 export async function callTool(tool: string, args: object = {}) {
+  logger.info(`Calling tool: ${tool}`);
   const chartType = CHART_TYPE_MAP[tool as keyof typeof CHART_TYPE_MAP];
 
   if (!chartType) {
+    logger.error(`Unknown tool: ${tool}`);
     throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${tool}.`);
   }
 
@@ -55,6 +58,7 @@ export async function callTool(tool: string, args: object = {}) {
       // Use safeParse instead of parse and try-catch.
       const result = z.object(schema).safeParse(args);
       if (!result.success) {
+        logger.error(`Invalid parameters: ${result.error.message}`);
         throw new McpError(
           ErrorCode.InvalidParams,
           `Invalid parameters: ${result.error.message}`,
@@ -75,6 +79,7 @@ export async function callTool(tool: string, args: object = {}) {
     }
 
     const url = await generateChartUrl(chartType, args);
+    logger.info(`Generated chart URL: ${url}`);
 
     return {
       content: [
@@ -85,12 +90,15 @@ export async function callTool(tool: string, args: object = {}) {
       ],
       _meta: {
         description:
-          "Charts spec configuration, you can use this config to generate the corresponding chart.",
+          "This is the chart's spec and configuration, which can be renderred to corresponding chart by AntV GPT-Vis chart components.",
         spec: { type: chartType, ...args },
       },
     };
     // biome-ignore lint/suspicious/noExplicitAny: <explanation>
   } catch (error: any) {
+    logger.error(
+      `Failed to generate chart: ${error.message || "Unknown error"}.`,
+    );
     if (error instanceof McpError) throw error;
     if (error instanceof ValidateError)
       throw new McpError(ErrorCode.InvalidParams, error.message);

src/utils/logger.ts

@@ -0,0 +1,42 @@
+/**
+ * Unified logger for consistent logging across the application
+ */
+const prefix = "[MCP-Server-Chart]";
+
+/**
+ * Log info message
+ */
+function info(message: string, ...args: unknown[]): void {
+  console.log(`${prefix} ℹ️  ${message}`, ...args);
+}
+
+/**
+ * Log warning message
+ */
+function warn(message: string, ...args: unknown[]): void {
+  console.warn(`${prefix} ⚠️  ${message}`, ...args);
+}
+
+/**
+ * Log error message
+ */
+function error(message: string, error?: unknown): void {
+  console.error(`${prefix} ❌ ${message}`, error || "");
+}
+
+/**
+ * Log success message
+ */
+function success(message: string, ...args: unknown[]): void {
+  console.log(`${prefix} ✅ ${message}`, ...args);
+}
+
+/**
+ * Logger object for backward compatibility
+ */
+export const logger = {
+  info,
+  warn,
+  error,
+  success,
+};