swagger_mcp_tool 0.1.1

data/lib/swagger_mcp_tool/helpers/tool_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SwaggerMCPTool
+  module Helpers
+    module ToolBuilder
+      private
+
+      def create_base_tool_definition(path, method, operation)
+        {
+          'name' => generate_operation_id(path, method, operation),
+          'description' => generate_description(path, method, operation),
+          'method' => method,
+          'path' => path,
+          'parameters' => create_empty_parameters_schema
+        }
+      end
+
+      def generate_operation_id(path, method, operation)
+        operation['operationId'] || generate_default_operation_id(path, method)
+      end
+
+      def generate_default_operation_id(path, method)
+        "#{method}_#{sanitize_path_for_id(path)}"
+      end
+
+      def sanitize_path_for_id(path)
+        path.gsub(/[^\w]/, '_')
+      end
+
+      def generate_description(path, method, operation)
+        operation['summary'] || operation['description'] || "#{method.upcase} #{path}"
+      end
+
+      def create_empty_parameters_schema
+        {
+          'type' => 'object',
+          'properties' => {},
+          'required' => []
+        }
+      end
+    end
+  end
+end

data/lib/swagger_mcp_tool/helpers/tool_register.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SwaggerMCPTool
+  module Helpers
+    module ToolRegister
+      def tool_registry
+        SwaggerMCPTool::ToolRegistry.instance
+      end
+
+      def setup_tool_registry
+        registry = tool_registry
+        registry.setup(@config) # <-- This is where setup gets called
+        @logger = @config.logger
+        log_message('Tool registry setup complete')
+      end
+
+      def initialize_tools
+        generate_tools_from_swagger_url
+      end
+
+      # Generate tools from a Swagger URL
+      def generate_tools_from_swagger_url
+        @config.logger.info "Generating tools from Swagger URL: #{@config.swagger_url}"
+        # Create a Swagger client
+        swagger_client = SwaggerClient.new(@config.swagger_url)
+
+        # Create a tool generator
+        tool_generator = ToolGenerator.new(swagger_client)
+
+        # Generate tools
+        tools = tool_generator.generate_tools
+
+        # Register the tools dynamically (simplified)
+        tool_registry.register_dynamic_tools(tools, swagger_client.base_url)
+      rescue StandardError => e
+        log_and_raise_error(e)
+      end
+    end
+  end
+end

data/lib/swagger_mcp_tool/logging.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# The SwaggerMCPTool module provides core functionality for the Swagger MCP Tool gem.
+# It serves as a namespace for organizing related components, such as logging utilities,
+# configuration management, and integration helpers for managing Swagger-based MCP services.
+
+module SwaggerMCPTool
+  # SwaggerMCPTool::Logging for logging-related methods and usage.
+  module Logging
+    def log_server_initialization
+      logger.info '=== SERVER INITIALIZATION ==='
+
+      server_config_items.each do |label, value|
+        logger.info "#{label}: #{value}"
+      end
+
+      logger.info '================================'
+    end
+
+    def log_and_raise_error(exception)
+      logger.error(exception.message)
+      raise exception
+    end
+
+    def log_message(message)
+      logger.info(message)
+    end
+
+    def log_request_details(context)
+      logger.debug 'API Request Details:'
+      logger.debug "  Method: #{context[:method].upcase}"
+      logger.debug "  Path: #{context[:original_path]}"
+      logger.debug "  Params: #{context[:params].inspect}"
+      logger.debug "  Headers: #{sanitize_headers_for_logging(context[:headers])}"
+    end
+
+    def log_request_execution(method, uri)
+      logger.info "Making #{method.upcase} request to #{uri.host}#{uri.path}"
+    end
+
+    private
+
+    def server_config_items
+      [
+        ['Server port', config.server_port],
+        ['Server bind', config.server_bind],
+        ['Swagger URL', config.swagger_url],
+        ['MCP name', config.mcp_name],
+        ['Auth header name', config.auth_header_name]
+      ]
+    end
+
+    def logger
+      config.logger
+    end
+
+    def config
+      @config
+    end
+  end
+end

data/lib/swagger_mcp_tool/server.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+require 'sinatra/json'
+require 'mcp'
+require 'json'
+require 'logger'
+require 'byebug'
+require_relative 'tool_registry'
+require_relative 'logging'
+require_relative 'config'
+require_relative 'helpers/tool_register'
+
+module SwaggerMCPTool
+  # The Server class is the main Sinatra-based HTTP server for the SwaggerMCPTool.
+  # It provides endpoints for manifest retrieval, tool generation, authentication token management,
+  # and health checks. The server dynamically generates tools from a Swagger/OpenAPI specification,
+  # manages user authentication, and integrates with the MCP (Model Control Protocol) server.
+  #
+  # Key responsibilities:
+  # - Initializes configuration and tool registry on startup.
+  # - Exposes RESTful endpoints for manifest, MCP requests, tool generation, and health checks.
+  # - Handles CORS and server configuration.
+  # - Dynamically generates and registers tools from a Swagger URL.
+  # - Manages user authentication tokens and server context.
+  #
+  # Endpoints:
+  # - GET  /mcp/manifest      : Returns the MCP manifest for integration.
+  # - POST /mcp               : Handles MCP requests with dynamic tools.
+  # - POST /set_auth_token    : Sets authentication tokens for users.
+  # - POST /generate_tools    : Generates tools from a provided Swagger URL.
+  # - GET  /logo.png          : Serves the logo image.
+  # - GET  /health            : Health check and server status.
+  #
+  # Usage:
+  #   SwaggerMCPTool::Server.start
+  #
+  # Dependencies:
+  # - Sinatra::Base
+  # - SwaggerMCPTool::Config
+  # - SwaggerMCPTool::ToolRegistry
+  # - SwaggerClient
+  # - ToolGenerator
+  # - MCP::Server
+  #
+  # Configuration is managed via the Config singleton, and tools are registered
+  # dynamically via the ToolRegistry singleton.
+  class Server < Sinatra::Base
+    attr_reader :config, :dynamic_tools
+
+    include Logging
+    include Helpers::ToolRegister
+
+    # Initialize with configuration
+    def initialize(app = nil)
+      super(app)
+      @config = Config.instance
+
+      # Debug configuration values
+      log_server_initialization
+      # Generate tools on startup
+      setup_tool_registry
+      initialize_tools
+      # Configure server settings
+      configure_server
+    end
+
+    # def tool_registry
+    #   SwaggerMCPTool::ToolRegistry.instance
+    # end
+
+    # def setup_tool_registry
+    #   registry = tool_registry
+    #   registry.setup(@config)  # <-- This is where setup gets called
+    #   @logger = @config.logger
+    #   log_message('Tool registry setup complete')
+    # end
+
+    # def initialize_tools
+    #   generate_tools_from_swagger_url
+    # end
+
+    # Start the server
+    def self.start
+      # self.define_routes
+      new
+      run!
+    end
+
+    def configure_server
+      self.class.set :server, @config.server_type
+      self.class.set :bind, @config.server_bind
+      self.class.set :port, @config.server_port
+
+      # Enable CORS
+      enable_cors
+
+      # Add options headers
+      add_options
+    end
+
+    def enable_cors
+      self.class.before do
+        headers 'Access-Control-Allow-Origin' => '*',
+                'Access-Control-Allow-Methods' => 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers' => 'Content-Type, Authorization, X-User-ID, Auth-Token, X-Username, X-Email'
+      end
+    end
+
+    def add_options
+      self.class.options '*' do
+        response.headers['Allow'] = 'GET, POST, OPTIONS'
+        response.headers['Access-Control-Allow-Headers'] =
+          'Authorization, Content-Type, Accept, X-User-ID, Auth-Token, X-Username, X-Email'
+        200
+      end
+    end
+
+    # private
+
+    # Define server routes
+    # def define_routes
+    # MCP manifest endpoint
+    get '/mcp/manifest' do
+      manifest = {
+        schema_version: 'v1',
+        name_for_human: @config.mcp_name_for_human,
+        name_for_model: @config.mcp_name,
+        description_for_human: @config.mcp_description_for_human,
+        description_for_model: @config.mcp_description_for_model,
+        auth: {
+          type: @config.auth_type
+        },
+        api: {
+          type: 'function'
+        },
+        logo_url: "#{request.base_url}/logo.png",
+        contact_email: 'support@example.com',
+        legal_info_url: 'https://example.com/legal'
+      }
+
+      json manifest
+    end
+
+    # MCP endpoint
+    post '/mcp' do
+      content_type :json
+
+      # Create server context with user details
+      user_details = @config.to_context(request)
+
+      # Create MCP server with our tools and prompts
+      mcp = MCP::Server.new(
+        name: @config.mcp_name,
+        tools: tool_registry.dynamic_tools,
+        prompts: @config.prompts,
+        server_context: user_details
+      )
+
+      MCP.configure do |config|
+        config.instrumentation_callback = lambda { |data|
+          @config.logger.debug "Got instrumentation data #{data.inspect}"
+        }
+      end
+      # Process the MCP request
+      request_body = request.body.read
+      @config.logger.debug "MCP request: #{request_body}"
+
+      response_body = mcp.handle_json(request_body)
+      @config.logger.debug "MCP response: #{response_body}"
+
+      response_body
+    end
+
+    # Set auth token endpoint
+    post '/set_auth_token' do
+      content_type :json
+
+      begin
+        # Parse request body
+        request_data = JSON.parse(request.body.read)
+        user_id = request_data['user_id'] || request.env['HTTP_X_USER_ID'] || '1'
+        auth_token = request_data['auth_token']
+
+        if auth_token.nil? || auth_token.empty?
+          status 400
+          return { error: 'Missing auth_token parameter' }.to_json
+        end
+
+        # Set the auth token
+        @auth_handler.set_auth_token(user_id, auth_token)
+
+        # Return success
+        {
+          success: true,
+          message: "Auth token set for user: #{user_id}"
+        }.to_json
+      rescue StandardError => e
+        status 500
+        { error: e.message }.to_json
+      end
+    end
+
+    # Generate tools endpoint
+    post '/generate_tools' do
+      content_type :json
+
+      # Parse request body
+      request_data = JSON.parse(request.body.read)
+      swagger_url = request_data['swagger_url']
+
+      if swagger_url.nil? || swagger_url.empty?
+        status 400
+        return { error: 'Missing swagger_url parameter' }.to_json
+      end
+
+      # Generate tools
+      generate_tools_from_swagger_url(swagger_url)
+
+      # Return success
+      {
+        success: true,
+        message: "Generated #{@dynamic_tools.size} tools",
+        tools: @dynamic_tools.map { |t| { name: t.name, description: t.description } }
+      }.to_json
+    rescue StandardError => e
+      status 500
+      { error: e.message }.to_json
+    end
+
+    # Logo endpoint
+    get '/logo.png' do
+      # You can replace this with an actual logo file
+      content_type 'image/png'
+      File.read('logo.png') if File.exist?('logo.png')
+    end
+
+    # Health check endpoint
+    get '/health' do
+      content_type :json
+      {
+        status: 'ok',
+        timestamp: Time.now.to_s,
+        tools_count: @dynamic_tools.size,
+        prompts_count: @config.prompts.size,
+        cache_stats: @tool_cache.stats,
+        config: {
+          server_port: @config.server_port,
+          swagger_url: @config.swagger_url
+        }
+      }.to_json
+    end
+  end
+end

data/lib/swagger_mcp_tool/swagger_client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'json'
+require 'yaml'
+
+module SwaggerMCPTool
+  # The SwaggerClient class is responsible for fetching and parsing Swagger/OpenAPI specifications
+  # from a given URL. It supports both Swagger 2.0 and OpenAPI 3.x formats, handling JSON and YAML
+  # content types. The class provides methods to extract the base URL from the specification and
+  # manages HTTP(S) requests with proper SSL configuration and error handling.
+  #
+  # Example usage:
+  #   client = SwaggerMCPTool::SwaggerClient.new('https://example.com/swagger.json')
+  #   spec = client.swagger_spec
+  #   base_url = client.base_url
+  #
+  # Attributes:
+  #   @swagger_spec [Hash] The parsed Swagger/OpenAPI specification.
+  #   @base_url [String] The base URL extracted from the specification.
+  #
+  # Methods:
+  #   - initialize(url): Initializes the client and fetches the specification.
+  #   - fetch_swagger_spec(url): Fetches and parses the Swagger/OpenAPI spec from the URL.
+  #   - parse_url_content(url, content): Parses the content as JSON or YAML.
+  #   - get_base_url(swagger_spec): Determines the base URL from the spec.
+  #   - get_base_for_swagger_v2(swagger_spec): Extracts base URL for Swagger 2.0.
+  #   - get_base_for_swagger_v3(swagger_spec): Extracts base URL for OpenAPI 3.x.
+  #   - make_http_request(url): Performs the HTTP GET request.
+  #   - create_http_client(uri): Creates and configures the HTTP client.
+  #   - configure_ssl(http, uri): Configures SSL for HTTPS requests.
+  #   - validate_response!(response): Validates the HTTP response.
+  #
+  # @see https://swagger.io/specification/
+  class SwaggerClient
+    attr_reader :swagger_spec, :base_url
+
+    def initialize(url)
+      @config = Config.instance
+      @swagger_url = url
+      @swagger_spec = fetch_swagger_spec(url)
+      @base_url = get_base_url(@swagger_spec)
+    end
+
+    # Fetch Swagger/OpenAPI specification from URL
+    def fetch_swagger_spec(url)
+      @config.logger.info "Fetching Swagger specification from: #{url}"
+
+      # Use HTTPS if specified in the URL
+      http_response = make_http_request(url)
+      validate_response!(http_response)
+
+      # Parse JSON or YAML based on content
+      parse_url_content(url, http_response.body)
+    end
+
+    def parse_url_content(url, content)
+      if url.end_with?('.json') || content.strip.start_with?('{')
+        JSON.parse(content)
+      else
+        YAML.safe_load(content)
+      end
+    end
+
+    # Get base URL from Swagger spec
+    def get_base_url(swagger_spec)
+      if swagger_spec['swagger'] == '2.0'
+        get_base_for_swagger_v2(swagger_spec)
+      elsif swagger_spec['openapi']&.start_with?('3.')
+        get_base_for_swagger_v3(swagger_spec)
+      else
+        ''
+      end
+    end
+
+    def get_base_for_swagger_v2(swagger_spec)
+      base_path = swagger_spec['basePath'] || ''
+      host = swagger_spec['host'] || ''
+      schemes = swagger_spec['schemes'] || ['https']
+      "#{schemes.first}://#{host}#{base_path}"
+    end
+
+    def get_base_for_swagger_v3(swagger_spec)
+      servers = swagger_spec['servers'] || [{ 'url' => '' }]
+      servers.first['url']
+    end
+
+    def make_http_request(url)
+      uri = URI(url)
+      http = create_http_client(uri)
+      request = Net::HTTP::Get.new(uri.request_uri)
+      http.request(request)
+    end
+
+    def create_http_client(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      configure_ssl(http, uri)
+      http
+    end
+
+    def configure_ssl(http, uri)
+      return unless uri.scheme == 'https'
+
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    def validate_response!(response)
+      return if response.is_a?(Net::HTTPSuccess)
+
+      raise "Failed to fetch Swagger specification: #{response.code} #{response.message}"
+    end
+  end
+end

data/lib/swagger_mcp_tool/tool_generator.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'config'
+require_relative 'logging'
+require_relative 'helpers/swagger_validator'
+require_relative 'helpers/parameter_processor'
+require_relative 'helpers/request_body_processor'
+require_relative 'helpers/tool_builder'
+
+module SwaggerMCPTool
+  # Provides validation methods for Swagger (OpenAPI) specification structures.
+  # This module includes methods to validate the overall structure of a Swagger spec,
+  # ensure required keys are present, and check the structure of the 'paths' section.
+  # Intended to be included in classes that require Swagger spec validation logic.
+  #
+  # Example usage:
+  #   include SwaggerValidator
+  #   validate_swagger_spec!(swagger_spec_hash)
+  #
+  # Raises ArgumentError if the spec or paths are invalid.
+  #
+  # @see https://swagger.io/specification/
+
+  # Generate MCP tools from Swagger/OpenAPI specification
+  # Generates a list of tool definitions based on the Swagger/OpenAPI specification.
+  class ToolGenerator
+    include Helpers::SwaggerValidator
+    include Helpers::ParameterProcessor
+    include Helpers::RequestBodyProcessor
+    include Helpers::ToolBuilder
+
+    def initialize(swagger_client)
+      @swagger_client = swagger_client
+      @config = Config.instance
+      @generated_tools = []
+    end
+
+    def generate_tools
+      swagger_spec = @swagger_client.swagger_spec
+      validate_swagger_spec!(swagger_spec)
+
+      @config.logger.info 'Generating tools from Swagger spec'
+
+      process_swagger_paths(swagger_spec['paths'])
+
+      @config.logger.info "Generated #{@generated_tools.size} tools"
+      @generated_tools
+    end
+
+    private
+
+    def process_swagger_paths(paths)
+      paths.each do |path, methods|
+        process_path_methods(path, methods) if methods.is_a?(Hash)
+      end
+    rescue StandardError => e
+      @config.logger.error "Error processing paths: #{e.message}"
+      @generated_tools
+    end
+
+    def process_path_methods(path, methods)
+      methods.each do |method, operation|
+        next if skip_method?(method, operation)
+
+        tool = build_tool_from_operation(path, method, operation)
+        @generated_tools << tool if tool
+      end
+    end
+
+    def skip_method?(method, operation)
+      method == 'parameters' || !operation.is_a?(Hash)
+    end
+
+    def build_tool_from_operation(path, method, operation)
+      tool_definition = create_base_tool_definition(path, method, operation)
+
+      add_parameters_to_tool(tool_definition, operation)
+      add_request_body_to_tool(tool_definition, operation)
+
+      tool_definition
+    rescue StandardError => e
+      @config.logger.warn "Skipping tool for #{method.upcase} #{path}: #{e.message}"
+    end
+  end
+end