@nestjs-mcp/server 0.1.1 → 0.2.0-alpha.1

package/src/registry/discovery.service.ts

@@ -1,116 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import {
-  MetadataScanner,
-  DiscoveryService as NestDiscoveryService,
-  Reflector,
-} from '@nestjs/core';
-import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
-
-export interface MethodWithMetadata<T = unknown> {
-  method: string;
-  metadata: T;
-  handler: (...args: any[]) => any;
-  instance: object;
-}
-
-type ProviderInstance = Record<string, unknown>;
-
-@Injectable()
-export class DiscoveryService {
-  constructor(
-    private readonly discoveryService: NestDiscoveryService,
-    private readonly metadataScanner: MetadataScanner,
-    private readonly reflector: Reflector,
-  ) {}
-
-  /**
-   * Get all methods with specific metadata from all providers (now scans all @Injectable, not just @McpProvider)
-   */
-  public getAllMethodsWithMetadata<T = unknown>(
-    metadataKey: string,
-  ): MethodWithMetadata<T>[] {
-    const providers = this.discoveryService.getProviders();
-    const result: MethodWithMetadata<T>[] = [];
-
-    // Scan ALL providers, not just those with MCP_PROVIDER
-    for (const provider of providers) {
-      if (!provider.instance) {
-        continue;
-      }
-
-      const methods = this.getMethodsWithMetadataFromProvider<T>(
-        provider,
-        metadataKey,
-      );
-
-      if (methods.length > 0) {
-        result.push(...methods);
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * Get all methods with a specific metadata from a single provider.
-   */
-  public getMethodsWithMetadataFromProvider<T = unknown>(
-    provider: InstanceWrapper,
-    metadataKey: string,
-  ): MethodWithMetadata<T>[] {
-    if (!provider.instance) {
-      return [];
-    }
-
-    const instance = provider.instance as ProviderInstance;
-    const instancePrototype = Object.getPrototypeOf(instance) as Record<
-      string,
-      unknown
-    >;
-
-    if (!instancePrototype) {
-      return [];
-    }
-
-    const methodNames =
-      this.metadataScanner.getAllMethodNames(instancePrototype);
-    const result: MethodWithMetadata<T>[] = [];
-
-    for (const methodName of methodNames) {
-      // Removed hasOwnProperty check to allow inherited methods
-      const methodFunction = instancePrototype[methodName];
-      if (typeof methodFunction !== 'function') {
-        continue;
-      }
-
-      const metadata = this.reflector.get<T>(metadataKey, methodFunction);
-
-      if (metadata) {
-        const handlerProperty = instance[methodName];
-
-        if (typeof handlerProperty !== 'function') {
-          continue;
-        }
-
-        const handler = ((...args: unknown[]): unknown => {
-          return handlerProperty.apply(instance, args);
-        }) as (...args: any[]) => any;
-
-        // Preserve the original method name
-        Object.defineProperty(handler, 'name', {
-          value: methodName,
-          writable: false,
-        });
-
-        result.push({
-          method: methodName,
-          metadata: metadata as T,
-          handler,
-          instance,
-        });
-      }
-    }
-
-    return result;
-  }
-}

package/src/registry/index.ts

@@ -1,2 +0,0 @@
-export * from './discovery.service';
-export * from './registry.service';

package/src/registry/logger.service.ts

@@ -1,143 +0,0 @@
-import {
-  Inject,
-  Injectable,
-  Logger,
-  LoggerService,
-  Optional,
-} from '@nestjs/common';
-
-import { McpLoggingOptions } from '../interfaces/mcp-server-options.interface';
-
-/**
- * Servicio especializado de logging para el servidor MCP
- */
-@Injectable()
-export class McpLoggerService implements LoggerService {
-  private readonly logger: Logger;
-  private readonly options: Required<McpLoggingOptions>;
-
-  constructor(
-    @Optional() @Inject('MCP_LOGGING_OPTIONS') options?: McpLoggingOptions,
-  ) {
-    this.options = {
-      enabled: options?.enabled !== false, // Habilitado por defecto
-      level: options?.level || 'verbose',
-    };
-
-    this.logger = new Logger('MCP');
-  }
-
-  /**
-   * Registra un mensaje de nivel debug
-   */
-  debug(message: string, context?: string): void {
-    if (
-      !this.options.enabled ||
-      this.getLevelValue(this.options.level) > this.getLevelValue('debug')
-    ) {
-      return;
-    }
-
-    const formattedContext = this.formatContext(context);
-    this.logger.debug(message, formattedContext);
-  }
-
-  /**
-   * Registra un mensaje de nivel verbose (detallado)
-   */
-  verbose(message: string, context?: string): void {
-    if (
-      !this.options.enabled ||
-      this.getLevelValue(this.options.level) > this.getLevelValue('verbose')
-    ) {
-      return;
-    }
-
-    const formattedContext = this.formatContext(context);
-    this.logger.verbose(message, formattedContext);
-  }
-
-  /**
-   * Registra un mensaje de nivel log (información)
-   */
-  log(message: string, context?: string): void {
-    if (
-      !this.options.enabled ||
-      this.getLevelValue(this.options.level) > this.getLevelValue('log')
-    ) {
-      return;
-    }
-
-    const formattedContext = this.formatContext(context);
-    this.logger.log(message, formattedContext);
-  }
-
-  /**
-   * Registra un mensaje de nivel warn (advertencia)
-   */
-  warn(message: string, context?: string): void {
-    if (
-      !this.options.enabled ||
-      this.getLevelValue(this.options.level) > this.getLevelValue('warn')
-    ) {
-      return;
-    }
-
-    const formattedContext = this.formatContext(context);
-    this.logger.warn(message, formattedContext);
-  }
-
-  /**
-   * Registra un mensaje de nivel error
-   */
-  error(message: string, trace?: string, context?: string): void {
-    if (
-      !this.options.enabled ||
-      this.getLevelValue(this.options.level) > this.getLevelValue('error')
-    ) {
-      return;
-    }
-
-    const formattedContext = this.formatContext(context);
-    this.logger.error(message, trace, formattedContext);
-  }
-
-  /**
-   * Método para determinar si el logging está habilitado
-   */
-  isEnabled(): boolean {
-    return this.options.enabled;
-  }
-
-  /**
-   * Método para obtener el nivel actual de logging
-   */
-  getLevel(): string {
-    return this.options.level;
-  }
-
-  /**
-   * Formatea el contexto para añadirle el prefijo '@mcp'
-   */
-  private formatContext(context?: string): string {
-    if (!context) {
-      return '@mcp';
-    }
-    return `@mcp:${context}`;
-  }
-
-  /**
-   * Convierte un nivel de log a un valor numérico para comparaciones
-   */
-  private getLevelValue(level: string): number {
-    const levels: Record<string, number> = {
-      debug: 0,
-      verbose: 1,
-      log: 2,
-      warn: 3,
-      error: 4,
-    };
-
-    return levels[level] ?? 2; // Por defecto, nivel 'log'
-  }
-}

package/src/registry/registry.service.ts

@@ -1,366 +0,0 @@
-import {
-  McpServer,
-  ResourceTemplate,
-} from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { CanActivate, Type } from '@nestjs/common';
-import { Injectable } from '@nestjs/common';
-import { Reflector } from '@nestjs/core';
-
-import { MCP_RESOLVER } from '../decorators';
-import {
-  MCP_PROMPT,
-  MCP_RESOURCE,
-  MCP_TOOL,
-} from '../decorators/capabilities.constants';
-import { MCP_GUARDS } from '../decorators/capabilities.decorators';
-import {
-  PromptHandlerParams,
-  PromptOptions,
-  RequestHandlerExtra,
-  ResourceOptions,
-  ResourceTemplateHandlerParams,
-  ResourceUriHandlerParams,
-  ToolHandlerParams,
-  ToolOptions,
-} from '../interfaces/capabilities.interface';
-import { McpExecutionContext } from '../interfaces/context.interface';
-import { SessionManager } from '../services/session.manager';
-import { DiscoveryService } from './discovery.service';
-import { McpLoggerService } from './logger.service';
-
-@Injectable()
-export class RegistryService {
-  constructor(
-    private readonly discoveryService: DiscoveryService,
-    private readonly logger: McpLoggerService,
-    private readonly reflector: Reflector,
-    private readonly sessionManager: SessionManager,
-  ) {}
-
-  async registerAll(server: McpServer): Promise<void> {
-    this.logger.log(
-      'Starting registration of all MCP capabilities...',
-      'registry',
-    );
-
-    await Promise.all([
-      this.registerResources(server),
-      this.registerPrompts(server),
-      this.registerTools(server),
-    ]);
-  }
-
-  private getDecoratorType(method: Type<any> | undefined): string | null {
-    if (!method) return null;
-
-    if (this.reflector.get(MCP_TOOL, method)) return 'TOOL';
-    if (this.reflector.get(MCP_PROMPT, method)) return 'PROMPT';
-    if (this.reflector.get(MCP_RESOURCE, method)) return 'RESOURCE';
-
-    return null;
-  }
-
-  private getHandlerArgs(
-    method: Type<any> | undefined,
-    args: unknown[],
-  ):
-    | ResourceUriHandlerParams
-    | ResourceTemplateHandlerParams
-    | PromptHandlerParams
-    | ToolHandlerParams {
-    if (!method) throw new Error('Method not found');
-
-    switch (this.getDecoratorType(method)) {
-      case 'RESOURCE':
-        return args[0] instanceof URL
-          ? ResourceUriHandlerParams.from(
-              args[0],
-              args[1] as RequestHandlerExtra,
-            )
-          : ResourceTemplateHandlerParams.from(
-              args[0] as any,
-              args[2] as RequestHandlerExtra,
-              args[1] as Record<string, string>,
-            );
-      case 'PROMPT':
-        return args.length === 1
-          ? PromptHandlerParams.from(args[0] as RequestHandlerExtra)
-          : PromptHandlerParams.from(
-              args[1] as RequestHandlerExtra,
-              args[0] as any,
-            );
-      case 'TOOL':
-        return args.length === 1
-          ? ToolHandlerParams.from(args[0] as RequestHandlerExtra)
-          : ToolHandlerParams.from(
-              args[1] as RequestHandlerExtra,
-              args[0] as any,
-            );
-      default:
-        throw new Error(`Unknown decorator type for method ${method.name}`);
-    }
-  }
-
-  /**
-   * Executes all guards attached to the resolver class and method.
-   * Throws an error if any guard denies access.
-   *
-   * @param instance The resolver instance
-   * @param methodName The method name being invoked
-   * @param args The arguments passed to the method
-   * @throws Error if any guard denies access
-   */
-  private runGuards(
-    instance: object,
-    methodName: string,
-    args: unknown[],
-  ): Promise<void> {
-    // Retrieve class-level guards
-    const classConstructor = instance.constructor;
-
-    const classGuards: (CanActivate | { new (): CanActivate })[] =
-      (Reflect.getMetadata(MCP_GUARDS, classConstructor) as (
-        | CanActivate
-        | { new (): CanActivate }
-      )[]) || [];
-
-    // Retrieve method-level guards
-    const prototype = Object.getPrototypeOf(instance) as Record<
-      string,
-      unknown
-    >;
-
-    const methodKey = prototype[methodName] as Type<any> | undefined;
-
-    const methodGuards: (CanActivate | { new (): CanActivate })[] =
-      (methodKey &&
-        (Reflect.getMetadata(MCP_GUARDS, methodKey) as (
-          | CanActivate
-          | { new (): CanActivate }
-        )[])) ||
-      [];
-
-    // Combine guards: class-level first, then method-level
-    const allGuards = [...classGuards, ...methodGuards];
-
-    if (!allGuards.length) return Promise.resolve();
-
-    const handlerArgs = this.getHandlerArgs(methodKey, args);
-
-    const { sessionId } = handlerArgs.extra;
-
-    if (!sessionId) {
-      throw new Error('Session not found');
-    }
-
-    const session = this.sessionManager.getSession(sessionId);
-
-    if (!session) {
-      throw new Error('Session not found');
-    }
-
-    const context: McpExecutionContext = {
-      args: handlerArgs,
-      // @ts-expect-error: Default types are 'http' | 'ws' | 'rpc' but in our case, we are using 'mcp'
-      getType: () => 'mcp',
-      getClass: () => instance.constructor as Type<any>,
-      getArgs: <T = any>() => args as T,
-      getArgByIndex: <T = any>(index: number) => args[index] as T,
-      getSessionId: () => sessionId,
-      getHandler: () => methodKey as unknown as Type<any>,
-      switchToHttp: () => ({
-        getRequest: <R = Request>() => session.request as R,
-        getResponse: () => {
-          throw new Error('Response not available in MCP context');
-        },
-        getNext: () => {
-          throw new Error('Next not available in MCP context');
-        },
-      }),
-    };
-
-    return (async () => {
-      for (const Guard of allGuards) {
-        const guardInstance: CanActivate =
-          typeof Guard === 'function' ? new Guard() : Guard;
-        const allowed = await guardInstance.canActivate(context);
-
-        if (!allowed)
-          throw new Error(`Access denied by guard on ${methodName}`);
-      }
-    })();
-  }
-
-  private async wrappedHandler<TArgs extends unknown[], TResult>(
-    instance: object,
-    handler: (...args: TArgs) => TResult,
-    args: unknown[],
-  ) {
-    const isResolver = Reflect.hasMetadata(MCP_RESOLVER, instance.constructor);
-
-    if (!isResolver) {
-      throw new Error(
-        `Class "${instance.constructor.name}" must be decorated with @Resolver to use @Prompt, @Tool, or @Resource.`,
-      );
-    }
-
-    const methodName = handler.name;
-
-    await this.runGuards(instance, methodName, args);
-
-    return handler(...(args as TArgs));
-  }
-
-  private registerResources(server: McpServer) {
-    const resourceMethods =
-      this.discoveryService.getAllMethodsWithMetadata<ResourceOptions>(
-        MCP_RESOURCE,
-      );
-    for (const method of resourceMethods) {
-      const { metadata, handler, instance } = method;
-
-      this.logger.log(
-        `Resource "${metadata?.name || 'unnamed'}" found.`,
-        'resources',
-      );
-
-      const wrappedHandler = (...args: unknown[]) =>
-        this.wrappedHandler(instance, handler, args);
-
-      try {
-        if ('template' in metadata) {
-          if ('metadata' in metadata) {
-            server.resource(
-              metadata.name,
-              new ResourceTemplate(metadata.template, { list: undefined }),
-              metadata.metadata,
-              wrappedHandler,
-            );
-          } else {
-            server.resource(
-              metadata.name,
-              new ResourceTemplate(metadata.template, { list: undefined }),
-              wrappedHandler,
-            );
-          }
-        } else if ('uri' in metadata) {
-          if ('metadata' in metadata) {
-            server.resource(
-              metadata.name,
-              metadata.uri,
-              metadata.metadata,
-              wrappedHandler,
-            );
-          } else {
-            server.resource(metadata.name, metadata.uri, wrappedHandler);
-          }
-        }
-      } catch (error) {
-        this.logger.error(
-          `Error registering resource ${metadata.name}: ${error}`,
-          undefined,
-          'resources',
-        );
-        if (error && typeof error === 'object' && 'stack' in error) {
-          this.logger.error(
-            `Error stack: ${(error as Error).stack}`,
-            undefined,
-            'resources',
-          );
-        }
-      }
-    }
-  }
-
-  private registerPrompts(server: McpServer) {
-    const promptMethods =
-      this.discoveryService.getAllMethodsWithMetadata<PromptOptions>(
-        MCP_PROMPT,
-      );
-    for (const method of promptMethods) {
-      const { metadata, handler, instance } = method;
-
-      this.logger.log(
-        `Prompt "${metadata?.name || 'unnamed'}" found.`,
-        'prompts',
-      );
-
-      const wrappedHandler = (...args: unknown[]) =>
-        this.wrappedHandler(instance, handler, args);
-
-      try {
-        if ('description' in metadata && 'argsSchema' in metadata) {
-          server.prompt(
-            metadata.name,
-            metadata.description,
-            metadata.argsSchema,
-            wrappedHandler,
-          );
-        } else if ('argsSchema' in metadata) {
-          server.prompt(metadata.name, metadata.argsSchema, wrappedHandler);
-        } else if ('description' in metadata) {
-          server.prompt(metadata.name, metadata.description, wrappedHandler);
-        } else {
-          server.prompt(metadata.name, wrappedHandler);
-        }
-      } catch (error) {
-        this.logger.error(
-          `Error registering prompt ${metadata.name}: ${error}`,
-          undefined,
-          'prompts',
-        );
-        if (error && typeof error === 'object' && 'stack' in error) {
-          this.logger.error(
-            `Error stack: ${(error as Error).stack}`,
-            undefined,
-            'prompts',
-          );
-        }
-      }
-    }
-  }
-
-  private registerTools(server: McpServer) {
-    const toolMethods =
-      this.discoveryService.getAllMethodsWithMetadata<ToolOptions>(MCP_TOOL);
-
-    for (const method of toolMethods) {
-      const { metadata, handler, instance } = method;
-
-      this.logger.log(`Tool "${metadata?.name || 'unnamed'}" found.`, 'tools');
-
-      const wrappedHandler = (...args: unknown[]) =>
-        this.wrappedHandler(instance, handler, args);
-
-      try {
-        if ('description' in metadata && 'paramSchema' in metadata) {
-          server.tool(
-            metadata.name,
-            metadata.description,
-            metadata.paramSchema,
-            wrappedHandler,
-          );
-        } else if ('paramSchema' in metadata) {
-          server.tool(metadata.name, metadata.paramSchema, wrappedHandler);
-        } else if ('description' in metadata) {
-          server.tool(metadata.name, metadata.description, wrappedHandler);
-        } else {
-          server.tool(metadata.name, wrappedHandler);
-        }
-      } catch (error) {
-        this.logger.error(
-          `Error registering tool ${metadata.name}: ${error}`,
-          undefined,
-          'tools',
-        );
-        if (error && typeof error === 'object' && 'stack' in error) {
-          this.logger.error(
-            `Stack trace: ${(error as Error).stack}`,
-            undefined,
-            'tools',
-          );
-        }
-      }
-    }
-  }
-}

package/src/services/session.manager.ts

@@ -1,26 +0,0 @@
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { Injectable } from '@nestjs/common';
-import { Request } from 'express';
-
-type Session = {
-  transport: StreamableHTTPServerTransport | SSEServerTransport;
-  request: Request;
-};
-
-@Injectable()
-export class SessionManager {
-  private sessions = new Map<string, Session>();
-
-  public getSession(sessionId: string): Session | undefined {
-    return this.sessions.get(sessionId);
-  }
-
-  public setSession(sessionId: string, session: Session): void {
-    this.sessions.set(sessionId, session);
-  }
-
-  public deleteSession(sessionId: string): void {
-    this.sessions.delete(sessionId);
-  }
-}