@leanmcp/core 0.1.2 → 0.3.0

package/dist/index.mjs

@@ -392,7 +392,26 @@ function isInitializeRequest(body) {
   return body && body.method === "initialize";
 }
 __name(isInitializeRequest, "isInitializeRequest");
-async function createHTTPServer(serverFactory, options = {}) {
+async function createHTTPServer(serverInput, options) {
+  let serverFactory;
+  let httpOptions;
+  if (typeof serverInput === "function") {
+    serverFactory = serverInput;
+    httpOptions = options || {};
+  } else {
+    const serverOptions = serverInput;
+    const { MCPServer: MCPServer2 } = await import("./index.mjs");
+    serverFactory = /* @__PURE__ */ __name(async () => {
+      const mcpServer2 = new MCPServer2(serverOptions);
+      return mcpServer2.getServer();
+    }, "serverFactory");
+    httpOptions = {
+      port: serverOptions.port,
+      cors: serverOptions.cors,
+      logging: serverOptions.logging,
+      sessionTimeout: serverOptions.sessionTimeout
+    };
+  }
   const [express, { StreamableHTTPServerTransport }, cors] = await Promise.all([
     // @ts-ignore
     import("express").catch(() => {
@@ -403,19 +422,20 @@ async function createHTTPServer(serverFactory, options = {}) {
       throw new Error("MCP SDK not found. Install with: npm install @modelcontextprotocol/sdk");
     }),
     // @ts-ignore
-    options.cors ? import("cors").catch(() => null) : Promise.resolve(null)
+    httpOptions.cors ? import("cors").catch(() => null) : Promise.resolve(null)
   ]);
   const app = express.default();
-  const port = options.port || 3001;
+  const port = httpOptions.port || 3001;
   validatePort(port);
   const transports = {};
-  const logger = options.logger || new Logger({
-    level: options.logging ? LogLevel.INFO : LogLevel.NONE,
+  let mcpServer = null;
+  const logger = httpOptions.logger || new Logger({
+    level: httpOptions.logging ? LogLevel.INFO : LogLevel.NONE,
     prefix: "HTTP"
   });
-  if (cors && options.cors) {
-    const corsOptions = typeof options.cors === "object" ? {
-      origin: options.cors.origin || false,
+  if (cors && httpOptions.cors) {
+    const corsOptions = typeof httpOptions.cors === "object" ? {
+      origin: httpOptions.cors.origin || false,
       methods: [
         "GET",
         "POST",
@@ -431,7 +451,7 @@ async function createHTTPServer(serverFactory, options = {}) {
       exposedHeaders: [
         "mcp-session-id"
       ],
-      credentials: options.cors.credentials ?? false,
+      credentials: httpOptions.cors.credentials ?? false,
       maxAge: 86400
     } : false;
     if (corsOptions) {
@@ -450,6 +470,18 @@ async function createHTTPServer(serverFactory, options = {}) {
   const handleMCPRequest = /* @__PURE__ */ __name(async (req, res) => {
     const sessionId = req.headers["mcp-session-id"];
     let transport;
+    const method = req.body?.method || "unknown";
+    const params = req.body?.params;
+    let logMessage = `${req.method} /mcp - ${method}`;
+    if (params?.name) {
+      logMessage += ` [${params.name}]`;
+    } else if (params?.uri) {
+      logMessage += ` [${params.uri}]`;
+    }
+    if (sessionId) {
+      logMessage += ` (session: ${sessionId.substring(0, 8)}...)`;
+    }
+    logger.info(logMessage);
     try {
       if (sessionId && transports[sessionId]) {
         transport = transports[sessionId];
@@ -469,8 +501,10 @@ async function createHTTPServer(serverFactory, options = {}) {
             logger.debug(`Session cleaned up: ${transport.sessionId}`);
           }
         };
-        const server = await serverFactory();
-        await server.connect(transport);
+        if (!mcpServer) {
+          throw new Error("MCP server not initialized");
+        }
+        await mcpServer.connect(transport);
       } else {
         res.status(400).json({
           jsonrpc: "2.0",
@@ -499,18 +533,39 @@ async function createHTTPServer(serverFactory, options = {}) {
   }, "handleMCPRequest");
   app.post("/mcp", handleMCPRequest);
   app.delete("/mcp", handleMCPRequest);
-  process.on("SIGINT", () => {
-    logger.info("\nShutting down server...");
-    Object.values(transports).forEach((t) => t.close?.());
-    process.exit(0);
-  });
-  return new Promise((resolve) => {
-    app.listen(port, () => {
-      logger.info(`Server running on http://localhost:${port}`);
-      logger.info(`MCP endpoint: http://localhost:${port}/mcp`);
-      logger.info(`Health check: http://localhost:${port}/health`);
-      resolve();
-    });
+  return new Promise(async (resolve, reject) => {
+    try {
+      mcpServer = await serverFactory();
+      if (mcpServer && typeof mcpServer.waitForInit === "function") {
+        await mcpServer.waitForInit();
+      }
+      const listener = app.listen(port, () => {
+        logger.info(`Server running on http://localhost:${port}`);
+        logger.info(`MCP endpoint: http://localhost:${port}/mcp`);
+        logger.info(`Health check: http://localhost:${port}/health`);
+        resolve(listener);
+      });
+      listener.on("error", (error) => {
+        logger.error(`Server error: ${error.message}`);
+        reject(error);
+      });
+      const cleanup = /* @__PURE__ */ __name(() => {
+        logger.info("\nShutting down server...");
+        Object.values(transports).forEach((t) => t.close?.());
+        listener.close(() => {
+          logger.info("Server closed");
+          process.exit(0);
+        });
+        setTimeout(() => {
+          logger.warn("Forcing shutdown...");
+          process.exit(1);
+        }, 5e3);
+      }, "cleanup");
+      process.on("SIGINT", cleanup);
+      process.on("SIGTERM", cleanup);
+    } catch (error) {
+      reject(error);
+    }
   });
 }
 __name(createHTTPServer, "createHTTPServer");
@@ -527,10 +582,18 @@ var MCPServer = class {
   resources = /* @__PURE__ */ new Map();
   logging;
   logger;
+  options;
+  initPromise;
+  autoDiscovered = false;
   constructor(options) {
+    this.options = options;
     this.logging = options.logging || false;
+    let logLevel = LogLevel.NONE;
+    if (options.logging) {
+      logLevel = options.debug ? LogLevel.DEBUG : LogLevel.INFO;
+    }
     this.logger = new Logger({
-      level: this.logging ? LogLevel.INFO : LogLevel.NONE,
+      level: logLevel,
       prefix: "MCPServer"
     });
     this.server = new Server({
@@ -539,11 +602,84 @@ var MCPServer = class {
     }, {
       capabilities: {
         tools: {},
-        resources: {},
-        prompts: {}
+        prompts: {},
+        resources: {}
       }
     });
     this.setupHandlers();
+    this.initPromise = this.autoInit();
+  }
+  /**
+  * Internal initialization - runs automatically in constructor
+  */
+  async autoInit() {
+    const options = this.options;
+    if (options.autoDiscover !== false) {
+      await this.autoDiscoverServices(options.mcpDir, options.serviceFactories);
+    }
+  }
+  /**
+  * Wait for initialization to complete
+  * This is called internally by createHTTPServer
+  */
+  async waitForInit() {
+    await this.initPromise;
+  }
+  /**
+  * Automatically discover and register services from the mcp directory
+  * Called by init() unless autoDiscover is set to false
+  */
+  async autoDiscoverServices(customMcpDir, serviceFactories) {
+    if (this.autoDiscovered) return;
+    this.autoDiscovered = true;
+    try {
+      let mcpDir;
+      if (customMcpDir) {
+        mcpDir = customMcpDir;
+      } else {
+        const callerFile = this.getCallerFile();
+        if (callerFile) {
+          const callerDir = path.dirname(callerFile);
+          mcpDir = path.join(callerDir, "mcp");
+        } else {
+          mcpDir = path.join(process.cwd(), "mcp");
+        }
+      }
+      if (fs.existsSync(mcpDir)) {
+        this.logger.debug(`Auto-discovering services from: ${mcpDir}`);
+        await this.autoRegisterServices(mcpDir, serviceFactories);
+      } else {
+        this.logger.debug(`MCP directory not found at ${mcpDir}, skipping auto-discovery`);
+      }
+    } catch (error) {
+      this.logger.warn(`Auto-discovery failed: ${error.message}`);
+    }
+  }
+  /**
+  * Get the file path of the caller (the file that instantiated MCPServer)
+  */
+  getCallerFile() {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    try {
+      const err = new Error();
+      Error.prepareStackTrace = (_, stack2) => stack2;
+      const stack = err.stack;
+      for (let i = 0; i < stack.length; i++) {
+        let fileName = stack[i].getFileName();
+        if (fileName && !fileName.includes("@leanmcp") && !fileName.includes("leanmcp-sdk\\packages\\core") && !fileName.includes("leanmcp-sdk/packages/core") && (fileName.endsWith(".ts") || fileName.endsWith(".js") || fileName.endsWith(".mjs"))) {
+          if (fileName.startsWith("file://")) {
+            fileName = fileName.replace("file:///", "").replace("file://", "");
+            if (process.platform === "win32" && fileName.startsWith("/")) {
+              fileName = fileName.substring(1);
+            }
+          }
+          return fileName;
+        }
+      }
+      return null;
+    } finally {
+      Error.prepareStackTrace = originalPrepareStackTrace;
+    }
   }
   setupHandlers() {
     this.server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -688,6 +824,90 @@ var MCPServer = class {
     });
   }
   /**
+  * Auto-register all services from the mcp directory
+  * Scans the directory recursively and registers all exported classes
+  * 
+  * @param mcpDir - Path to the mcp directory containing service files
+  * @param serviceFactories - Optional map of service class names to factory functions for dependency injection
+  * 
+  * @example
+  * // Auto-register services with no dependencies
+  * await server.autoRegisterServices('./mcp');
+  * 
+  * @example
+  * // Auto-register with dependency injection
+  * await server.autoRegisterServices('./mcp', {
+  *   SlackService: () => new SlackService(process.env.SLACK_TOKEN),
+  *   AuthService: () => new AuthService(authProvider)
+  * });
+  */
+  async autoRegisterServices(mcpDir, serviceFactories) {
+    this.logger.debug(`Auto-registering services from: ${mcpDir}`);
+    if (!fs.existsSync(mcpDir)) {
+      this.logger.warn(`MCP directory not found: ${mcpDir}`);
+      return;
+    }
+    const serviceFiles = this.findServiceFiles(mcpDir);
+    this.logger.debug(`Found ${serviceFiles.length} service file(s)`);
+    for (const filePath of serviceFiles) {
+      try {
+        await this.loadAndRegisterService(filePath, serviceFactories);
+      } catch (error) {
+        this.logger.error(`Failed to load service from ${filePath}: ${error.message}`);
+      }
+    }
+  }
+  /**
+  * Recursively find all index.ts/index.js files in the mcp directory
+  */
+  findServiceFiles(dir) {
+    const files = [];
+    const entries = fs.readdirSync(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...this.findServiceFiles(fullPath));
+      } else if (entry.isFile()) {
+        if (entry.name === "index.ts" || entry.name === "index.js") {
+          files.push(fullPath);
+        }
+      }
+    }
+    return files;
+  }
+  /**
+  * Load a service file and register all exported classes
+  */
+  async loadAndRegisterService(filePath, serviceFactories) {
+    this.logger.debug(`Loading service from: ${filePath}`);
+    const fileUrl = pathToFileURL(filePath).href;
+    const module = await import(fileUrl);
+    let registeredCount = 0;
+    for (const [exportName, exportValue] of Object.entries(module)) {
+      if (typeof exportValue === "function" && exportValue.prototype) {
+        try {
+          let instance;
+          if (serviceFactories && serviceFactories[exportName]) {
+            instance = serviceFactories[exportName]();
+            this.logger.info(`Using factory for service: ${exportName}`);
+          } else {
+            instance = new exportValue();
+          }
+          this.registerService(instance);
+          registeredCount++;
+          this.logger.debug(`Registered service: ${exportName} from ${path.basename(filePath)}`);
+        } catch (error) {
+          this.logger.warn(`Skipped ${exportName}: ${error.message}`);
+        }
+      }
+    }
+    if (registeredCount === 0) {
+      this.logger.warn(`No services registered from ${filePath}`);
+    }
+  }
+  /**
   * Register a service instance with decorated methods
   */
   registerService(instance) {
@@ -709,7 +929,7 @@ var MCPServer = class {
         propertyKey
       });
       if (this.logging) {
-        this.logger.info(`Registered tool: ${methodMeta.toolName}${inputClass ? " (class-based schema)" : ""}`);
+        this.logger.debug(`Registered tool: ${methodMeta.toolName}${inputClass ? " (class-based schema)" : ""}`);
       }
     }
     const promptMethods = getDecoratedMethods(cls, "prompt:name");
@@ -734,7 +954,7 @@ var MCPServer = class {
         propertyKey
       });
       if (this.logging) {
-        this.logger.info(`Registered prompt: ${methodMeta.promptName}`);
+        this.logger.debug(`Registered prompt: ${methodMeta.promptName}`);
       }
     }
     const resourceMethods = getDecoratedMethods(cls, "resource:uri");
@@ -757,14 +977,16 @@ var MCPServer = class {
         propertyKey
       });
       if (this.logging) {
-        this.logger.info(`Registered resource: ${methodMeta.resourceUri}`);
+        this.logger.debug(`Registered resource: ${methodMeta.resourceUri}`);
       }
     }
   }
   /**
   * Get the underlying MCP SDK Server instance
+  * Attaches waitForInit method for HTTP server initialization
   */
   getServer() {
+    this.server.waitForInit = () => this.waitForInit();
     return this.server;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/core",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "Core library implementing decorators, reflection, and MCP runtime server",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -24,14 +24,14 @@
     "test:watch": "jest --watch"
   },
   "dependencies": {
-    "reflect-metadata": "^0.2.1",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "ajv": "^8.12.0",
     "dotenv": "^16.3.1",
-    "ajv": "^8.12.0"
+    "reflect-metadata": "^0.2.1"
   },
   "peerDependencies": {
-    "express": "^5.0.0",
-    "cors": "^2.8.5"
+    "cors": "^2.8.5",
+    "express": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "express": {
@@ -42,9 +42,9 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
+    "@types/cors": "^2.8.0",
     "@types/express": "^5.0.0",
-    "@types/cors": "^2.8.0"
+    "@types/node": "^20.0.0"
   },
   "repository": {
     "type": "git",

package/dist/chunk-O6YSETKJ.mjs

@@ -1,6 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-export {
-  __name
-};