fast-mcp 0.1.0

data/lib/mcp/transports/authenticated_rack_transport.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'rack_transport'
+
+module MCP
+  module Transports
+    class AuthenticatedRackTransport < RackTransport
+      def initialize(server, app, options = {})
+        super
+
+        @auth_token = options[:auth_token]
+        @auth_header_name = options[:auth_header_name] || 'Authorization'
+        @auth_exempt_paths = options[:auth_exempt_paths] || []
+        @auth_enabled = !@auth_token.nil?
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+
+        if auth_enabled? && !exempt_from_auth?(request.path)
+          auth_header = request.env["HTTP_#{@auth_header_name.upcase.gsub('-', '_')}"]
+          token = auth_header&.gsub('Bearer ', '')
+
+          return unauthorized_response(request) unless valid_token?(token)
+        end
+
+        super
+      end
+
+      private
+
+      def auth_enabled?
+        @auth_enabled
+      end
+
+      def exempt_from_auth?(path)
+        @auth_exempt_paths.any? { |exempt_path| path.start_with?(exempt_path) }
+      end
+
+      def valid_token?(token)
+        token == @auth_token
+      end
+
+      def unauthorized_response(request)
+        body = JSON.generate(
+          {
+            jsonrpc: '2.0',
+            error: {
+              code: -32_000,
+              message: 'Unauthorized: Invalid or missing authentication token'
+            },
+            id: extract_request_id(request)
+          }
+        )
+
+        [401, { 'Content-Type' => 'application/json' }, [body]]
+      end
+
+      def extract_request_id(request)
+        return nil unless request.post?
+
+        begin
+          body = request.body.read
+          request.body.rewind
+          JSON.parse(body)['id']
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/mcp/transports/base_transport.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MCP
+  module Transports
+    # Base class for all MCP transports
+    # This defines the interface that all transports must implement
+    class BaseTransport
+      attr_reader :server, :logger
+
+      def initialize(server, logger: nil)
+        @server = server
+        @logger = logger || server.logger
+      end
+
+      # Start the transport
+      # This method should be implemented by subclasses
+      def start
+        raise NotImplementedError, "#{self.class} must implement #start"
+      end
+
+      # Stop the transport
+      # This method should be implemented by subclasses
+      def stop
+        raise NotImplementedError, "#{self.class} must implement #stop"
+      end
+
+      # Send a message to the client
+      # This method should be implemented by subclasses
+      def send_message(message)
+        raise NotImplementedError, "#{self.class} must implement #send_message"
+      end
+
+      # Process an incoming message
+      # This is a helper method that can be used by subclasses
+      def process_message(message)
+        server.handle_json_request(message)
+      end
+    end
+  end
+end

data/lib/mcp/transports/rack_transport.rb

@@ -0,0 +1,468 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+require 'rack'
+require_relative 'base_transport'
+
+module MCP
+  module Transports
+    # Rack middleware transport for MCP
+    # This transport can be mounted in any Rack-compatible web framework
+    class RackTransport < BaseTransport
+      DEFAULT_PATH_PREFIX = '/mcp'
+
+      attr_reader :app, :path_prefix, :sse_clients
+
+      def initialize(server, app, options = {})
+        super(server, logger: options[:logger])
+        @app = app
+        @path_prefix = options[:path_prefix] || DEFAULT_PATH_PREFIX
+        @sse_clients = {}
+        @running = false
+      end
+
+      # Start the transport
+      def start
+        @logger.info("Starting Rack transport with path prefix: #{@path_prefix}")
+        @running = true
+      end
+
+      # Stop the transport
+      def stop
+        @logger.info('Stopping Rack transport')
+        @running = false
+
+        # Close all SSE connections
+        @sse_clients.each_value do |client|
+          client[:stream].close if client[:stream].respond_to?(:close) && !client[:stream].closed?
+        rescue StandardError => e
+          @logger.error("Error closing SSE connection: #{e.message}")
+        end
+        @sse_clients.clear
+      end
+
+      # Send a message to all connected SSE clients
+      def send_message(message)
+        json_message = message.is_a?(String) ? message : JSON.generate(message)
+        @logger.info("Broadcasting message to #{@sse_clients.size} SSE clients: #{json_message}")
+
+        clients_to_remove = []
+
+        @sse_clients.each do |client_id, client|
+          stream = client[:stream]
+          next if stream.nil? || (stream.respond_to?(:closed?) && stream.closed?)
+
+          stream.write("data: #{json_message}\n\n")
+          stream.flush if stream.respond_to?(:flush)
+        rescue Errno::EPIPE, IOError => e
+          # Broken pipe or IO error - client disconnected
+          @logger.info("Client #{client_id} disconnected: #{e.message}")
+          clients_to_remove << client_id
+        rescue StandardError => e
+          @logger.error("Error sending message to client #{client_id}: #{e.message}")
+          # Remove the client if we can't send to it
+          clients_to_remove << client_id
+        end
+
+        # Remove disconnected clients outside the loop to avoid modifying the hash during iteration
+        clients_to_remove.each { |client_id| unregister_sse_client(client_id) }
+      end
+
+      # Register a new SSE client
+      def register_sse_client(client_id, stream)
+        @logger.info("Registering SSE client: #{client_id}")
+        @sse_clients[client_id] = { stream: stream, connected_at: Time.now }
+      end
+
+      # Unregister an SSE client
+      def unregister_sse_client(client_id)
+        @logger.info("Unregistering SSE client: #{client_id}")
+        @sse_clients.delete(client_id)
+      end
+
+      # Rack call method
+      def call(env)
+        request = Rack::Request.new(env)
+        path = request.path
+        @logger.info("Rack request path: #{path}")
+
+        # Check if the request is for our MCP endpoints
+        if path.start_with?(@path_prefix)
+          handle_mcp_request(request, env)
+        else
+          # Pass through to the main application
+          @app.call(env)
+        end
+      end
+
+      private
+
+      # Handle MCP-specific requests
+      def handle_mcp_request(request, env)
+        subpath = request.path[@path_prefix.length..]
+        @logger.info("MCP request subpath: '#{subpath.inspect}'")
+
+        case subpath
+        when '/sse'
+          handle_sse_request(request, env)
+        when '/messages'
+          @logger.info('Received message request')
+          handle_message_request(request)
+        else
+          @logger.info('Received unknown request')
+          # Return 404 for unknown MCP endpoints
+          endpoint_not_found_response
+        end
+      end
+
+      # Return a 404 endpoint not found response
+      def endpoint_not_found_response
+        [404, { 'Content-Type' => 'application/json' },
+         [JSON.generate(
+           {
+             jsonrpc: '2.0',
+             error: {
+               code: -32_601,
+               message: 'Endpoint not found'
+             },
+             id: nil
+           }
+         )]]
+      end
+
+      # Handle SSE connection request
+      def handle_sse_request(request, env)
+        # Handle OPTIONS preflight request
+        return [200, setup_cors_headers, []] if request.options?
+
+        return method_not_allowed_response unless request.get?
+
+        # Set up SSE headers
+        headers = setup_sse_headers
+
+        # Handle streaming based on the framework
+        handle_streaming(env, headers)
+      end
+
+      # Handle streaming based on the framework
+      def handle_streaming(env, headers)
+        @logger.info("Handling streaming for env: #{env['HTTP_USER_AGENT']}")
+        if env['rack.hijack']
+          # Rack hijacking (e.g., Puma)
+          @logger.info('Handling rack hijack SSE')
+          handle_rack_hijack_sse(env, headers)
+        elsif rails_live_streaming?(env)
+          # Rails ActionController::Live
+          @logger.info('Handling rails live streaming SSE')
+          handle_rails_sse(env, headers)
+        else
+          # Fallback for servers that don't support streaming
+          @logger.info('Falling back to default SSE')
+          [200, headers, [":ok\n\n"]]
+        end
+      end
+
+      # Check if Rails live streaming is available
+      def rails_live_streaming?(env)
+        defined?(ActionController::Live) &&
+          env['action_controller.instance'].respond_to?(:response) &&
+          env['action_controller.instance'].response.respond_to?(:stream)
+      end
+
+      # Set up headers for SSE connection
+      def setup_sse_headers
+        {
+          'Content-Type' => 'text/event-stream',
+          'Cache-Control' => 'no-cache, no-store, must-revalidate',
+          'Connection' => 'keep-alive',
+          'X-Accel-Buffering' => 'no', # For Nginx
+          'Access-Control-Allow-Origin' => '*', # Allow CORS
+          'Access-Control-Allow-Methods' => 'GET, OPTIONS',
+          'Access-Control-Allow-Headers' => 'Content-Type',
+          'Access-Control-Max-Age' => '86400', # 24 hours
+          'Keep-Alive' => 'timeout=600', # 10 minutes timeout
+          'Pragma' => 'no-cache',
+          'Expires' => '0'
+        }
+      end
+
+      # Set up CORS headers for preflight requests
+      def setup_cors_headers
+        {
+          'Access-Control-Allow-Origin' => '*',
+          'Access-Control-Allow-Methods' => 'GET, OPTIONS',
+          'Access-Control-Allow-Headers' => 'Content-Type',
+          'Access-Control-Max-Age' => '86400', # 24 hours
+          'Content-Type' => 'text/plain'
+        }
+      end
+
+      # Extract client ID from request or generate a new one
+      def extract_client_id(env)
+        request = Rack::Request.new(env)
+
+        # Check various places for client ID
+        client_id = request.params['client_id']
+        client_id ||= env['HTTP_LAST_EVENT_ID']
+        client_id ||= env['HTTP_X_CLIENT_ID']
+
+        # Get browser information
+        user_agent = env['HTTP_USER_AGENT'] || ''
+        browser_type = detect_browser_type(user_agent)
+        @logger.info("Client connection from: #{user_agent} (#{browser_type})")
+
+        # Handle MCP inspector with fixed client ID
+        @logger.info("MCP Inspector detected, using fixed client ID: #{client_id}") if mcp_inspector?(user_agent, env)
+
+        # Handle reconnection
+        if client_id && @sse_clients.key?(client_id)
+          handle_client_reconnection(client_id, browser_type)
+        else
+          # Generate a new client ID if none was provided
+          client_id ||= SecureRandom.uuid
+          @logger.info("New client connection: #{client_id} (#{browser_type})")
+        end
+
+        client_id
+      end
+
+      # Detect browser type from user agent
+      def detect_browser_type(user_agent)
+        is_chrome = user_agent.include?('Chrome/')
+        is_safari = user_agent.include?('Safari/') && !user_agent.include?('Chrome/')
+        is_firefox = user_agent.include?('Firefox/')
+        is_node = user_agent.include?('Node.js') || user_agent.include?('node-fetch')
+
+        if is_chrome
+          'Chrome'
+        elsif is_safari
+          'Safari'
+        elsif is_firefox
+          'Firefox'
+        elsif is_node
+          'Node.js'
+        else
+          'Other browser'
+        end
+      end
+
+      # Check if client is MCP inspector
+      def mcp_inspector?(user_agent, env)
+        user_agent.include?('mcp-inspector') || (env['mcp.client_name'] == 'mcp-inspector')
+      end
+
+      # Handle client reconnection
+      def handle_client_reconnection(client_id, browser_type)
+        @logger.info("Client #{client_id} is reconnecting (#{browser_type})")
+        old_client = @sse_clients[client_id]
+        begin
+          old_client[:stream].close if old_client[:stream].respond_to?(:close) && !old_client[:stream].closed?
+        rescue StandardError => e
+          @logger.error("Error closing old connection for client #{client_id}: #{e.message}")
+        end
+        unregister_sse_client(client_id)
+
+        # Small delay to ensure the old connection is fully closed
+        sleep 0.1
+      end
+
+      # Handle SSE with Rack hijacking (e.g., Puma)
+      def handle_rack_hijack_sse(env, headers)
+        client_id = extract_client_id(env)
+        @logger.info("Setting up Rack hijack SSE connection for client #{client_id}")
+
+        env['rack.hijack'].call
+        io = env['rack.hijack_io']
+        @logger.info("Obtained hijack IO for client #{client_id}")
+
+        setup_sse_connection(client_id, io, headers)
+        start_keep_alive_thread(client_id, io)
+
+        # Return async response
+        [-1, {}, []]
+      end
+
+      # Set up the SSE connection
+      def setup_sse_connection(client_id, io, headers)
+        # Send headers
+        @logger.info("Sending HTTP headers for SSE connection #{client_id}")
+        io.write("HTTP/1.1 200 OK\r\n")
+        headers.each { |k, v| io.write("#{k}: #{v}\r\n") }
+        io.write("\r\n")
+        io.flush
+
+        # Register client
+        register_sse_client(client_id, io)
+
+        # Send an initial comment to keep the connection alive
+        io.write(": SSE connection established\n\n")
+
+        # Send endpoint information as the first message
+        endpoint = "#{@path_prefix}/messages"
+        @logger.info("Sending endpoint information to client #{client_id}: #{endpoint}")
+        io.write("event: endpoint\ndata: #{endpoint}\n\n")
+
+        # Send a retry directive with a very short reconnect time
+        # This helps browsers reconnect quickly if the connection is lost
+        io.write("retry: 100\n\n") # 100ms reconnect time
+        io.flush
+      rescue StandardError => e
+        @logger.error("Error setting up SSE connection for client #{client_id}: #{e.message}")
+        @logger.error(e.backtrace.join("\n")) if e.backtrace
+        raise
+      end
+
+      # Start a keep-alive thread for SSE connection
+      def start_keep_alive_thread(client_id, io)
+        @logger.info("Starting keep-alive thread for client #{client_id}")
+        Thread.new do
+          keep_alive_loop(io, client_id)
+        rescue StandardError => e
+          @logger.error("Error in SSE keep-alive for client #{client_id}: #{e.message}")
+          @logger.error(e.backtrace.join("\n")) if e.backtrace
+        ensure
+          cleanup_sse_connection(client_id, io)
+        end
+      end
+
+      # Run the keep-alive loop
+      def keep_alive_loop(io, client_id)
+        @logger.info("Starting keep-alive loop for SSE connection #{client_id}")
+        ping_count = 0
+        ping_interval = 1 # Send a ping every 1 second
+        max_ping_count = 30 # Reset connection after 30 pings (about 30 seconds)
+
+        while @running && !io.closed?
+          begin
+            ping_count = send_keep_alive_ping(io, client_id, ping_count, max_ping_count)
+            break if ping_count >= max_ping_count
+
+            sleep ping_interval
+          rescue Errno::EPIPE, IOError => e
+            # Broken pipe or IO error - client disconnected
+            @logger.error("SSE connection error for client #{client_id}: #{e.message}")
+            break
+          end
+        end
+      end
+
+      # Send a keep-alive ping and return the updated ping count
+      def send_keep_alive_ping(io, client_id, ping_count, max_ping_count)
+        ping_count += 1
+
+        # Send a comment before each ping to keep the connection alive
+        io.write(": keep-alive #{ping_count}\n\n")
+        io.flush
+
+        # Only send actual ping events every 5 counts to reduce overhead
+        if (ping_count % 5).zero?
+          @logger.info("Sending ping ##{ping_count} to SSE client #{client_id}")
+          send_ping_event(io)
+        end
+
+        # If we've reached the max ping count, force a reconnection
+        if ping_count >= max_ping_count
+          @logger.info("Reached max ping count (#{max_ping_count}) for client #{client_id}, forcing reconnection")
+          send_reconnect_event(io)
+        end
+
+        ping_count
+      end
+
+      # Send a ping event
+      def send_ping_event(io)
+        ping_message = {
+          jsonrpc: '2.0',
+          method: 'ping',
+          id: SecureRandom.uuid
+        }
+        io.write("event: ping\ndata: #{JSON.generate(ping_message)}\n\n")
+        io.flush
+      end
+
+      # Send a reconnect event
+      def send_reconnect_event(io)
+        io.write("event: reconnect\ndata: {\"reason\":\"timeout prevention\"}\n\n")
+        io.flush
+      end
+
+      # Clean up SSE connection
+      def cleanup_sse_connection(client_id, io)
+        @logger.info("Cleaning up SSE connection for client #{client_id}")
+        unregister_sse_client(client_id)
+        begin
+          io.close unless io.closed?
+          @logger.info("Successfully closed IO for client #{client_id}")
+        rescue StandardError => e
+          @logger.error("Error closing IO for client #{client_id}: #{e.message}")
+        end
+      end
+
+      # Handle SSE with Rails ActionController::Live
+      def handle_rails_sse(env, headers)
+        client_id = extract_client_id(env)
+        controller = env['action_controller.instance']
+        stream = controller.response.stream
+
+        # Register client
+        register_sse_client(client_id, stream)
+
+        # The controller will handle the streaming
+        [200, headers, []]
+      end
+
+      # Handle message POST request
+      def handle_message_request(request)
+        @logger.info('Received message request')
+        return method_not_allowed_response unless request.post?
+
+        begin
+          process_json_request(request)
+        rescue JSON::ParserError => e
+          handle_parse_error(e)
+        rescue StandardError => e
+          handle_internal_error(e)
+        end
+      end
+
+      # Process a JSON-RPC request
+      def process_json_request(request)
+        # Parse the request body
+        body = request.body.read
+
+        response = process_message(body)
+        @logger.info("Response: #{response}")
+        [200, { 'Content-Type' => 'application/json' }, [response]]
+      end
+
+      # Return a method not allowed error response
+      def method_not_allowed_response
+        json_rpc_error_response(405, -32_601, 'Method not allowed')
+      end
+
+      # Handle JSON parse errors
+      def handle_parse_error(error)
+        @logger.error("Invalid JSON in request: #{error.message}")
+        json_rpc_error_response(400, -32_700, 'Parse error: Invalid JSON')
+      end
+
+      # Handle internal server errors
+      def handle_internal_error(error)
+        @logger.error("Error processing message: #{error.message}")
+        json_rpc_error_response(500, -32_603, "Internal error: #{error.message}")
+      end
+
+      def json_rpc_error_response(http_status, code, message, id = nil)
+        [http_status, { 'Content-Type' => 'application/json' },
+         [JSON.generate(
+           {
+             jsonrpc: '2.0',
+             error: { code: code, message: message },
+             id: id
+           }
+         )]]
+      end
+    end
+  end
+end

data/lib/mcp/transports/stdio_transport.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'base_transport'
+
+module MCP
+  module Transports
+    # STDIO transport for MCP
+    # This transport uses standard input/output for communication
+    class StdioTransport < BaseTransport
+      def initialize(server, logger: nil)
+        super
+        @running = false
+      end
+
+      # Start the transport
+      def start
+        @logger.info('Starting STDIO transport')
+        @running = true
+
+        # Process input from stdin
+        while @running && (line = $stdin.gets)
+          begin
+            process_message(line.strip)
+          rescue StandardError => e
+            @logger.error("Error processing message: #{e.message}")
+            @logger.error(e.backtrace.join("\n"))
+            send_error(-32_000, "Internal error: #{e.message}")
+          end
+        end
+      end
+
+      # Stop the transport
+      def stop
+        @logger.info('Stopping STDIO transport')
+        @running = false
+      end
+
+      # Send a message to the client
+      def send_message(message)
+        json_message = message.is_a?(String) ? message : JSON.generate(message)
+
+        $stdout.puts(json_message)
+        $stdout.flush
+      end
+
+      private
+
+      # Send a JSON-RPC error response
+      def send_error(code, message, id = nil)
+        response = {
+          jsonrpc: '2.0',
+          error: {
+            code: code,
+            message: message
+          },
+          id: id
+        }
+        send_message(response)
+      end
+    end
+  end
+end

data/lib/mcp/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Version information
+module FastMCP
+  VERSION = '0.1.0'
+end