Merge pull request #1 from QuantGeekDev/feature/mcp-cli

Feature/mcp cli

Author: QuantGeekDev

package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-framework",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Framework for building Model Context Protocol (MCP) servers in Typescript",
   "type": "module",
   "author": "Alex Andru <alex@andru.codes>",
@@ -15,6 +15,9 @@
   "files": [
     "dist"
   ],
+  "bin": {
+    "mcp-build": "./dist/cli/build.js"
+  },
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch",

src/cli/build.ts

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { spawnSync } from "child_process";
+import { readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+
+function runTsc() {
+  const tscPath = join(process.cwd(), "node_modules", ".bin", "tsc");
+  const tsc = spawnSync(tscPath, [], {
+    stdio: "inherit",
+    shell: true,
+  });
+
+  if (tsc.status !== 0) {
+    process.exit(tsc.status ?? 1);
+  }
+}
+
+function addShebang() {
+  const indexPath = join(process.cwd(), "dist", "index.js");
+  try {
+    const content = readFileSync(indexPath, "utf8");
+    const shebang = "#!/usr/bin/env node\n";
+
+    if (!content.startsWith(shebang)) {
+      writeFileSync(indexPath, shebang + content);
+      console.log("Added shebang to dist/index.js");
+    }
+  } catch (error) {
+    console.error("Error adding shebang:", error);
+    process.exit(1);
+  }
+}
+
+runTsc();
+
+addShebang();
+
+console.log("MCP Build complete");

src/core/MCPServer.ts

@@ -6,22 +6,34 @@ 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";
 
 export interface MCPServerConfig {
-  name: string;
-  version: string;
+  name?: string;
+  version?: string;
 }
 
 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 = {}) {
+    this.serverName = config.name ?? this.getDefaultName();
+    this.serverVersion = config.version ?? this.getDefaultVersion();
+
+    logger.info(
+      `Initializing MCP Server: ${this.serverName}@${this.serverVersion}`
+    );
 
-  constructor(config: MCPServerConfig) {
     this.server = new Server(
       {
-        name: config.name,
-        version: config.version,
+        name: this.serverName,
+        version: this.serverVersion,
       },
       {
         capabilities: {
@@ -36,6 +48,46 @@ export class MCPServer {
     this.setupHandlers();
   }
 
+  private readPackageJson(): any {
+    try {
+      const mainModulePath = process.argv[1];
+      const packagePath = join(dirname(mainModulePath), "..", "package.json");
+      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: ${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 packageJson = this.readPackageJson();
+      if (packageJson?.version) {
+        logger.info(`Using version from package.json: ${packageJson.version}`);
+        return packageJson.version;
+      }
+    } catch (error) {
+      logger.warn(`Error getting version from package.json: ${error}`);
+    }
+    return "0.0.0";
+  }
+
   private setupHandlers() {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
@@ -66,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;
     }
   }