activeadmin_mcp 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99312ac0bef360e80a8d058b79adf5f0af182d3bedc19fdfbf4caa69964f7e44
-  data.tar.gz: bba982b59472e271c18214bc4674e60a3ae96729b78172163d54eed756b3997c
+  metadata.gz: 1d97e042cb6e4af51f5939d4edd39a96f7193ece948a05a70dd8e18851f1bc85
+  data.tar.gz: 6b91b93d2d0511f3bea310f62044589eb35b90358547e942d379be214582d5e7
 SHA512:
-  metadata.gz: 861ea8e3d8eeff901f12f4fa99385db60fd0854a0eae22462cf314cce67820632033b8e55ebc13252bcaa3389f0b6aceda4cc712d5bceb4ba0c342ac10a5815d
-  data.tar.gz: 035b92456d5b3ca111c5e4715c8f495f52531ab053eb7974f1c1dda12de73d87f08ba34b40f226723d8a207bc98a89c929c4d6bb8ecdc9ee0873fdc6fbefb275
+  metadata.gz: 6714a33bbef7072a22f067f422837e6ccf88ebd6a835157c8ffa8fff5487791ee2494fbcd1316ac4ca65c9767e53ac6e48a7c672e84846615fb77af29b507080
+  data.tar.gz: fb49f14f716cd9c5a5e0b9ca80c546adaaa7fcab15b8867965c7d823084f456580982270185c65861477c11840c219cbdf41fd676a597c2b39c4835ec7d0f5f4

data/README.md

@@ -21,11 +21,17 @@ The server is a Rails engine mounted inside your application (by default at
 - **Queries use Ransack.** The `query` tool passes its arguments straight to
   [Ransack](https://activerecord-hackery.github.io/ransack/), the same search
   library ActiveAdmin uses for filtering.
+- **Reads go through ActiveAdmin too.** `list_resources` and `query` run through
+  the same authorization adapter (CanCanCan, Pundit, etc.) as the authenticated
+  MCP user: resources the user cannot read are hidden from the listing and
+  refused by `query`, and every query is scoped with the adapter's
+  `scope_collection`, so the MCP user only ever sees the records they could see
+  in the admin UI. With ActiveAdmin's default adapter every check passes, so
+  applications without an authorization adapter are unaffected.
 - **Writes go through ActiveAdmin.** The `update` tool only writes fields
   allowed by the resource's `permit_params`, refuses resources that don't
   register the `update` action, and runs every change through your
-  authorization adapter (CanCanCan, Pundit, etc.) as the authenticated MCP
-  user.
+  authorization adapter as the authenticated MCP user.
 - **Authentication is optional but built in.** Enable Bearer-token auth and the
   installer adds an "MCP Tokens" management page to your ActiveAdmin panel.
 
@@ -57,8 +63,8 @@ read/query setup without authentication.
 
 | Tool | Description |
 |------|-------------|
-| `list_resources` | List every ActiveAdmin resource along with its attributes. |
-| `query` | Query a resource using Ransack syntax (`limit` defaults to 25, capped at 100). |
+| `list_resources` | List the ActiveAdmin resources the current user may read, along with their attributes. |
+| `query` | Query a resource the current user may read, using Ransack syntax, scoped to the records they may access (`limit` defaults to 25, capped at 100). |
 | `update` | Update an existing record, honouring ActiveAdmin's permitted params and authorization. |
 
 ### Query examples

data/lib/activeadmin_mcp/authorization.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ActiveadminMcp
+  # Applies a resource's ActiveAdmin authorization adapter to MCP tool calls, so
+  # reads, listings and writes obey the same rules as the admin UI.
+  #
+  # ActiveAdmin's default adapter authorizes every action and returns collections
+  # unchanged, so applications without an authorization adapter are unaffected.
+  # Applications that configure one (CanCanCan via `cancan_ability_class`, Pundit,
+  # a custom adapter, ...) get their policy enforced on every path.
+  class Authorization
+    READ = :read
+
+    def self.for(config, current_user)
+      adapter_class = config.namespace.authorization_adapter
+      adapter_class = adapter_class.constantize if adapter_class.is_a?(String)
+      new(adapter_class.new(config, current_user))
+    end
+
+    def initialize(adapter)
+      @adapter = adapter
+    end
+
+    def authorized?(action, subject)
+      @adapter.authorized?(action, subject)
+    end
+
+    def scope_collection(collection, action = READ)
+      @adapter.scope_collection(collection, action)
+    end
+  end
+end

data/lib/activeadmin_mcp/form_field_collector.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveadminMcp
+  # Records the field names declared by an ActiveAdmin `form do ... end` block.
+  #
+  # ActiveAdmin form blocks are arbitrary Formtastic DSL — `input`, `inputs`,
+  # `actions`, helper calls, conditionals — so the block is run against this
+  # stand-in form builder. Every `input :field` records `:field`; every other
+  # message (including unknown helpers) is swallowed and returns self, so the
+  # block executes without a real view context. Nested `has_many` associations
+  # are intentionally not descended into: the updater only writes flat
+  # attributes, and descending would record association fields as top-level.
+  class FormFieldCollector
+    attr_reader :fields
+
+    def initialize
+      @fields = []
+    end
+
+    def collect(&block)
+      instance_exec(self, &block)
+      @fields.uniq
+    end
+
+    def input(name, *_args, **_opts, &_block)
+      @fields << name.to_sym if name.respond_to?(:to_sym)
+      self
+    end
+
+    def inputs(*_args, **_opts, &block)
+      instance_exec(self, &block) if block
+      self
+    end
+
+    def has_many(*_args, **_opts)
+      self
+    end
+
+    def method_missing(_name, *_args, **_opts, &block)
+      instance_exec(self, &block) if block
+      self
+    end
+
+    def respond_to_missing?(_name, _include_private = false)
+      true
+    end
+  end
+end

data/lib/activeadmin_mcp/record_updater.rb

@@ -53,29 +53,50 @@ module ActiveadminMcp
     end
 
     def authorized?(config, record)
-      adapter_class = config.namespace.authorization_adapter
-      adapter_class = adapter_class.constantize if adapter_class.is_a?(String)
-      adapter_class.new(config, @current_user).authorized?(UPDATE, record)
+      Authorization.for(config, @current_user).authorized?(UPDATE, record)
     end
 
-    # Runs the incoming attributes through the resource controller's own
-    # permitted_params (compiled from `permit_params`), so we accept exactly what
-    # the admin form accepts. Fails closed if that cannot be resolved.
+    # Resolves the fields we may write, accepting exactly what the admin form
+    # accepts. Prefers the resource's own `permit_params` (via the controller's
+    # compiled permitted_params); when a resource declares its writable fields
+    # through a `form do ... end` block instead — as ActiveAdmin's default
+    # permitted_params then returns nil — derives them from the form inputs.
+    # Fails closed if neither can be resolved.
     def permitted_attributes(config, attributes)
+      from_permit_params(config, attributes) ||
+        from_form(config, attributes) ||
+        raise(PermitError, "Could not determine permitted attributes: #{@resource[:name]}")
+    end
+
+    def from_permit_params(config, attributes)
       param_key = config.param_key.to_sym
       controller = config.controller.new
-
-      unless controller.respond_to?(:permitted_params, true)
-        raise PermitError, "Resource does not declare permit_params: #{@resource[:name]}"
-      end
+      return nil unless controller.respond_to?(:permitted_params, true)
 
       controller.params = ActionController::Parameters.new(param_key => attributes)
-      permitted = controller.send(:permitted_params)[param_key]
-      permitted ? permitted.to_h.symbolize_keys : {}
-    rescue PermitError
-      raise
-    rescue StandardError => e
-      raise PermitError, "Could not determine permitted attributes: #{e.message}"
+      permitted = controller.send(:permitted_params)
+      scoped = permitted && permitted[param_key]
+      scoped ? scoped.to_h.symbolize_keys : nil
+    rescue StandardError
+      nil
+    end
+
+    def from_form(config, attributes)
+      fields = form_fields(config)
+      return nil if fields.empty?
+
+      ActionController::Parameters.new(attributes).permit(*fields).to_h.symbolize_keys
+    rescue StandardError
+      nil
+    end
+
+    def form_fields(config)
+      return [] unless config.respond_to?(:page_presenters)
+
+      block = config.page_presenters[:form]&.block
+      return [] unless block
+
+      FormFieldCollector.new.collect(&block)
     end
 
     def error(message, details: nil)

data/lib/activeadmin_mcp/request_handler.rb

@@ -44,12 +44,15 @@ module ActiveadminMcp
         tools: [
           {
             name: "list_resources",
-            description: "List all ActiveAdmin resources with their attributes",
+            description: "List the ActiveAdmin resources the authenticated user is authorized " \
+                         "to read, with their attributes",
             inputSchema: { type: "object", properties: {} },
           },
           {
             name: "query",
-            description: "Query an ActiveAdmin resource using Ransack syntax",
+            description: "Query an ActiveAdmin resource using Ransack syntax. Respects ActiveAdmin " \
+                         "authorization: the resource must be readable by the authenticated user, " \
+                         "and results are scoped to the records they may access.",
             inputSchema: {
               type: "object",
               properties: {
@@ -93,18 +96,21 @@ module ActiveadminMcp
     end
 
     def tool_list_resources
-      { resources: ResourceRegistry.all }
+      entries = ResourceRegistry.resources.select { |entry| authorized_to_read?(entry) }
+      { resources: entries.map { |entry| ResourceRegistry.resource_info(entry) } }
     end
 
     def tool_query(args)
       resource = ResourceRegistry.find(args["resource"])
       return { error: "Resource not found: #{args['resource']}" } unless resource
+      return { error: "Not authorized to query #{resource[:name]}" } unless authorized_to_read?(resource)
 
       limit = [args["limit"] || 25, 100].min
       q = args["q"] || {}
 
-      records = resource[:model].ransack(q).result.limit(limit)
-      { resource: resource[:name], count: records.size, records: records.as_json }
+      relation = resource[:model].ransack(q).result
+      records = authorization(resource).scope_collection(relation, Authorization::READ).limit(limit)
+      { resource: resource[:name], count: records.size, records: filter_sensitive(records.as_json) }
     end
 
     def tool_update(args)
@@ -119,6 +125,21 @@ module ActiveadminMcp
                    .call(id: args["id"], attributes: attributes)
     end
 
+    def authorized_to_read?(resource)
+      authorization(resource).authorized?(Authorization::READ, resource[:model])
+    end
+
+    def authorization(resource)
+      Authorization.for(resource[:config], @current_user)
+    end
+
+    def filter_sensitive(records)
+      sensitive = ResourceRegistry.sensitive_attributes
+      Array(records).map do |record|
+        record.is_a?(Hash) ? record.except(*sensitive) : record
+      end
+    end
+
     def success(id, result)
       { jsonrpc: "2.0", id: id, result: result }
     end

data/lib/activeadmin_mcp/resource_registry.rb

@@ -4,14 +4,28 @@ module ActiveadminMcp
   module ResourceRegistry
     class << self
       def all
-        discover.map { |r| resource_info(r) }
+        resources.map { |entry| resource_info(entry) }
+      end
+
+      def resources
+        discover.map { |r| entry(r) }
       end
 
       def find(name)
-        resource = discover.find { |r| r.resource_class.name == name }
-        return unless resource
+        resources.find { |entry| entry[:name] == name }
+      end
 
-        { name: resource.resource_class.name, model: resource.resource_class, config: resource }
+      def resource_info(entry)
+        klass = entry[:model]
+        {
+          name: klass.name,
+          table: klass.table_name,
+          attributes: klass.column_names - sensitive_attributes,
+        }
+      end
+
+      def sensitive_attributes
+        %w[encrypted_password password_digest reset_password_token api_key secret]
       end
 
       private
@@ -26,17 +40,8 @@ module ActiveadminMcp
         end || []
       end
 
-      def resource_info(resource)
-        klass = resource.resource_class
-        {
-          name: klass.name,
-          table: klass.table_name,
-          attributes: klass.column_names - sensitive_attributes,
-        }
-      end
-
-      def sensitive_attributes
-        %w[encrypted_password password_digest reset_password_token api_key secret]
+      def entry(resource)
+        { name: resource.resource_class.name, model: resource.resource_class, config: resource }
       end
     end
   end

data/lib/activeadmin_mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveadminMcp
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/activeadmin_mcp.rb

@@ -2,7 +2,9 @@
 
 require_relative "activeadmin_mcp/version"
 require_relative "activeadmin_mcp/configuration"
+require_relative "activeadmin_mcp/authorization"
 require_relative "activeadmin_mcp/resource_registry"
+require_relative "activeadmin_mcp/form_field_collector"
 require_relative "activeadmin_mcp/record_updater"
 require_relative "activeadmin_mcp/request_handler"
 require_relative "activeadmin_mcp/engine"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activeadmin_mcp
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - harunkumars
@@ -95,8 +95,10 @@ files:
 - app/models/activeadmin_mcp/api_token.rb
 - config/routes.rb
 - lib/activeadmin_mcp.rb
+- lib/activeadmin_mcp/authorization.rb
 - lib/activeadmin_mcp/configuration.rb
 - lib/activeadmin_mcp/engine.rb
+- lib/activeadmin_mcp/form_field_collector.rb
 - lib/activeadmin_mcp/record_updater.rb
 - lib/activeadmin_mcp/request_handler.rb
 - lib/activeadmin_mcp/resource_registry.rb