rails_ai_admin 0.1.0

data/app/controllers/rails_ai_admin/imports_controller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RailsAiAdmin
+  # Upload a CSV file, check it, then create one record per row.
+  class ImportsController < ApplicationController
+    before_action :load_import
+
+    def new; end
+
+    # A header row naming every importable field; no data and no audit.
+    def template
+      send_data @import.template, filename: "#{@resource.key}-import.csv", type: "text/csv; charset=utf-8", disposition: "attachment"
+    end
+
+    def create
+      file = params[:file]
+      unless file.is_a?(ActionDispatch::Http::UploadedFile)
+        @problem = t("rails_ai_admin.imports.choose_file")
+        return render(:new, status: :unprocessable_content)
+      end
+      raise AccessDenied, "INVALID_QUERY" unless params[:mode].nil? || %w[check import].include?(params[:mode])
+      if file.size > Presentation::CsvImport::MAX_BYTES
+        @problem = t("rails_ai_admin.imports.too_large")
+        return render(:new, status: :unprocessable_content)
+      end
+      @report = @import.call(file.read, write: params[:mode] == "import")
+      render :new, status: @report.failed.any? ? :unprocessable_content : :ok
+    rescue Presentation::CsvImport::Invalid => error
+      @problem = error.message
+      render :new, status: :unprocessable_content
+    end
+
+    private
+
+    def load_import
+      @resource = RailsAiAdmin.registry.fetch(params[:resource])
+      Authorization::Access.new(@context, @resource).authorize_import!
+      @import = Presentation::CsvImport.new(@context, @resource)
+    end
+  end
+end

data/app/controllers/rails_ai_admin/mcp_controller.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RailsAiAdmin
+  # The MCP endpoint. It reads no cookie or session: a bearer token names the
+  # owner, and the host's resolve_job turns that into a fresh Context.
+  class McpController < ActionController::API
+    before_action :prepare_headers
+
+    def handle
+      return head(:forbidden) unless same_origin?
+      context, token = authenticate
+      return unauthorized unless context
+      require "rails_ai_admin/mcp"
+      raw = request.raw_post.to_s
+      return render(json: rpc_error(nil, -32600, "Request too large"), status: :payload_too_large) if raw.bytesize > Mcp::MAX_BODY
+      message = begin
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        return render(json: rpc_error(nil, -32700, "Parse error"), status: :bad_request)
+      end
+      return render(json: rpc_error(nil, -32600, "Batches are not supported"), status: :bad_request) if message.is_a?(Array)
+      server = Mcp::Server.new(context: context, token: token,
+        review_url: ->(surface_id) { admin_surface_url(surface_id: surface_id) })
+      status, body = if RailsAiAdmin.configuration.surfaces
+        Integrations::ToolViews.with_context(context) { server.handle(message) }
+      else
+        server.handle(message)
+      end
+      body ? render(json: body, status: status) : head(status)
+    end
+
+    # No server-initiated stream and no session to end.
+    def unsupported = head(:method_not_allowed)
+
+    private
+
+    def prepare_headers
+      response.headers["Cache-Control"] = "no-store"
+      response.headers["X-Content-Type-Options"] = "nosniff"
+    end
+
+    # MCP requires rejecting cross-site browser requests (DNS rebinding).
+    def same_origin?
+      origin = request.headers["Origin"]
+      return true if origin.blank?
+      URI.parse(origin).then { |uri| uri.host == request.host && (uri.port || 80) == request.port }
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def authenticate
+      raise AccessDenied unless RailsAiAdmin.configuration.mcp
+      require "rails_ai_admin/assistant"
+      require "rails_ai_admin/mcp"
+      require "rails_ai_admin/integrations/tool_views" if RailsAiAdmin.configuration.surfaces
+      header = request.headers["Authorization"].to_s
+      token = Mcp::AccessToken.authenticate(header.delete_prefix("Bearer ").strip) if header.start_with?("Bearer ")
+      return [ nil, nil ] unless token
+      adapter = RailsAiAdmin.configuration.context_adapter&.constantize&.new
+      return [ nil, nil ] unless adapter.respond_to?(:resolve_job)
+      context = ActiveRecord::Base.while_preventing_writes do
+        adapter.resolve_job(actor_ref: token.actor_ref, tenant_ref: token.tenant_ref, security_version: token.security_version)
+      end
+      unless context.is_a?(Context) && context.actor_ref == token.actor_ref && context.tenant_ref == token.tenant_ref &&
+          context.security_version == token.security_version
+        return [ nil, nil ]
+      end
+      token.update_columns(last_used_at: Time.current) if token.last_used_at.nil? || token.last_used_at < 1.minute.ago
+      [ context, token ]
+    rescue AccessDenied, ActiveRecord::ReadOnlyError
+      [ nil, nil ]
+    end
+
+    def unauthorized
+      response.headers["WWW-Authenticate"] = %(Bearer realm="rails_ai_admin")
+      render json: rpc_error(nil, -32001, "A valid admin access token is required"), status: :unauthorized
+    end
+
+    def rpc_error(id, code, message) = { "jsonrpc" => "2.0", "id" => id, "error" => { "code" => code, "message" => message } }
+  end
+end

data/app/controllers/rails_ai_admin/mcp_tokens_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RailsAiAdmin
+  # Personal access tokens for MCP clients. A new token is shown once, in the
+  # response that created it; the list shows names and dates only.
+  class McpTokensController < ApplicationController
+    before_action :require_mcp
+
+    def index
+      load_tokens
+    end
+
+    def create
+      @record, @token = Mcp::AccessToken.issue!(@context, name: params[:name], lifetime: params[:lifetime])
+      load_tokens
+      render :index, status: :created
+    rescue AccessDenied => error
+      raise unless error.code == "INVALID_QUERY"
+      @problem = t("rails_ai_admin.mcp.invalid")
+      load_tokens
+      render :index, status: :unprocessable_content
+    end
+
+    def revoke
+      token = Mcp::AccessToken.for_owner(@context).find_by(id: params[:id])
+      raise AccessDenied unless token
+      token.update!(revoked_at: Time.current) if token.revoked_at.nil?
+      redirect_to mcp_tokens_path, status: :see_other, notice: t("rails_ai_admin.mcp.revoked")
+    end
+
+    private
+
+    def require_mcp
+      raise AccessDenied unless RailsAiAdmin.configuration.mcp
+      require "rails_ai_admin/assistant"
+      require "rails_ai_admin/mcp"
+      raise AccessDenied unless Assistant.available?(@context)
+    end
+
+    def load_tokens
+      @tokens = Mcp::AccessToken.for_owner(@context).order(created_at: :desc).limit(50).to_a
+      @endpoint = mcp_url
+    end
+  end
+end

data/app/controllers/rails_ai_admin/operations_controller.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module RailsAiAdmin
+  # Human input -> pure preview -> input-bound confirmation -> shared Runner.
+  class OperationsController < ApplicationController
+    before_action :resolve_operation
+
+    def new
+      load_form
+      @form_values, @errors = {}, {}
+      render :form
+    end
+
+    def preflight
+      load_form
+      input = submitted_input
+      proposal = Operations::Runner.new.preflight(context: @context, resource: @resource, operation: @definition.key,
+        target_id: @record.id, expected_version: params[:expected_version], input: input)
+      if proposal.is_a?(Operations::Result)
+        render_failure(proposal, input)
+      else
+        @proposal = proposal
+        @form_values = proposal.values
+        @wire_input = JSON.generate(proposal.values.transform_values { |value| wire_value(value) })
+        if request.format.turbo_stream?
+          render turbo_stream: turbo_stream.replace(@flow_id, template: "rails_ai_admin/operations/confirmation", layout: false)
+        else
+          render :confirmation
+        end
+      end
+    end
+
+    def execute
+      input = confirmed_input
+      result = Operations::Runner.new.execute(context: @context, intent_ref: params[:intent_ref], input: input,
+        human_confirmed: true, binding: { resource_key: @resource.key, operation: @definition.key, target_id: params[:id] })
+      if result.success?
+        notice = result.work_refs.any? ? t("rails_ai_admin.operations.completed_with_work") : t("rails_ai_admin.operations.completed")
+        notice += " A host callback needs review." if result.warning
+        redirect_to resource_path(resource: @resource.key, id: result.record_id, **navigation_params), status: :see_other, notice: notice
+      elsif result.code == "NOT_FOUND"
+        raise AccessDenied
+      elsif result.code == "VALIDATION_FAILED"
+        load_form
+        render_failure(result, input)
+      else
+        @failure_code = result.code
+        render :failure, status: %w[OPERATION_FAILED TIMEOUT].include?(result.code) ? :service_unavailable : :conflict
+      end
+    end
+
+    private
+
+    def resolve_operation
+      @resource = RailsAiAdmin.registry.fetch(params[:resource])
+      @definition = RailsAiAdmin.operation_registry.fetch(@resource, params[:operation])
+      raise AccessDenied unless @definition.custom? && @definition.scope == :member
+      @access = Authorization::Access.new(@context, @resource)
+      raise AccessDenied unless @access.canonical_id?(params[:id])
+      resolve_list_navigation
+      @flow_id = "raa_operation_#{@resource.key}_#{params[:id]}_#{@definition.key}"
+    end
+
+    def load_form
+      @record = @access.find!(params[:id], action: @definition.key)
+      @flow_id = "raa_operation_#{@resource.key}_#{@record.id}_#{@definition.key}"
+      @form_fields = @definition.fields(@access, @record)
+    end
+
+    def submitted_input
+      input = params[:input]
+      raise AccessDenied, "INVALID_QUERY" unless input.nil? || input.is_a?(ActionController::Parameters)
+      input ? input.to_unsafe_h : {}
+    end
+
+    def confirmed_input
+      value = params[:confirmed_input]
+      raise AccessDenied, "INVALID_QUERY" unless value.is_a?(String) && value.bytesize <= 16_384
+      JSON.parse(value)
+    rescue JSON::ParserError
+      raise AccessDenied, "INVALID_QUERY"
+    end
+
+    def wire_value(value)
+      case value
+      when BigDecimal then value.to_s("F")
+      when Time, ActiveSupport::TimeWithZone then value.utc.iso8601(6)
+      when Date then value.iso8601
+      else value
+      end
+    end
+
+    def render_failure(result, input)
+      names = @form_fields.map { |field| field.name.to_s }
+      @form_values = input.is_a?(Hash) ? input.stringify_keys.slice(*names).reject { |_, value| value.is_a?(Array) || value.is_a?(Hash) } : {}
+      @errors, @failure_code = result.errors, result.code
+      status = case result.code
+      when "VALIDATION_FAILED" then :unprocessable_content
+      when "CONFLICT" then :conflict
+      else :service_unavailable
+      end
+      render :form, status: status
+    end
+  end
+end

data/app/controllers/rails_ai_admin/references_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RailsAiAdmin
+  # Picker search for reference inputs whose choices exceed the bounded
+  # select. :resource is the target resource; the reply holds only what that
+  # resource's own index would show this actor for the same term.
+  class ReferencesController < ApplicationController
+    def search
+      target = RailsAiAdmin.registry.fetch(params[:resource])
+      term = params[:q]
+      raise AccessDenied, "INVALID_QUERY" unless term.nil? || term.is_a?(String)
+      results = Fields::Association.search(@context, target, term)
+      render json: { results: results.map { |label, id| { id: id, label: label } } }
+    end
+  end
+end

data/app/controllers/rails_ai_admin/resources_controller.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+module RailsAiAdmin
+  # Conventional pages use the same operation runner as other trusted adapters.
+  class ResourcesController < ApplicationController
+    before_action :resolve_resource
+
+    def index
+      raw = params.to_unsafe_h.slice(*Navigation::ListState::KEYS)
+      @list_navigation = Navigation::ListState.new(@access, raw, strict: true)
+      if return_state_discarded?
+        redirect_to list_return_path, status: :see_other, notice: t("rails_ai_admin.resources.index.settings_restored")
+        return
+      end
+      # A native filter form submits every input; share only the canonical
+      # nonblank conditions. This changes no grant and adds no notice.
+      if raw.key?("filter") && raw["filter"] != navigation_state["filter"]
+        redirect_to list_return_path, status: :see_other
+        return
+      end
+      @page = Queries::List.new(@context, @resource).call(search: navigation_state["q"], sort: navigation_state["sort"], direction: navigation_state.fetch("direction", "asc"), page: navigation_state.fetch("page", "1"), recover_empty_page: true, scope: navigation_state["scope"], filters: navigation_state["filter"])
+      if @page.number != navigation_state.fetch("page", "1").to_i
+        @list_navigation = Navigation::ListState.new(@access, navigation_state.merge("page" => @page.number.to_s))
+        redirect_to list_return_path, status: :see_other, notice: t("rails_ai_admin.resources.index.page_empty")
+        return
+      end
+      @sortable_fields = @access.fields(:sort)
+      @list_scopes = @access.named_scopes
+      @filter_fields = @access.fields(:filter)
+      @current_scope = @page.scope
+      @columns = @resource.index.order(@access.fields(:read, view: :index))
+      computed = @columns.map(&:name) | [ @resource.title ]
+      # A record inside the policy scope whose own show check fails is left out
+      # of the page, like an unavailable reference, instead of failing the
+      # whole list (RAA-001). The notice says rows were left out, never which.
+      @rows = @page.records.filter_map do |record|
+        values = @access.project(record, view: :index, only: computed)
+        { id: record.id, label: record_label(@resource, record, values: values, view: :index), values: values,
+          editable: allowed_action?(@resource, :update, record) }
+      rescue AccessDenied
+        @omitted_rows = true
+        nil
+      end
+      # One target query per reference column instead of one per row.
+      @columns.select { |field| field.scalar_type == :belongs_to }.each do |field|
+        admin_associations.prime(field, @rows.filter_map { |row| row[:values][field.name.to_s] })
+      end
+      @searchable = @access.fields(:search).any?
+      @omitted_rows ||= false
+      @selectable = begin
+        @access.authorize_selection!
+      rescue AccessDenied
+        false
+      end
+      @importable = begin
+        @access.authorize_import!
+      rescue AccessDenied
+        false
+      end
+      @exportable = begin
+        @access.authorize_export!
+      rescue AccessDenied
+        false
+      end
+    end
+
+    def show
+      @record = @access.find!(params[:id])
+      @values = @access.project(@record, view: :show)
+      @fields = @access.fields(:read, @record, view: :show)
+      @association_panels = Presentation::AssociationPanel.build(@context, @resource, @record)
+      @operations = RailsAiAdmin.operation_registry.custom(@resource).select { |definition| definition.scope == :member }.select do |definition|
+        @access.authorize!(definition.key, @record)
+        definition.fields(@access, @record)
+        true
+      rescue AccessDenied
+        false
+      end
+    end
+
+    # Who changed this record, when and which fields, newest first.
+    def history
+      @record = @access.find!(params[:id])
+      before = params[:before]
+      raise AccessDenied, "INVALID_QUERY" unless before.nil? || before.is_a?(String)
+      @history = Presentation::History.new(@access, @record).page(before: before)
+      @actor_labels = actor_labels(@history.entries.map(&:actor_ref).uniq)
+    end
+
+    def new
+      prepare_form(:create)
+    end
+
+    def edit
+      prepare_form(:update)
+    end
+
+    def recover_form
+      response.headers["Vary"] = [ response.headers["Vary"], "Cookie", "X-RailsAiAdmin-Recovery-Intent", "X-RailsAiAdmin-Return-State" ].compact.join(", ")
+      @intent_ref = request.headers["X-RailsAiAdmin-Recovery-Intent"]
+      session = runner.resume_form(context: @context, resource: @resource, intent_ref: @intent_ref)
+      @intent, @record = session.intent, session.record
+      @operation = @intent.operation.to_sym
+      build_form_plan(@operation)
+      @errors = {}
+      render @operation == :create ? :new : :edit
+      response.headers["X-RailsAiAdmin-Form-Recovery"] = "ready"
+    end
+
+    def confirm_destroy
+      prepare_form(:destroy)
+    end
+
+    def create = submit(:create)
+    def update = submit(:update)
+    def destroy = submit(:destroy)
+
+    private
+
+    def resolve_resource
+      @resource = RailsAiAdmin.registry.fetch(params[:resource])
+      @access = Authorization::Access.new(@context, @resource)
+      raise AccessDenied if params.key?(:id) && !@access.canonical_id?(params[:id])
+      resolve_list_navigation unless action_name == "index"
+    end
+
+    def runner
+      @runner ||= Operations::Runner.new
+    end
+
+    def prepare_form(operation)
+      @operation = operation
+      @record = operation == :create ? @access.relation.new : @access.find!(params[:id], action: operation)
+      @access.authorize!(operation, @record)
+      build_form_plan(operation, operation == :create ? prefill_values : nil) unless operation == :destroy
+      @errors = {}
+      # GET stays read-only: the form carries a signed reference that becomes
+      # an intent on submit (RAA-005, ADR 0025).
+      @intent_ref = runner.issue_form_intent(context: @context, resource: @resource, operation: operation,
+        target_id: operation == :create ? nil : @record.id, expected_version: operation == :create ? nil : RecordVersion.of(@record)).ref
+      render operation == :destroy ? :confirm_destroy : operation == :create ? :new : :edit
+    end
+
+    # prefill[<belongs_to field>]=<key> starts a new record pointing at a
+    # parent, as the "Add" link of an association panel does. Only writable
+    # references to targets the actor can see are taken; anything else is
+    # ignored, and the person still submits the form.
+    def prefill_values
+      raw = params[:prefill]
+      return nil unless raw.is_a?(ActionController::Parameters)
+      raw = raw.to_unsafe_h
+      references = @access.fields(:write, @record, operation: :create).select { |field| field.scalar_type == :belongs_to }
+      resolver = Fields::Association.new(@context, @resource)
+      references.each_with_object({}) do |field, values|
+        value = raw[field.name.to_s]
+        next unless value.is_a?(String)
+        key = field.coerce(value)
+        values[field.name.to_s] = key if key && resolver.admissible?(field, key)
+      rescue ArgumentError
+        next
+      end
+    end
+
+    def submit(operation)
+      input = operation == :destroy ? {} : submitted_input
+      @intent_ref = params[:intent_ref]
+      intent_id = runner.materialize_form_intent(context: @context, reference: @intent_ref)
+      upload_files(operation, input) unless operation == :destroy
+      result = runner.execute(context: @context, intent_ref: intent_id, input: input,
+        human_confirmed: true, origin: :ui,
+        binding: { resource_key: @resource.key, operation: operation, target_id: params[:id] })
+      discard_uploads unless result.success?
+      if result.success?
+        target = operation == :destroy ? list_return_path : resource_path(resource: @resource.key, id: result.record_id, **navigation_params)
+        redirect_to target, status: :see_other, notice: result.warning ? t("rails_ai_admin.resources.saved_with_warning", operation: intent_id) : t("rails_ai_admin.resources.saved")
+      elsif result.code == "NOT_FOUND"
+        raise AccessDenied
+      else
+        @operation = operation
+        @record = operation == :create ? @access.relation.new : @access.find!(params[:id], action: operation)
+        @access.authorize!(operation, @record)
+        @intent = OperationRun.find_by!(id: intent_id, actor_ref: @context.actor_ref, tenant_ref: @context.tenant_ref)
+        build_form_plan(operation, input) unless operation == :destroy
+        names = operation == :destroy ? [] : @form_fields.map { |field| field.name.to_s }
+        @errors = result.errors.slice("base", *names)
+        @errors["base"] ||= [ t("rails_ai_admin.resources.form.inputs_unavailable") ] if (result.errors.keys - [ "base" ] - names).any?
+        @failure_code = result.code
+        # A restricted delete can succeed once the references are gone.
+        @needs_reload = !%w[VALIDATION_FAILED RESTRICTED].include?(result.code)
+        render operation == :destroy ? :confirm_destroy : operation == :create ? :new : :edit,
+          status: %w[VALIDATION_FAILED RESTRICTED].include?(result.code) ? :unprocessable_content : :conflict
+      end
+    rescue ActiveRecord::RecordNotFound
+      raise AccessDenied
+    end
+
+    # A chosen file becomes a new blob before the write, and only for a file
+    # field the actor may write now. Pages never pass blob ids: a text value in
+    # a file slot is refused. remove_files[] clears a file that is not required.
+    def upload_files(operation, input)
+      @uploaded_blobs = []
+      record = operation == :create ? @access.relation.new : @access.find!(params[:id], action: operation)
+      writable = @access.fields(:write, record, operation: operation)
+      upload_lists(writable.select { |field| field.scalar_type == :files }, input)
+      files = writable.select { |field| field.scalar_type == :file }.index_by { |field| field.name.to_s }
+      input.each_key do |name|
+        value = input[name]
+        next if writable.any? { |field| field.scalar_type == :files && field.name.to_s == name }
+        next unless files.key?(name) || value.is_a?(ActionDispatch::Http::UploadedFile)
+        field = files[name] || raise(AccessDenied, "INVALID_QUERY")
+        if value == ""
+          input.delete(name)
+        elsif !value.is_a?(ActionDispatch::Http::UploadedFile)
+          raise AccessDenied, "INVALID_QUERY"
+        elsif value.size > field.options[:max_size]
+          input[name] = Fields::RejectedUpload.new("too_large", field.options[:max_size])
+        else
+          input[name] = store_upload(value)
+        end
+      end
+      removals = params[:remove_files]
+      return if removals.nil?
+      raise AccessDenied, "INVALID_QUERY" unless removals.is_a?(Array) && removals.size <= files.size && removals.all? { |name| name.is_a?(String) && files.key?(name) }
+      removals.each { |name| input[name] = nil unless input.key?(name) }
+    end
+
+    def store_upload(value)
+      raise ConfigurationError, "file fields need Active Storage" unless defined?(::ActiveStorage::Blob)
+      blob = ::ActiveStorage::Blob.create_and_upload!(io: value, filename: value.original_filename.presence || "upload",
+        content_type: value.content_type, identify: true)
+      @uploaded_blobs << blob
+      blob.signed_id
+    end
+
+    # files fields: record[photos][] carries new uploads and
+    # remove_attachments[photos][] the attachment ids to remove.
+    def upload_lists(fields, input)
+      removals = params[:remove_attachments]
+      removals = removals.to_unsafe_h if removals.is_a?(ActionController::Parameters)
+      raise AccessDenied, "INVALID_QUERY" unless removals.nil? || removals.is_a?(Hash)
+      removals ||= {}
+      raise AccessDenied, "INVALID_QUERY" unless (removals.keys - fields.map { |field| field.name.to_s }).empty?
+      fields.each do |field|
+        name = field.name.to_s
+        uploads = input.key?(name) ? input[name] : []
+        remove = removals.fetch(name, [])
+        raise AccessDenied, "INVALID_QUERY" unless uploads.is_a?(Array) && remove.is_a?(Array) && remove.all? { |id| id.is_a?(String) }
+        uploads = uploads.reject { |value| value == "" }
+        raise AccessDenied, "INVALID_QUERY" unless uploads.all? { |value| value.is_a?(ActionDispatch::Http::UploadedFile) }
+        added = uploads.map { |value| value.size > field.options[:max_size] ? Fields::RejectedUpload.new("too_large", field.options[:max_size]) : store_upload(value) }
+        if added.empty? && remove.empty?
+          input.delete(name)
+        else
+          input[name] = { "add" => added, "remove" => remove }
+        end
+      end
+    end
+
+    # A refused write keeps no new upload; the person chooses the file again.
+    def discard_uploads
+      Array(@uploaded_blobs).each { |blob| blob.purge_later unless blob.attachments.exists? }
+    end
+
+    def submitted_input
+      value = params[:record]
+      raise AccessDenied, "INVALID_QUERY" unless value.nil? || value.is_a?(ActionController::Parameters)
+      value.is_a?(ActionController::Parameters) ? value.to_unsafe_h : {}
+    end
+
+    def build_form_plan(operation, input = nil)
+      view = operation == :create ? :create : :edit
+      @form_fields = @access.fields(:write, @record, operation: operation)
+      readable_values = begin
+        @access.project(@record, view: view)
+      rescue AccessDenied
+        {}
+      end
+      names = @form_fields.map { |field| field.name.to_s }
+      @form_values = readable_values.slice(*names)
+      if input.is_a?(Hash)
+        # A refused file is chosen again; the form keeps showing the stored one.
+        files = @form_fields.select { |field| Field::FILE_TYPES.include?(field.scalar_type) }.map { |field| field.name.to_s }
+        @form_values.merge!(input.stringify_keys.slice(*(names - files)).reject { |_, value| value.is_a?(Hash) || value.is_a?(Array) })
+      end
+      readonly_fields = @access.fields(:read, @record, view: view).select { |field| readable_values.key?(field.name.to_s) && !names.include?(field.name.to_s) }
+      readonly_values = readable_values.slice(*readonly_fields.map { |field| field.name.to_s })
+      @form_plan = Forms::Plan.new(fields: @form_fields, values: @form_values, readonly_fields: readonly_fields, readonly_values: readonly_values, order: @resource.fields)
+    end
+  end
+end

data/app/controllers/rails_ai_admin/search_controller.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsAiAdmin
+  # One search box over every resource the actor may list and search. Each
+  # resource runs its own list query (policy relation, default list tab,
+  # granted search fields) and each row its own show grant.
+  class SearchController < ApplicationController
+    PER_RESOURCE = 5
+    # A bound on list queries for one search.
+    MAX_RESOURCES = 30
+    Section = Data.define(:resource, :rows, :more)
+    Row = Data.define(:id, :label)
+
+    def index
+      query = params[:q]
+      raise AccessDenied, "INVALID_QUERY" unless query.nil? || query.is_a?(String)
+      @query = query.to_s.strip
+      raise AccessDenied, "INVALID_QUERY" unless @query.valid_encoding? && @query.length <= 200
+      @sections = @query.empty? ? [] : searchable_resources.first(MAX_RESOURCES).filter_map { |resource| section(resource) }
+    end
+
+    private
+
+    def section(resource)
+      access = Authorization::Access.new(@context, resource)
+      page = Queries::List.new(@context, resource).call(search: @query, page_size: PER_RESOURCE)
+      rows = page.records.filter_map do |record|
+        access.authorize!(:show, record)
+        Row.new(record.id.to_s, access.record_label(record, view: :index))
+      rescue AccessDenied
+        nil
+      end
+      return if rows.empty?
+      Section.new(resource, rows, page.has_next)
+    rescue AccessDenied
+      nil
+    end
+  end
+end