feat: read default name and version from package json

Author: QuantGeekDev

package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-framework",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Framework for building Model Context Protocol (MCP) servers in Typescript",
   "type": "module",
   "author": "Alex Andru <alex@andru.codes>",

src/core/MCPServer.ts

@@ -6,6 +6,7 @@ import {
 } from "@modelcontextprotocol/sdk/types.js";
 import { ToolLoader } from "./toolLoader.js";
 import { BaseTool } from "../tools/BaseTool.js";
+import { readFileSync } from "fs";
 import { join, dirname } from "path";
 import { logger } from "./Logger.js";
 
@@ -18,51 +19,73 @@ export class MCPServer {
   private server: Server;
   private toolsMap: Map<string, BaseTool> = new Map();
   private toolLoader: ToolLoader;
+  private serverName: string;
+  private serverVersion: string;
 
   constructor(config: MCPServerConfig = {}) {
-    const serverConfig = {
-      name: config.name ?? this.getDefaultName(),
-      version: config.version ?? this.getDefaultVersion(),
-    };
+    this.serverName = config.name ?? this.getDefaultName();
+    this.serverVersion = config.version ?? this.getDefaultVersion();
 
-    this.server = new Server(serverConfig, {
-      capabilities: {
-        tools: {
-          enabled: true,
-        },
+    logger.info(
+      `Initializing MCP Server: ${this.serverName}@${this.serverVersion}`
+    );
+
+    this.server = new Server(
+      {
+        name: this.serverName,
+        version: this.serverVersion,
       },
-    });
+      {
+        capabilities: {
+          tools: {
+            enabled: true,
+          },
+        },
+      }
+    );
 
     this.toolLoader = new ToolLoader();
     this.setupHandlers();
   }
 
-  private getDefaultName(): string {
+  private readPackageJson(): any {
     try {
       const mainModulePath = process.argv[1];
       const packagePath = join(dirname(mainModulePath), "..", "package.json");
-      const packageContent = require(packagePath);
-      logger.debug(`Found package.json with name: ${packageContent.name}`);
-      return packageContent.name;
+      const packageContent = readFileSync(packagePath, "utf-8");
+      const packageJson = JSON.parse(packageContent);
+      logger.debug(`Successfully read package.json from: ${packagePath}`);
+      return packageJson;
     } catch (error) {
-      logger.warn(`Could not read package.json for name: ${error}`);
-      return "unnamed-mcp-server";
+      logger.warn(`Could not read package.json: ${error}`);
+      return null;
     }
   }
 
+  private getDefaultName(): string {
+    try {
+      const packageJson = this.readPackageJson();
+      if (packageJson?.name) {
+        logger.info(`Using name from package.json: ${packageJson.name}`);
+        return packageJson.name;
+      }
+    } catch (error) {
+      logger.warn(`Error getting name from package.json: ${error}`);
+    }
+    return "unnamed-mcp-server";
+  }
+
   private getDefaultVersion(): string {
     try {
-      const mainModulePath = process.argv[1];
-      const packagePath = join(dirname(mainModulePath), "..", "package.json");
-      const packageContent = require(packagePath);
-      logger.debug(
-        `Found package.json with version: ${packageContent.version}`
-      );
-      return packageContent.version;
+      const packageJson = this.readPackageJson();
+      if (packageJson?.version) {
+        logger.info(`Using version from package.json: ${packageJson.version}`);
+        return packageJson.version;
+      }
     } catch (error) {
-      logger.warn(`Could not read package.json for version: ${error}`);
-      return "0.0.0";
+      logger.warn(`Error getting version from package.json: ${error}`);
     }
+    return "0.0.0";
   }
 
   private setupHandlers() {
@@ -95,9 +118,14 @@ export class MCPServer {
       const transport = new StdioServerTransport();
       await this.server.connect(transport);
 
-      process.stderr.write(`Server started with ${tools.length} tools\n`);
+      logger.info(
+        `Started ${this.serverName}@${this.serverVersion} with ${tools.length} tools`
+      );
+      logger.info(
+        `Available tools: ${Array.from(this.toolsMap.keys()).join(", ")}`
+      );
     } catch (error) {
-      process.stderr.write(`Server initialization error: ${error}\n`);
+      logger.error(`Server initialization error: ${error}`);
       throw error;
     }
   }