keycardai-mcp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 598ccfb7138983e92a8e17d1b139689b313a9e7b2ebc4c0e422a47c9730f73a8
+  data.tar.gz: 5f0828148a2565f81fa33574639418aeae0c0f64540cbda9e3e20cf7749070fe
+SHA512:
+  metadata.gz: 38a310adbe756ab5f33bd3989235cdaa6873cb89b5b99e18e342f56d881d032ed461c2209988f45b0952d77243631c997f401e60f85245a0a045fad031c1a8e3
+  data.tar.gz: 63256d53e222d04096c844e371721341c44891e42bdd1dd3202ad405d216908500f658f8380a294a19236231fd639895ae25c028d710a7c1f1ddc9e46b27a6e6

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+Entries from 0.2.0 onward are generated by commitizen on each bump. This first
+one is written by hand because 0.1.0 is published from a baseline tag rather
+than from a bump.
+
+## 0.1.0
+
+Initial release.
+
+Keycard integration for MCP servers at the Rack seam: fail-closed bearer
+verification with RFC 6750 challenges, OAuth metadata endpoints (RFC 9728
+protected-resource with path insertion, an RFC 8414 authorization-server proxy,
+and JWKS), and an AuthProvider whose `grant` middleware exchanges the caller's
+token per resource into an AccessContext. Wraps no MCP SDK.

data/LICENSE

@@ -0,0 +1,9 @@
+MIT LICENSE
+
+Copyright © 2026 Keycard Labs, inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# keycardai-mcp
+
+Keycard integration for MCP servers in Ruby, attached at the Rack seam.
+
+> **Preview.** APIs may change between minor versions while the surface settles.
+> Conformance against the cross-SDK contract is tracked in the
+> [conformance report](https://github.com/keycardai/ruby-sdk/blob/main/docs/conformance-report.md).
+
+```sh
+bundle add keycardai-mcp
+```
+
+What it ships (per [keycard-sdk-spec](https://github.com/keycardai/keycard-sdk-spec)):
+
+- Bearer-token verification middleware: fail-closed 401 with an RFC 6750
+  `WWW-Authenticate` challenge advertising `resource_metadata`
+- OAuth metadata endpoints: RFC 9728 protected-resource metadata with path
+  insertion, RFC 8414 authorization-server metadata proxy, `/.well-known/jwks.json`
+- AuthProvider: `grant(resources)` middleware for delegated token exchange
+  (RFC 8693) plus imperative `exchange_tokens`
+- Rack env accessors for the verified `AuthInfo` and the `AccessContext`
+
+This gem wraps no MCP SDK. It works with any Rack app; compatibility with
+servers built on the official [`mcp` gem](https://github.com/modelcontextprotocol/ruby-sdk)
+is proven by the example server in the repo's `examples/` directory.
+
+## Quickstart
+
+### Protect an endpoint
+
+```ruby
+require "keycardai/mcp"
+
+zone_url = ENV.fetch("KEYCARD_URL")
+
+verifier = Keycardai::OAuth::TokenVerifier.new(issuers: zone_url)
+metadata = Keycardai::MCP::MetadataApp.new(
+  issuer: zone_url,
+  resource_name: "mcp-server-ruby",
+  scopes_supported: ["mcp:tools"],
+)
+
+protected_mcp = Keycardai::MCP::RequireBearerAuth.new(
+  your_mcp_endpoint, verifier: verifier, required_scopes: ["mcp:tools"],
+)
+
+run lambda { |env|
+  case env["PATH_INFO"]
+  when %r{\A/\.well-known/} then metadata.call(env)
+  when "/mcp" then protected_mcp.call(env)
+  else [404, { "content-type" => "application/json" }, ['{"error":"not_found"}']]
+  end
+}
+```
+
+An unauthenticated request gets a 401 with an RFC 6750 `WWW-Authenticate`
+challenge pointing at `resource_metadata`, which is what lets a client discover
+where to authenticate. `MetadataApp` serves the RFC 9728 protected-resource
+document, proxies the zone's RFC 8414 authorization-server metadata, and serves
+`/.well-known/jwks.json`.
+
+Inside the handler, the verified token is on the Rack env:
+
+```ruby
+auth = Keycardai::MCP.auth_info(env)
+auth.subject
+auth.scopes
+```
+
+### Get tokens for downstream resources
+
+```ruby
+provider = Keycardai::MCP::AuthProvider.new(
+  zone_url: zone_url,
+  client_id: ENV.fetch("KEYCARD_CLIENT_ID"),
+  client_secret: ENV.fetch("KEYCARD_CLIENT_SECRET"),
+)
+
+use provider.grant(["https://api.github.com", "https://slack.com/api"])
+```
+
+By the time the handler runs, the caller's token has been exchanged once per
+resource and the results are on the env:
+
+```ruby
+context = Keycardai::MCP.access_context(env)
+context.access("https://api.github.com")  # raises if that resource failed
+context.status                            # "success", "partial_error", or "error"
+```
+
+A single resource failing does not abort the request; it lands on the context.
+A missing verified token does abort, 401, before any exchange is attempted.
+Stacked `grant` calls merge into one context.
+
+To act as a named user instead of the caller, pass `user_identifier:` (a string,
+or a callable that receives the Rack env). For an imperative call outside the
+middleware, `provider.exchange_tokens(token, resources)` returns the same
+`AccessContext`.

data/lib/keycardai/mcp/auth_provider.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Keycardai
+  module MCP
+    # The delegated-access provider for an MCP server: holds the zone and the
+    # application credential, builds the inbound TokenVerifier, and exposes
+    # grant middleware plus imperative token exchange. Multi-zone is inferred
+    # from a multi-zone credential (the credential is self-describing).
+    #
+    #   provider = Keycardai::MCP::AuthProvider.new(
+    #     zone_url: "https://acme.keycard.cloud",
+    #     credential: Keycardai::OAuth::ClientSecret.new(client_id, client_secret),
+    #   )
+    #   use Keycardai::MCP::RequireBearerAuth, verifier: provider.token_verifier
+    #   use provider.grant("https://api.example.com")
+    class AuthProvider
+      # @param zone_url [String] the zone's issuer URL
+      # @param credential [Object, nil] an application credential; a
+      #   multi-zone ClientSecret switches the provider to multi-zone
+      # @param client_id [String, nil] shared-secret pair alternative
+      # @param client_secret [String, nil]
+      # @param audiences [String, Array<String>, nil] enforced on inbound tokens
+      # @param http_client [#get, #post_form] pluggable transport
+      # @param timeout [Numeric, nil]
+      def initialize(zone_url:, credential: nil, client_id: nil, client_secret: nil, audiences: nil,
+                     http_client: Keycardai::OAuth::HTTP::NetHTTPClient.new, timeout: nil)
+        @zone_url = zone_url
+        @credential = credential || (client_id ? Keycardai::OAuth::ClientSecret.new(client_id, client_secret) : nil)
+        @audiences = audiences
+        @http_client = http_client
+        @timeout = timeout
+        @mutex = Mutex.new
+      end
+
+      # The issuers this provider trusts: the zone URL, plus every zone of a
+      # multi-zone credential.
+      #
+      # @return [Array<String>]
+      def issuers
+        zones = @credential.respond_to?(:multi_zone?) && @credential.multi_zone? ? @credential.issuers : []
+        ([@zone_url] + zones).uniq
+      end
+
+      # The inbound bearer-token verifier for this provider's zone(s).
+      #
+      # @return [Keycardai::OAuth::TokenVerifier]
+      def token_verifier
+        @mutex.synchronize do
+          @token_verifier ||= Keycardai::OAuth::TokenVerifier.new(
+            issuers: issuers, audiences: @audiences, http_client: @http_client
+          )
+        end
+      end
+
+      # Grant middleware: declare the downstream resources a route needs, and
+      # the caller's verified token is exchanged for one token per resource
+      # before the handler runs. Results and per-resource errors land on the
+      # AccessContext in the Rack env (Keycardai::MCP.access_context); a
+      # per-resource failure never aborts the request. Stacked grants merge
+      # into one context. A missing verified token is rejected 401 fail-fast.
+      #
+      # @param resources [String, Array<String>]
+      # @param user_identifier [String, #call, nil] impersonation target; a
+      #   callable receives the Rack env and returns the user id
+      # @param request_scopes [String, Hash{String => String}, nil]
+      # @return [Class] a Rack middleware class for `use`
+      def grant(resources, user_identifier: nil, request_scopes: nil)
+        provider = self
+        Class.new(Grant) do
+          define_method(:initialize) do |app|
+            super(app, provider: provider, resources: Array(resources),
+                       user_identifier: user_identifier, request_scopes: request_scopes)
+          end
+        end
+      end
+
+      # Imperative exchange: the caller's token for one token per resource.
+      #
+      # @return [Keycardai::OAuth::AccessContext]
+      def exchange_tokens(subject_token, resources, access_context: Keycardai::OAuth::AccessContext.new,
+                          user_identifier: nil, request_scopes: nil, issuer: nil)
+        Keycardai::OAuth.exchange_tokens_for_resources(
+          client: exchange_client, resources: Array(resources), subject_token: subject_token,
+          access_context: access_context, user_identifier: user_identifier,
+          request_scopes: request_scopes, issuer: issuer
+        )
+      end
+
+      # Zone-selected imperative exchange for multi-zone providers.
+      #
+      # @return [Keycardai::OAuth::AccessContext]
+      def exchange_tokens_for_zone(issuer, subject_token, resources, **)
+        exchange_tokens(subject_token, resources, issuer: issuer, **)
+      end
+
+      private
+
+      def exchange_client
+        @mutex.synchronize do
+          @exchange_client ||= Keycardai::OAuth::TokenExchangeClient.new(
+            issuer: @zone_url, credential: @credential, http_client: @http_client, timeout: @timeout
+          )
+        end
+      end
+
+      # The middleware realizing a grant declaration. Not used directly;
+      # constructed through AuthProvider#grant.
+      class Grant
+        def initialize(app, provider:, resources:, user_identifier:, request_scopes:)
+          @app = app
+          @provider = provider
+          @resources = resources
+          @user_identifier = user_identifier
+          @request_scopes = request_scopes
+        end
+
+        def call(env)
+          auth_info = env[ENV_AUTH_INFO]
+          return RackSupport.challenge_response(env, status: 401) if auth_info.nil?
+
+          context = env[ENV_ACCESS_CONTEXT] || Keycardai::OAuth::AccessContext.new
+          @provider.exchange_tokens(
+            auth_info.token, @resources,
+            access_context: context, user_identifier: resolve_user(env), request_scopes: @request_scopes
+          )
+          env[ENV_ACCESS_CONTEXT] = context
+          @app.call(env)
+        end
+
+        private
+
+        def resolve_user(env)
+          @user_identifier.respond_to?(:call) ? @user_identifier.call(env) : @user_identifier
+        end
+      end
+    end
+  end
+end

data/lib/keycardai/mcp/metadata_app.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Keycardai
+  module MCP
+    # Rack app serving the resource server's OAuth discovery surface
+    # (RFC 9728 / RFC 8414): the protected-resource metadata (with path
+    # insertion for sub-path mounts), a server-side proxy of the zone's
+    # authorization-server metadata (with the resource= rewrite shim for
+    # pre-RFC-8707 MCP clients), and optionally the server's own public JWKS.
+    # Responses carry permissive CORS so browser clients can read them.
+    #
+    #   run Keycardai::MCP::MetadataApp.new(issuer: zone_url, scopes_supported: ["mcp:tools"])
+    class MetadataApp
+      PROTECTED_RESOURCE_PATH = "/.well-known/oauth-protected-resource"
+      AUTHORIZATION_SERVER_PATH = "/.well-known/oauth-authorization-server"
+      JWKS_PATH = "/.well-known/jwks.json"
+      LEGACY_MCP_PROTOCOL_VERSION = "2025-03-26"
+
+      # @param issuer [String] the zone's issuer URL
+      # @param scopes_supported [Array<String>, nil]
+      # @param resource_name [String, nil]
+      # @param resource_documentation [String, nil]
+      # @param public_jwks [Hash, nil] served at /.well-known/jwks.json when set
+      # @param http_client [#get] transport for the AS-metadata proxy
+      # @param timeout [Numeric] upstream fetch timeout
+      def initialize(issuer:, scopes_supported: nil, resource_name: nil, resource_documentation: nil,
+                     public_jwks: nil, http_client: Keycardai::OAuth::HTTP::NetHTTPClient.new, timeout: 10)
+        raise Keycardai::OAuth::ConfigurationError, "MetadataApp requires an issuer" if issuer.nil? || issuer.empty?
+
+        @issuer = issuer
+        @scopes_supported = scopes_supported
+        @resource_name = resource_name
+        @resource_documentation = resource_documentation
+        @public_jwks = public_jwks
+        @http_client = http_client
+        @timeout = timeout
+      end
+
+      def call(env)
+        return preflight_response if env["REQUEST_METHOD"] == "OPTIONS"
+
+        path = env["PATH_INFO"].to_s
+        case path
+        when %r{\A#{Regexp.escape(PROTECTED_RESOURCE_PATH)}(/.*)?\z}
+          protected_resource_response(env, Regexp.last_match(1).to_s)
+        when AUTHORIZATION_SERVER_PATH
+          authorization_server_response(env)
+        when JWKS_PATH
+          jwks_response
+        else
+          RackSupport.json_response({ "error" => "not_found" }, status: 404)
+        end
+      end
+
+      private
+
+      def preflight_response
+        [204,
+         { "access-control-allow-origin" => "*", "access-control-allow-methods" => "GET, OPTIONS",
+           "access-control-allow-headers" => "MCP-Protocol-Version" },
+         []]
+      end
+
+      # RFC 9728, with path insertion: a resource mounted at /mcp is described
+      # at /.well-known/oauth-protected-resource/mcp and identified as
+      # origin + /mcp.
+      def protected_resource_response(env, resource_path)
+        origin = RackSupport.origin(env)
+        legacy = env["HTTP_MCP_PROTOCOL_VERSION"] == LEGACY_MCP_PROTOCOL_VERSION
+        document = {
+          "resource" => "#{origin}#{resource_path}",
+          "authorization_servers" => [legacy ? origin : @issuer],
+          "bearer_methods_supported" => ["header"],
+          "scopes_supported" => @scopes_supported,
+          "resource_name" => @resource_name,
+          "resource_documentation" => @resource_documentation,
+          "jwks_uri" => @public_jwks ? "#{origin}#{JWKS_PATH}" : nil
+        }.compact
+        RackSupport.json_response(document)
+      end
+
+      # RFC 8414 proxy of the zone's metadata, rewriting the
+      # authorization_endpoint to carry resource=<origin> (replacing any
+      # resource parameter already present in the upstream value).
+      def authorization_server_response(env)
+        metadata = Keycardai::OAuth.fetch_authorization_server_metadata(
+          @issuer, http_client: @http_client, timeout: @timeout
+        )
+        document = metadata.raw.dup
+        if document["authorization_endpoint"]
+          document["authorization_endpoint"] =
+            with_resource_param(document["authorization_endpoint"], RackSupport.origin(env))
+        end
+        RackSupport.json_response(document)
+      rescue Keycardai::Error
+        RackSupport.json_response({ "error" => "bad_gateway" }, status: 502)
+      end
+
+      def with_resource_param(endpoint, resource)
+        uri = URI(endpoint)
+        params = URI.decode_www_form(uri.query.to_s)
+        params.delete_if { |pair| pair.first == "resource" }
+        params << ["resource", resource]
+        uri.query = URI.encode_www_form(params)
+        uri.to_s
+      end
+
+      def jwks_response
+        return RackSupport.json_response({ "error" => "not_found" }, status: 404) unless @public_jwks
+
+        RackSupport.json_response(@public_jwks)
+      end
+    end
+  end
+end

data/lib/keycardai/mcp/rack_support.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Keycardai
+  module MCP
+    # Shared Rack plumbing: request-origin derivation and the RFC 6750
+    # challenge responses. Not public API.
+    module RackSupport
+      module_function
+
+      # The request origin (scheme + host [+ non-default port]).
+      def origin(env)
+        scheme = env["rack.url_scheme"] || "http"
+        host = env["HTTP_HOST"]
+        unless host
+          host = env["SERVER_NAME"].to_s
+          port = env["SERVER_PORT"].to_s
+          default = scheme == "https" ? "443" : "80"
+          host = "#{host}:#{port}" unless port.empty? || port == default
+        end
+        "#{scheme}://#{host}"
+      end
+
+      # The RFC 9728 protected-resource metadata URL advertised in challenges.
+      def resource_metadata_url(env)
+        "#{origin(env)}/.well-known/oauth-protected-resource"
+      end
+
+      # An RFC 6750 challenge response. A nil error code produces the bare
+      # challenge used for missing credentials.
+      def challenge_response(env, status:, error: nil, description: nil)
+        params = []
+        params << %(error="#{error}") if error
+        params << %(error_description="#{description}") if description
+        params << %(resource_metadata="#{resource_metadata_url(env)}")
+        body = JSON.dump({ "error" => error || "unauthorized" })
+        [status,
+         { "content-type" => "application/json", "www-authenticate" => "Bearer #{params.join(", ")}" },
+         [body]]
+      end
+
+      def json_response(payload, status: 200, headers: {})
+        [status,
+         { "content-type" => "application/json", "access-control-allow-origin" => "*" }.merge(headers),
+         [JSON.dump(payload)]]
+      end
+    end
+  end
+end

data/lib/keycardai/mcp/require_bearer_auth.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Keycardai
+  module MCP
+    # Rack middleware verifying the Authorization bearer token against the
+    # zone's JWKS. Fail-closed: unauthenticated requests are rejected with an
+    # RFC 6750 challenge advertising the RFC 9728 resource_metadata URL, and
+    # never reach the app. On success the verified AccessToken is stored in
+    # the Rack env (Keycardai::MCP.auth_info).
+    #
+    #   use Keycardai::MCP::RequireBearerAuth,
+    #       verifier: Keycardai::OAuth::TokenVerifier.new(issuers: zone_url),
+    #       required_scopes: ["mcp:tools"]
+    #
+    # Route-level gating is this same middleware applied per route with a
+    # required_scopes set; every configured scope must be present (all-of), a
+    # missing one yielding 403 insufficient_scope.
+    class RequireBearerAuth
+      # @param app [#call] the downstream Rack app
+      # @param verifier [#verify_token] a TokenVerifier
+      # @param required_scopes [Array<String>, String, nil] all-of scope set
+      # @raise [Keycardai::OAuth::ConfigurationError] nil verifier; an auth
+      #   boundary with no verifier is a programming error caught at boot
+      def initialize(app, verifier:, required_scopes: nil)
+        raise Keycardai::OAuth::ConfigurationError, "RequireBearerAuth requires a verifier" if verifier.nil?
+
+        @app = app
+        @verifier = verifier
+        @required_scopes = Array(required_scopes)
+      end
+
+      def call(env)
+        header = env["HTTP_AUTHORIZATION"]
+        return RackSupport.challenge_response(env, status: 401) if header.nil? || header.empty?
+
+        parts = header.split
+        return [400, { "content-type" => "application/json" }, ['{"error":"invalid_request"}']] if parts.length != 2
+
+        scheme, token = parts
+        unless scheme.casecmp("bearer").zero?
+          return RackSupport.challenge_response(env, status: 401, error: "invalid_token",
+                                                     description: "unsupported authorization scheme")
+        end
+
+        authorize(env, token)
+      end
+
+      private
+
+      def authorize(env, token)
+        access_token, failure = verify(token)
+        return RackSupport.challenge_response(env, status: 401, error: "invalid_token", description: failure) if failure
+
+        missing = @required_scopes - access_token.scopes
+        unless missing.empty?
+          return RackSupport.challenge_response(env, status: 403, error: "insufficient_scope",
+                                                     description: "missing required scopes: #{missing.join(" ")}")
+        end
+
+        env[ENV_AUTH_INFO] = access_token
+        @app.call(env)
+      end
+
+      def verify(token)
+        [@verifier.verify_token(token), nil]
+      rescue Keycardai::Error => e
+        [nil, e.message]
+      end
+    end
+  end
+end

data/lib/keycardai/mcp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Keycardai
+  module MCP
+    VERSION = "0.1.0"
+  end
+end

data/lib/keycardai/mcp.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "keycardai/oauth"
+require_relative "mcp/version"
+require_relative "mcp/rack_support"
+require_relative "mcp/require_bearer_auth"
+require_relative "mcp/metadata_app"
+require_relative "mcp/auth_provider"
+
+module Keycardai
+  # Keycard integration for MCP servers, attached at the Rack seam: bearer
+  # middleware (RFC 6750), OAuth metadata endpoints (RFC 9728 / RFC 8414), and
+  # an AuthProvider for delegated token exchange. Handlers read the verified
+  # identity and exchanged tokens from the Rack env.
+  #
+  # Contract: https://github.com/keycardai/keycard-sdk-spec
+  module MCP
+    # Rack env key holding the verified inbound token's AuthInfo.
+    ENV_AUTH_INFO = "keycardai.auth_info"
+
+    # Rack env key holding the AccessContext produced by grant middleware.
+    ENV_ACCESS_CONTEXT = "keycardai.access_context"
+
+    # The verified inbound token for this request, set by RequireBearerAuth.
+    #
+    # @param env [Hash] the Rack env
+    # @return [Keycardai::OAuth::AccessToken, nil]
+    def self.auth_info(env)
+      env[ENV_AUTH_INFO]
+    end
+
+    # The delegated tokens granted for this request, set by grant middleware.
+    #
+    # @param env [Hash] the Rack env
+    # @return [Keycardai::OAuth::AccessContext, nil]
+    def self.access_context(env)
+      env[ENV_ACCESS_CONTEXT]
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: keycardai-mcp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Keycard
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: keycardai-oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: Rack bearer-token middleware (RFC 6750), OAuth protected-resource and
+  authorization-server metadata endpoints (RFC 9728 / RFC 8414), and an AuthProvider
+  for delegated token exchange in MCP servers. Wraps no MCP SDK; attaches to any Rack
+  app, including servers built on the official mcp gem.
+email:
+- support@keycard.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/keycardai/mcp.rb
+- lib/keycardai/mcp/auth_provider.rb
+- lib/keycardai/mcp/metadata_app.rb
+- lib/keycardai/mcp/rack_support.rb
+- lib/keycardai/mcp/require_bearer_auth.rb
+- lib/keycardai/mcp/version.rb
+homepage: https://github.com/keycardai/ruby-sdk
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/keycardai/ruby-sdk/tree/main/mcp
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Keycard MCP server integration at the Rack seam
+test_files: []