@leanmcp/core 0.1.1 → 0.2.0

package/README.md

@@ -75,19 +75,68 @@ export class SentimentService {
 
 ### 2. Create and Start Server
 
+#### Option A: Zero-Config Auto-Discovery (Recommended)
+
+Automatically discover and register all services from the `./mcp` directory:
+
+```typescript
+import { createHTTPServer, MCPServer } from "@leanmcp/core";
+
+// Create MCP server with auto-discovery
+const serverFactory = async () => {
+  const server = new MCPServer({
+    name: "my-mcp-server",
+    version: "1.0.0",
+    logging: true  // Enable HTTP server logs
+  });
+
+  // Services are automatically discovered and registered from ./mcp directory
+  return server.getServer();
+};
+
+// Start HTTP server
+await createHTTPServer(serverFactory, {
+  port: 3000,
+  cors: true,
+  logging: true  // Log HTTP requests
+});
+
+console.log('\nMCP Server running');
+console.log('HTTP endpoint: http://localhost:3000/mcp');
+console.log('Health check: http://localhost:3000/health');
+```
+
+**Directory Structure:**
+```
+your-project/
+├── main.ts
+└── mcp/
+    ├── sentiment/
+    │   └── index.ts    # export class SentimentService
+    ├── weather/
+    │   └── index.ts    # export class WeatherService
+    └── database/
+        └── index.ts    # export class DatabaseService
+```
+
+#### Option B: Manual Registration
+
+Manually import and register each service:
+
 ```typescript
 import { createHTTPServer, MCPServer } from "@leanmcp/core";
 import { SentimentService } from "./services/sentiment";
 
 // Create MCP server
-const serverFactory = () => {
+const serverFactory = async () => {
   const server = new MCPServer({
     name: "my-mcp-server",
     version: "1.0.0",
-    logging: true
+    logging: true,
+    autoDiscover: false  // Disable auto-discovery for manual registration
   });
 
-  // Register services
+  // Register services manually
   server.registerService(new SentimentService());
 
   return server.getServer();
@@ -97,7 +146,7 @@ const serverFactory = () => {
 await createHTTPServer(serverFactory, {
   port: 3000,
   cors: true,
-  logging: true
+  logging: true  // Log HTTP requests
 });
 ```
 
@@ -220,13 +269,137 @@ Main server class for registering services.
 
 ```typescript
 const server = new MCPServer({
-  name: string;        // Server name
-  version: string;     // Server version
-  logging?: boolean;   // Enable logging (default: false)
+  name: string;           // Server name
+  version: string;        // Server version
+  logging?: boolean;      // Enable logging (default: false)
+  debug?: boolean;        // Enable verbose debug logs (default: false)
+  autoDiscover?: boolean; // Enable auto-discovery (default: true)
+  mcpDir?: string;        // Custom mcp directory path (optional)
 });
 
+// Manual registration
 server.registerService(instance: any): void;
-server.getServer(): Server;  // Get underlying MCP SDK server
+
+// Get underlying MCP SDK server
+server.getServer(): Server;
+```
+
+**Options:**
+
+- **`logging`**: Enable basic logging for server operations
+- **`debug`**: Enable verbose debug logs showing detailed service registration (requires `logging: true`)
+- **`autoDiscover`**: Automatically discover and register services from `./mcp` directory (default: `true`)
+- **`mcpDir`**: Custom path to the mcp directory (default: auto-detected `./mcp`)
+
+#### Zero-Config Auto-Discovery
+
+Services are automatically discovered and registered from the `./mcp` directory when the server is created:
+
+**Basic Usage:**
+```typescript
+const serverFactory = async () => {
+  const server = new MCPServer({
+    name: "my-server",
+    version: "1.0.0",
+    logging: true  // Enable logging
+  });
+
+  // Services are automatically discovered and registered
+  return server.getServer();
+};
+```
+
+**With Debug Logging:**
+```typescript
+const serverFactory = async () => {
+  const server = new MCPServer({
+    name: "my-server",
+    version: "1.0.0",
+    logging: true,
+    debug: true  // Show detailed service registration logs
+  });
+
+  return server.getServer();
+};
+```
+
+**With Shared Dependencies:**
+
+For services that need shared dependencies, create a `config.ts` (example) file in your `mcp` directory:
+
+```typescript
+// mcp/config.ts
+import { AuthProvider } from "@leanmcp/auth";
+
+if (!process.env.COGNITO_USER_POOL_ID || !process.env.COGNITO_CLIENT_ID) {
+  throw new Error('Missing required Cognito configuration');
+}
+
+export const authProvider = new AuthProvider('cognito', {
+  region: process.env.AWS_REGION || 'us-east-1',
+  userPoolId: process.env.COGNITO_USER_POOL_ID,
+  clientId: process.env.COGNITO_CLIENT_ID,
+  clientSecret: process.env.COGNITO_CLIENT_SECRET
+});
+
+await authProvider.init();
+```
+
+Then import in your services:
+
+```typescript
+// mcp/slack/index.ts
+import { Tool } from "@leanmcp/core";
+import { Authenticated } from "@leanmcp/auth";
+import { authProvider } from "../config.js";
+
+@Authenticated(authProvider)
+export class SlackService {
+  constructor() {
+    // No parameters needed - use environment or imported config
+  }
+
+  @Tool({ description: 'Send a message' })
+  async sendMessage(args: any) {
+    // Implementation
+  }
+}
+```
+
+Your main file stays clean:
+
+```typescript
+const serverFactory = async () => {
+  const server = new MCPServer({
+    name: "my-server",
+    version: "1.0.0",
+    logging: true
+  });
+
+  // Services are automatically discovered and registered
+  return server.getServer();
+};
+```
+
+**How It Works:**
+- Automatically discovers and registers services from the `./mcp` directory during server initialization
+- Recursively scans for `index.ts` or `index.js` files
+- Dynamically imports each file and looks for exported classes
+- Instantiates services with no-args constructors
+- Registers all discovered services with their decorated methods
+
+**Directory Structure:**
+```
+your-project/
+├── main.ts
+└── mcp/
+    ├── config.ts      # Optional: shared dependencies
+    ├── slack/
+    │   └── index.ts   # export class SlackService
+    ├── database/
+    │   └── index.ts   # export class DatabaseService
+    └── auth/
+        └── index.ts   # export class AuthService
 ```
 
 ### createHTTPServer
@@ -235,11 +408,11 @@ Create and start an HTTP server with streamable transport.
 
 ```typescript
 await createHTTPServer(
-  serverFactory: () => Server,
+  serverFactory: () => Server | Promise<Server>,
   options: {
     port?: number;      // Port number (default: 3000)
     cors?: boolean;     // Enable CORS (default: false)
-    logging?: boolean;  // Enable logging (default: true)
+    logging?: boolean;  // Enable HTTP request logging (default: false)
   }
 );
 ```

package/dist/index.d.mts

@@ -225,8 +225,9 @@ interface MCPServerFactory {
 }
 /**
  * Create an HTTP server for MCP with Streamable HTTP transport
+ * Returns the HTTP server instance to keep the process alive
  */
-declare function createHTTPServer(serverFactory: MCPServerFactory, options?: HTTPServerOptions): Promise<void>;
+declare function createHTTPServer(serverFactory: MCPServerFactory, options?: HTTPServerOptions): Promise<any>;
 
 /**
  * Input validation utilities for LeanMCP
@@ -315,6 +316,15 @@ interface MCPServerOptions {
     cors?: boolean;
     logging?: boolean;
 }
+interface MCPServerConstructorOptions {
+    name: string;
+    version: string;
+    logging?: boolean;
+    debug?: boolean;
+    autoDiscover?: boolean;
+    mcpDir?: string;
+    serviceFactories?: Record<string, () => any>;
+}
 interface RegisteredTool {
     name: string;
     description: string;
@@ -352,18 +362,63 @@ declare class MCPServer {
     private resources;
     private logging;
     private logger;
-    constructor(options: {
-        name: string;
-        version: string;
-        logging?: boolean;
-    });
+    private options;
+    private initPromise;
+    private autoDiscovered;
+    constructor(options: MCPServerConstructorOptions);
+    /**
+     * Internal initialization - runs automatically in constructor
+     */
+    private autoInit;
+    /**
+     * Wait for initialization to complete
+     * This is called internally by createHTTPServer
+     */
+    waitForInit(): Promise<void>;
+    /**
+     * Automatically discover and register services from the mcp directory
+     * Called by init() unless autoDiscover is set to false
+     */
+    private autoDiscoverServices;
+    /**
+     * Get the file path of the caller (the file that instantiated MCPServer)
+     */
+    private getCallerFile;
     private setupHandlers;
+    /**
+     * 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)
+     * });
+     */
+    autoRegisterServices(mcpDir: string, serviceFactories?: Record<string, () => any>): Promise<void>;
+    /**
+     * Recursively find all index.ts/index.js files in the mcp directory
+     */
+    private findServiceFiles;
+    /**
+     * Load a service file and register all exported classes
+     */
+    private loadAndRegisterService;
     /**
      * Register a service instance with decorated methods
      */
     registerService(instance: any): void;
     /**
      * Get the underlying MCP SDK Server instance
+     * Attaches waitForInit method for HTTP server initialization
      */
     getServer(): Server<{
         method: string;
@@ -432,4 +487,4 @@ declare class MCPServerRuntime {
  */
 declare function startMCPServer(options: MCPServerOptions): Promise<MCPServerRuntime>;
 
-export { Auth, type AuthOptions, Deprecated, type HTTPServerOptions, LogLevel, Logger, type LoggerOptions, MCPServer, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, Render, Resource, type ResourceOptions, SchemaConstraint, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createHTTPServer, defaultLogger, getDecoratedMethods, getMethodMetadata, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };
+export { Auth, type AuthOptions, Deprecated, type HTTPServerOptions, LogLevel, Logger, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, Render, Resource, type ResourceOptions, SchemaConstraint, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createHTTPServer, defaultLogger, getDecoratedMethods, getMethodMetadata, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };

package/dist/index.d.ts

@@ -225,8 +225,9 @@ interface MCPServerFactory {
 }
 /**
  * Create an HTTP server for MCP with Streamable HTTP transport
+ * Returns the HTTP server instance to keep the process alive
  */
-declare function createHTTPServer(serverFactory: MCPServerFactory, options?: HTTPServerOptions): Promise<void>;
+declare function createHTTPServer(serverFactory: MCPServerFactory, options?: HTTPServerOptions): Promise<any>;
 
 /**
  * Input validation utilities for LeanMCP
@@ -315,6 +316,15 @@ interface MCPServerOptions {
     cors?: boolean;
     logging?: boolean;
 }
+interface MCPServerConstructorOptions {
+    name: string;
+    version: string;
+    logging?: boolean;
+    debug?: boolean;
+    autoDiscover?: boolean;
+    mcpDir?: string;
+    serviceFactories?: Record<string, () => any>;
+}
 interface RegisteredTool {
     name: string;
     description: string;
@@ -352,18 +362,63 @@ declare class MCPServer {
     private resources;
     private logging;
     private logger;
-    constructor(options: {
-        name: string;
-        version: string;
-        logging?: boolean;
-    });
+    private options;
+    private initPromise;
+    private autoDiscovered;
+    constructor(options: MCPServerConstructorOptions);
+    /**
+     * Internal initialization - runs automatically in constructor
+     */
+    private autoInit;
+    /**
+     * Wait for initialization to complete
+     * This is called internally by createHTTPServer
+     */
+    waitForInit(): Promise<void>;
+    /**
+     * Automatically discover and register services from the mcp directory
+     * Called by init() unless autoDiscover is set to false
+     */
+    private autoDiscoverServices;
+    /**
+     * Get the file path of the caller (the file that instantiated MCPServer)
+     */
+    private getCallerFile;
     private setupHandlers;
+    /**
+     * 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)
+     * });
+     */
+    autoRegisterServices(mcpDir: string, serviceFactories?: Record<string, () => any>): Promise<void>;
+    /**
+     * Recursively find all index.ts/index.js files in the mcp directory
+     */
+    private findServiceFiles;
+    /**
+     * Load a service file and register all exported classes
+     */
+    private loadAndRegisterService;
     /**
      * Register a service instance with decorated methods
      */
     registerService(instance: any): void;
     /**
      * Get the underlying MCP SDK Server instance
+     * Attaches waitForInit method for HTTP server initialization
      */
     getServer(): Server<{
         method: string;
@@ -432,4 +487,4 @@ declare class MCPServerRuntime {
  */
 declare function startMCPServer(options: MCPServerOptions): Promise<MCPServerRuntime>;
 
-export { Auth, type AuthOptions, Deprecated, type HTTPServerOptions, LogLevel, Logger, type LoggerOptions, MCPServer, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, Render, Resource, type ResourceOptions, SchemaConstraint, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createHTTPServer, defaultLogger, getDecoratedMethods, getMethodMetadata, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };
+export { Auth, type AuthOptions, Deprecated, type HTTPServerOptions, LogLevel, Logger, type LoggerOptions, MCPServer, type MCPServerConstructorOptions, type MCPServerFactory, type MCPServerOptions, MCPServerRuntime, Optional, Prompt, type PromptOptions, Render, Resource, type ResourceOptions, SchemaConstraint, Tool, type ToolOptions, UI, UserEnvs, classToJsonSchema, classToJsonSchemaWithConstraints, createHTTPServer, defaultLogger, getDecoratedMethods, getMethodMetadata, startMCPServer, validateNonEmpty, validatePath, validatePort, validateServiceName, validateUrl };

package/dist/index.js

@@ -466,6 +466,7 @@ async function createHTTPServer(serverFactory, options = {}) {
   const port = options.port || 3001;
   validatePort(port);
   const transports = {};
+  let mcpServer = null;
   const logger = options.logger || new Logger({
     level: options.logging ? LogLevel.INFO : LogLevel.NONE,
     prefix: "HTTP"
@@ -507,6 +508,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];
@@ -526,8 +539,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",
@@ -556,18 +571,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");
@@ -584,10 +620,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 import_server.Server({
@@ -596,11 +640,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 = import_path.default.dirname(callerFile);
+          mcpDir = import_path.default.join(callerDir, "mcp");
+        } else {
+          mcpDir = import_path.default.join(process.cwd(), "mcp");
+        }
+      }
+      if (import_fs.default.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(import_types.ListToolsRequestSchema, async () => {
@@ -634,7 +751,7 @@ var MCPServer = class {
         }
       }
       try {
-        const meta = request.params.arguments?._meta;
+        const meta = request.params._meta;
         const result = await tool.method.call(tool.instance, request.params.arguments, meta);
         let formattedResult = result;
         if (methodMeta.renderFormat === "markdown" && typeof result === "string") {
@@ -745,6 +862,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 (!import_fs.default.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 = import_fs.default.readdirSync(dir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const fullPath = import_path.default.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 = (0, import_url.pathToFileURL)(filePath).href;
+    const module2 = await import(fileUrl);
+    let registeredCount = 0;
+    for (const [exportName, exportValue] of Object.entries(module2)) {
+      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 ${import_path.default.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) {
@@ -766,7 +967,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");
@@ -791,7 +992,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");
@@ -814,14 +1015,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;
   }
 };
@@ -890,7 +1093,7 @@ var MCPServerRuntime = class {
         }
       }
       try {
-        const meta = request.params.arguments?._meta;
+        const meta = request.params._meta;
         const result = await tool.method.call(tool.instance, request.params.arguments, meta);
         if (result && typeof result === "object" && result.type === "elicitation") {
           return {

package/dist/index.mjs

@@ -409,6 +409,7 @@ async function createHTTPServer(serverFactory, options = {}) {
   const port = options.port || 3001;
   validatePort(port);
   const transports = {};
+  let mcpServer = null;
   const logger = options.logger || new Logger({
     level: options.logging ? LogLevel.INFO : LogLevel.NONE,
     prefix: "HTTP"
@@ -450,6 +451,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 +482,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 +514,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 +563,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 +583,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 () => {
@@ -577,7 +694,7 @@ var MCPServer = class {
         }
       }
       try {
-        const meta = request.params.arguments?._meta;
+        const meta = request.params._meta;
         const result = await tool.method.call(tool.instance, request.params.arguments, meta);
         let formattedResult = result;
         if (methodMeta.renderFormat === "markdown" && typeof result === "string") {
@@ -688,6 +805,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 +910,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 +935,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 +958,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;
   }
 };
@@ -833,7 +1036,7 @@ var MCPServerRuntime = class {
         }
       }
       try {
-        const meta = request.params.arguments?._meta;
+        const meta = request.params._meta;
         const result = await tool.method.call(tool.instance, request.params.arguments, meta);
         if (result && typeof result === "object" && result.type === "elicitation") {
           return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leanmcp/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Core library implementing decorators, reflection, and MCP runtime server",
   "main": "dist/index.js",
   "module": "dist/index.mjs",