iron-cms 0.18.2 → 0.19.0

data/app/controllers/concerns/iron/api/token_authentication.rb

@@ -13,15 +13,10 @@ module Iron
 
         def authenticate_integration
           authenticate_with_http_token do |token|
-            integration = Integration.find_by(token: token)
-            return head(:unauthorized) unless integration
-            return head(:unauthorized) if integration.expired?
-
-            user = integration.user
-            return head(:unauthorized) unless user&.active?
+            user = Integration.authenticate(token)
+            return head(:unauthorized) unless user
 
             Current.user = user
-            integration.touch(:last_used_at)
           end || head(:unauthorized)
         end
     end

data/app/controllers/concerns/iron/bounded_request_body.rb

@@ -0,0 +1,48 @@
+module Iron
+  module BoundedRequestBody
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :max_request_bytes, default: 10.megabytes, instance_writer: false
+    end
+
+    class_methods do
+      def bound_request_body(to:)
+        self.max_request_bytes = to
+      end
+    end
+
+    # Action Controller's instrumentation reads the request parameters — fully
+    # buffering and parsing the body — before any controller callback runs, so
+    # the size guard must wrap process_action itself: a before_action fires too
+    # late to stop an oversized body from being buffered into memory.
+    def process_action(...)
+      if acceptable_request_body?
+        super
+      else
+        head :content_too_large
+      end
+    end
+
+    private
+      def acceptable_request_body?
+        request.get_header("CONTENT_LENGTH").to_i <= max_request_bytes && buffer_request_body
+      end
+
+      # Re-homes the body onto a capped in-memory copy so a chunked request
+      # that never declared its length still can't feed the parameter parser
+      # more than the limit.
+      def buffer_request_body
+        body = request.body_stream&.read(max_request_bytes + 1).to_s
+        return false if body.bytesize > max_request_bytes
+
+        replace_request_body(StringIO.new(body), body.bytesize)
+        true
+      end
+
+      def replace_request_body(input, length)
+        request.set_header("rack.input", input)
+        request.set_header("CONTENT_LENGTH", length.to_s)
+      end
+  end
+end

data/app/controllers/iron/api/base_controller.rb

@@ -3,7 +3,10 @@ module Iron
     class BaseController < ActionController::API
       include ActiveStorage::SetCurrent
       include TokenAuthentication, LocaleResolution, Authorization
+      include BoundedRequestBody
 
+      # Sized for base64-encoded uploads of MAX_DOWNLOAD_BYTES-sized files.
+      bound_request_body to: 75.megabytes
       rate_limit to: 60, within: 1.minute
 
       rescue_from ActiveRecord::RecordNotFound, with: :render_not_found

data/app/controllers/iron/api/mcp_controller.rb

@@ -0,0 +1,119 @@
+module Iron
+  module Api
+    class McpController < BaseController
+      skip_before_action :authenticate_integration
+      # The default locale resolution reads params; resolve from the query
+      # string instead so nothing needs the (detached) body before `handle`.
+      skip_before_action :set_locale
+      before_action :verify_request_origin
+      before_action :verify_protocol_version
+      before_action :authenticate_mcp!
+      before_action :resolve_mcp_locale
+
+      def handle
+        return head :method_not_allowed unless request.post?
+
+        body = bounded_body
+        return head :content_too_large unless body
+        return reject_batch if batch?(body)
+
+        reply = server.handle_json(body)
+
+        if reply.nil?
+          head :accepted
+        else
+          render json: reply
+        end
+      end
+
+      private
+
+        # The JSON-RPC server consumes the raw body, so nothing should parse it
+        # into params: detach it before the framework's instrumentation runs,
+        # and read it — capped — only once the request is authenticated.
+        def buffer_request_body
+          request.set_header("iron.mcp_input", request.body_stream)
+          replace_request_body(StringIO.new(""), 0)
+          true
+        end
+
+        def bounded_body
+          body = request.get_header("iron.mcp_input")&.read(max_request_bytes + 1).to_s
+          body unless body.bytesize > max_request_bytes
+        end
+
+        # JSON-RPC batching was removed from the MCP spec (2025-06-18), and a
+        # batch would let one rate-limited request amplify into arbitrarily
+        # many tool calls.
+        def batch?(body)
+          body.match?(/\A\s*\[/)
+        end
+
+        def reject_batch
+          render json: {
+            jsonrpc: "2.0",
+            error: { code: -32600, message: "JSON-RPC batch requests are not supported" },
+            id: nil
+          }, status: :bad_request
+        end
+
+        # This endpoint has no legitimate browser client: Claude Code, the
+        # claude.ai backend, and scripts all call it server-to-server with no
+        # Origin header. Any Origin therefore marks a browser-originated
+        # request — including a DNS-rebinding page — and is refused. Matching
+        # the request Host instead would be no defense, since a rebinding
+        # attacker controls the Host as well as the Origin.
+        def verify_request_origin
+          head :forbidden if request.headers["Origin"].present?
+        end
+
+        # An explicit MCP-Protocol-Version must be one the server speaks; an
+        # absent header falls back to the negotiated default per the spec.
+        def verify_protocol_version
+          version = request.headers["MCP-Protocol-Version"]
+          return if version.blank? || MCP::Configuration::SUPPORTED_STABLE_PROTOCOL_VERSIONS.include?(version)
+
+          head :bad_request
+        end
+
+        def resolve_mcp_locale
+          code = request.query_parameters[:locale]
+          Current.locale = (Locale.find_by(code: code) if code.present?) || Locale.default
+        end
+
+        def server
+          Iron::Mcp::Server.build(context: Iron::Mcp::ToolContext.new)
+        end
+
+        def authenticate_mcp!
+          token = bearer_token
+          user = token.present? && (user_from_oauth(token) || Integration.authenticate(token))
+
+          return Current.user = user if user
+
+          challenge_for_authorization
+        end
+
+        def bearer_token
+          ActionController::HttpAuthentication::Token.token_and_options(request)&.first
+        end
+
+        def user_from_oauth(token)
+          access = Iron::Oauth::Token.authenticate(token)
+          return unless access&.scopes_include?(Iron::Oauth::Scope::MCP_ACCESS)
+          return unless access.audience == Oauth::Resource.url(request.base_url)
+
+          user = access.user
+          user if user&.active?
+        rescue ActiveRecord::StatementInvalid
+          nil
+        end
+
+        def challenge_for_authorization
+          metadata_url = "#{request.base_url}/.well-known/oauth-protected-resource"
+          response.set_header("WWW-Authenticate", %(Bearer resource_metadata="#{metadata_url}"))
+          head :unauthorized
+        end
+    end
+  end
+end

data/app/controllers/iron/api/openapi_controller.rb

@@ -4,19 +4,12 @@ module Iron
       skip_before_action :authenticate_integration
 
       def show
-        spec = Rails.cache.fetch(cache_key, expires_in: 1.hour) do
+        spec = Rails.cache.fetch(OpenapiSpec.cache_key, expires_in: 1.hour) do
           OpenapiSpec.new.to_h
         end
 
         render json: spec
       end
-
-      private
-
-        def cache_key
-          latest = [ ContentType, FieldDefinition, BlockDefinition ].filter_map { |m| m.maximum(:updated_at) }.max
-          "iron/openapi/#{latest&.to_i}"
-        end
     end
   end
 end

data/app/controllers/iron/oauth/authorizations_controller.rb

@@ -0,0 +1,120 @@
+module Iron
+  module Oauth
+    class AuthorizationsController < Iron::ApplicationController
+      PKCE_CHALLENGE = /\A[A-Za-z0-9\-_]{43}\z/
+
+      layout "iron/authentication"
+
+      before_action :load_client
+      before_action :validate_authorization_request
+
+      def new
+      end
+
+      def create
+        if approved?
+          _grant, code = Grant.issue!(
+            client: @client,
+            user: Current.user,
+            redirect_uri: @redirect_uri,
+            scopes: @scopes,
+            code_challenge: @code_challenge,
+            code_challenge_method: @code_challenge_method,
+            resource: @resource
+          )
+          redirect_to_client(code: code)
+        else
+          redirect_to_client(error: "access_denied")
+        end
+      end
+
+      private
+
+        def load_client
+          @client = Client.find_by(uid: params[:client_id])
+          @redirect_uri = params[:redirect_uri].to_s
+
+          render_invalid_request unless @client&.redirect_uri_allowed?(@redirect_uri)
+        end
+
+        def validate_authorization_request
+          return redirect_to_client(error: "unsupported_response_type") unless params[:response_type] == "code"
+          return redirect_to_client(error: "invalid_request") if pkce_missing?
+          return redirect_to_client(error: "invalid_request") unless scope_param_valid?
+          return redirect_to_client(error: "invalid_scope") unless scopes_subset?
+          return redirect_to_client(error: "invalid_target") unless resource_permitted?
+
+          @scopes = requested_scopes.join(" ")
+          @code_challenge = params[:code_challenge]
+          @code_challenge_method = params[:code_challenge_method]
+          @resource = Resource.normalize(params[:resource])
+        end
+
+        def approved?
+          params[:decision] == "approve"
+        end
+
+        def pkce_missing?
+          params[:code_challenge_method] != "S256" || !params[:code_challenge].to_s.match?(PKCE_CHALLENGE)
+        end
+
+        def scope_param_valid?
+          params[:scope].nil? || params[:scope].is_a?(String)
+        end
+
+        def scopes_subset?
+          (requested_scopes - @client.scopes.split).empty?
+        end
+
+        def requested_scopes
+          params[:scope].presence&.split || @client.scopes.split
+        end
+
+        def resource_permitted?
+          Resource.permitted?(params[:resource], base_url: request.base_url)
+        end
+
+        def redirect_to_client(query)
+          redirect_to authorization_response_uri(query), allow_other_host: true
+        end
+
+        def authorization_response_uri(query)
+          uri = URI.parse(@redirect_uri)
+          pairs = URI.decode_www_form(uri.query.to_s)
+          pairs += query.merge(state: state_param).compact.to_a
+          uri.query = URI.encode_www_form(pairs)
+          uri.to_s
+        end
+
+        def state_param
+          params[:state] if params[:state].is_a?(String)
+        end
+
+        def render_invalid_request
+          render plain: t("iron.oauth.authorizations.invalid_request"), status: :bad_request
+        end
+
+        def request_authentication
+          session[:return_to_after_authenticating] = resumable_authorization_url
+          redirect_to Iron::Engine.routes.url_helpers.sign_in_path
+        end
+
+        def resumable_authorization_url
+          "/oauth/authorize?" + authorization_request_params.to_query
+        end
+
+        def authorization_request_params
+          {
+            client_id: params[:client_id],
+            redirect_uri: params[:redirect_uri],
+            response_type: params[:response_type],
+            scope: params[:scope],
+            state: params[:state],
+            code_challenge: params[:code_challenge],
+            code_challenge_method: params[:code_challenge_method],
+            resource: params[:resource]
+          }.compact
+        end
+    end
+  end
+end

data/app/controllers/iron/oauth/metadata_controller.rb

@@ -0,0 +1,38 @@
+module Iron
+  module Oauth
+    class MetadataController < ActionController::API
+      def protected_resource
+        render json: {
+          resource: mcp_resource_url,
+          authorization_servers: [ issuer ],
+          bearer_methods_supported: %w[ header ],
+          scopes_supported: Scope::SUPPORTED
+        }
+      end
+
+      def authorization_server
+        render json: {
+          issuer: issuer,
+          authorization_endpoint: "#{issuer}/oauth/authorize",
+          token_endpoint: "#{issuer}/oauth/token",
+          registration_endpoint: "#{issuer}/oauth/register",
+          response_types_supported: %w[ code ],
+          grant_types_supported: %w[ authorization_code refresh_token ],
+          token_endpoint_auth_methods_supported: %w[ none ],
+          code_challenge_methods_supported: %w[ S256 ],
+          scopes_supported: Scope::SUPPORTED
+        }
+      end
+
+      private
+
+        def issuer
+          request.base_url
+        end
+
+        def mcp_resource_url
+          "#{issuer}#{Iron::Engine.routes.url_helpers.api_mcp_path}"
+        end
+    end
+  end
+end

data/app/controllers/iron/oauth/registrations_controller.rb

@@ -0,0 +1,54 @@
+module Iron
+  module Oauth
+    class RegistrationsController < ActionController::API
+      include Iron::BoundedRequestBody
+
+      bound_request_body to: 64.kilobytes
+      rate_limit to: 10, within: 1.minute, only: :create
+
+      def create
+        client = Client.new(
+          name: client_name,
+          redirect_uris: redirect_uris.join("\n"),
+          scopes: Scope.default
+        )
+
+        if client.save
+          render json: client_information(client), status: :created
+        else
+          render json: registration_error(client), status: :bad_request
+        end
+      end
+
+      private
+
+        def client_name
+          params[:client_name].presence || "MCP Client"
+        end
+
+        def redirect_uris
+          Array(params[:redirect_uris]).map(&:to_s).reject(&:blank?)
+        end
+
+        def client_information(client)
+          {
+            client_id: client.uid,
+            client_id_issued_at: client.created_at.to_i,
+            client_name: client.name,
+            redirect_uris: client.redirect_uri_list,
+            grant_types: %w[ authorization_code refresh_token ],
+            response_types: %w[ code ],
+            token_endpoint_auth_method: "none",
+            scope: client.scopes.to_s
+          }
+        end
+
+        def registration_error(client)
+          {
+            error: "invalid_client_metadata",
+            error_description: client.errors.full_messages.join(", ")
+          }
+        end
+    end
+  end
+end

data/app/controllers/iron/oauth/tokens_controller.rb

@@ -0,0 +1,92 @@
+module Iron
+  module Oauth
+    class TokensController < ActionController::API
+      include Iron::BoundedRequestBody
+
+      PKCE_VERIFIER = /\A[A-Za-z0-9\-._~]{43,128}\z/
+
+      bound_request_body to: 64.kilobytes
+      rate_limit to: 30, within: 1.minute, only: :create
+      before_action :prevent_token_caching, only: :create
+
+      def create
+        case params[:grant_type]
+        when "authorization_code"
+          issue_from_authorization_code
+        when "refresh_token"
+          issue_from_refresh_token
+        else
+          render_error("unsupported_grant_type")
+        end
+      end
+
+      private
+
+        def issue_from_authorization_code
+          code = string_param(:code)
+          verifier = string_param(:code_verifier)
+          redirect_uri = string_param(:redirect_uri)
+          resource = string_param(:resource)
+          return render_error("invalid_request") if code.blank? || redirect_uri.blank?
+          return render_error("invalid_request") unless verifier&.match?(PKCE_VERIFIER)
+          return render_error("invalid_target") unless Resource.permitted?(resource, base_url: request.base_url)
+
+          client = Client.find_by(uid: string_param(:client_id))
+          return render_error("invalid_client") unless client
+
+          issued = Grant.redeem(code, client: client, redirect_uri: redirect_uri, verifier: verifier, resource: Resource.normalize(resource)) do |grant|
+            Token.issue!(client: client, user: grant.user, scopes: grant.scopes, audience: grant.resource)
+          end
+          return render_error("invalid_grant") unless issued
+
+          render_token issued
+        end
+
+        # The resource indicator is optional on refresh: the rotated token
+        # keeps the grant's audience either way, so omitting it can't broaden
+        # what the token is good for — but naming a foreign resource is an
+        # explicit request this server must refuse.
+        def issue_from_refresh_token
+          refresh_token = string_param(:refresh_token)
+          return render_error("invalid_request") if refresh_token.blank?
+          return render_error("invalid_target") unless refresh_resource_permitted?
+
+          client = Client.find_by(uid: string_param(:client_id))
+          return render_error("invalid_client") unless client
+
+          issued = Token.exchange_refresh(refresh_token, client: client)
+          return render_error("invalid_grant") unless issued
+
+          render_token issued
+        end
+
+        def refresh_resource_permitted?
+          params[:resource].nil? || Resource.permitted?(string_param(:resource), base_url: request.base_url)
+        end
+
+        def string_param(key)
+          value = params[key]
+          value if value.is_a?(String)
+        end
+
+        def render_token(issued)
+          render json: {
+            access_token: issued.access_token,
+            token_type: "Bearer",
+            expires_in: issued.expires_in,
+            refresh_token: issued.refresh_token,
+            scope: issued.scope
+          }
+        end
+
+        def render_error(code)
+          render json: { error: code }, status: :bad_request
+        end
+
+        def prevent_token_caching
+          response.headers["Cache-Control"] = "no-store"
+          response.headers["Pragma"] = "no-cache"
+        end
+    end
+  end
+end

data/app/mcp/iron/mcp/error.rb

@@ -0,0 +1,5 @@
+module Iron
+  module Mcp
+    class Error < StandardError; end
+  end
+end

data/app/mcp/iron/mcp/forbidden.rb

@@ -0,0 +1,9 @@
+module Iron
+  module Mcp
+    class Forbidden < Error
+      def initialize(message = "Your token is not allowed to write content")
+        super
+      end
+    end
+  end
+end

data/app/mcp/iron/mcp/invalid_request.rb

@@ -0,0 +1,5 @@
+module Iron
+  module Mcp
+    class InvalidRequest < Error; end
+  end
+end

data/app/mcp/iron/mcp/paginator.rb

@@ -0,0 +1,19 @@
+module Iron
+  module Mcp
+    class Paginator
+      include Iron::Api::CursorPagination
+
+      def initialize(after: nil, per_page: nil)
+        @params = { after:, per_page: }.compact.with_indifferent_access
+      end
+
+      def call(scope)
+        paginate(scope)
+      end
+
+      private
+
+        attr_reader :params
+    end
+  end
+end

data/app/mcp/iron/mcp/server.rb

@@ -0,0 +1,38 @@
+module Iron
+  module Mcp
+    module Server
+      module_function
+
+      def build(context:)
+        ::MCP::Server.new(
+          name: "iron-cms",
+          title: "Iron CMS",
+          version: Iron::VERSION,
+          tools: tools,
+          server_context: { iron: context },
+          configuration: configuration
+        )
+      end
+
+      def tools
+        [
+          Tools::ListContentTypes,
+          Tools::DescribeSchema,
+          Tools::ListEntries,
+          Tools::GetEntry,
+          Tools::CreateEntry,
+          Tools::UpdateEntry,
+          Tools::DeleteEntry,
+          Tools::UploadAsset,
+          Tools::Search
+        ]
+      end
+
+      def configuration
+        ::MCP::Configuration.new(
+          exception_reporter: ->(exception, _server_context) { Rails.error.report(exception, handled: true, source: "iron.mcp") }
+        )
+      end
+    end
+  end
+end