mcp-rails 0.4.11

data/app/controllers/concerns/mcp/rails/tool_descriptions.rb

@@ -0,0 +1,39 @@
+module MCP::Rails::ToolDescriptions
+  extend ActiveSupport::Concern
+
+  def self.included(base)
+    base.extend ClassMethods
+    base.class_eval do
+      # Initialize instance variables for each class
+      @action_descriptions = {}
+
+      # Define class-level accessors
+      def self.action_descriptions
+        @action_descriptions ||= {}
+      end
+
+      # Optionally, define setters if needed
+      def self.action_descriptions=(value)
+        @action_descriptions = value
+      end
+
+      # Ensure subclasses get their own fresh instances
+      def self.inherited(subclass)
+        super
+        subclass.instance_variable_set(:@action_descriptions, {})
+      end
+    end
+  end
+
+  class_methods do
+    # Define description for an action
+    def tool_description_for(action, description)
+      action_descriptions[action.to_sym] = description
+    end
+
+    # Get description for an action
+    def tool_description(action)
+      action_descriptions[action.to_sym]
+    end
+  end
+end

data/lib/mcp/rails/bypass_key_manager.rb

@@ -0,0 +1,34 @@
+require "securerandom"
+
+module MCP
+  module Rails
+    class BypassKeyManager
+      class << self
+        def generate_key
+          SecureRandom.hex(32)
+        end
+
+        def save_key(key = nil)
+          key ||= generate_key
+          config = MCP::Rails.configuration
+          FileUtils.mkdir_p(File.dirname(config.bypass_key_path))
+          File.write(config.bypass_key_path, key)
+          key
+        end
+
+        def load_key
+          return nil unless File.exist?(MCP::Rails.configuration.bypass_key_path)
+          File.read(MCP::Rails.configuration.bypass_key_path).strip
+        end
+
+        def key
+          load_key || save_key
+        end
+
+        def create_new_key
+          save_key(generate_key)
+        end
+      end
+    end
+  end
+end

data/lib/mcp/rails/configuration.rb

@@ -0,0 +1,86 @@
+require "pathname"
+
+module MCP
+  module Rails
+    class Configuration
+      # Server configuration
+      attr_accessor :server_name, :server_version
+
+      # Output configuration
+      attr_writer :output_directory, :bypass_key_path
+
+      # Environment variables to include in tool calls
+      attr_accessor :env_vars
+
+      # Engine configurations
+      attr_reader :engine_configurations
+
+      def initialize
+        # Server defaults
+        @server_name = "mcp-server"
+        @server_version = "1.0.0"
+
+        # Output defaults
+        @output_directory = ::Rails.root.join("tmp", "mcp") if defined?(::Rails)
+        @bypass_key_path = ::Rails.root.join("tmp", "mcp", "bypass_key.txt") if defined?(::Rails)
+
+        # Environment variables to include in tool calls
+        @env_vars = []
+
+        # Initialize engine configurations hash
+        @engine_configurations = {}
+      end
+
+      def base_url
+        return @base_url if defined?(@base_url)
+
+        if defined?(::Rails)
+          mailer_options = ::Rails.application.config.action_mailer.default_url_options || {}
+          host = mailer_options[:host] || "localhost"
+          port = mailer_options[:port] || "3000"
+          protocol = mailer_options[:protocol] || "http"
+          "#{protocol}://#{host}:#{port}"
+        else
+          "http://localhost:3000"
+        end
+      end
+
+      def base_url=(url)
+        @base_url = url
+      end
+
+      def bypass_key_path
+        Pathname.new(@bypass_key_path || ::Rails.root.join("tmp", "mcp", "bypass_key.txt"))
+      end
+
+      def output_directory
+        Pathname.new(@output_directory || ::Rails.root.join("tmp", "mcp"))
+      end
+
+      # Register an engine's configuration
+      def register_engine(engine, settings = {})
+        engine_name = engine.respond_to?(:engine_name) ? engine.engine_name : engine
+        @engine_configurations[engine_name] = EngineConfiguration.new(settings)
+      end
+
+      # Get configuration for a specific engine
+      def for_engine(engine)
+        return self unless engine
+        engine_config = @engine_configurations[engine.engine_name]
+
+        dup.tap do |config|
+          config.server_name = engine.engine_name
+          config.instance_variable_set(:@env_vars, (self.env_vars + engine_config.env_vars).uniq)
+        end
+      end
+    end
+
+    class EngineConfiguration
+      attr_reader :env_vars
+
+      def initialize(settings = {})
+        @env_vars = Array(settings[:env_vars] || [])
+      end
+    end
+  end
+end

data/lib/mcp/rails/railtie.rb

@@ -0,0 +1,49 @@
+module Mcp
+  module Rails
+    class Railtie < ::Rails::Railtie
+      railtie_name "mcp-rails"
+      gem_root = Gem::Specification.find_by_name("mcp-rails").gem_dir
+
+      config.to_prepare do
+        require File.join(gem_root, "app/controllers/concerns/mcp/rails/parameters")
+        require File.join(gem_root, "app/controllers/concerns/mcp/rails/tool_descriptions")
+        require File.join(gem_root, "app/controllers/concerns/mcp/rails/error_handling")
+        require File.join(gem_root, "app/controllers/concerns/mcp/rails/renderer")
+        ActionController::Base.include(MCP::Rails::Parameters)
+        ActionController::Base.include(MCP::Rails::ToolDescriptions)
+        ActionController::Base.include(MCP::Rails::ErrorHandling)
+        ActionController::Base.include(MCP::Rails::Renderer)
+      end
+
+      initializer "mcp-rails.mime_type" do
+        Mime::Type.register "application/vnd.mcp+json", :mcp# , [ "application/json" ]
+      end
+
+      initializer "mcp-rails.renderer" do
+        ActionController::Renderers.add :mcp do |mcp_json, options|
+          self.content_type = Mime[:mcp] if media_type.nil?
+          mcp_json
+        end
+      end
+
+      initializer "mcp-rails.integration_test_request_encoding" do
+        ActiveSupport.on_load(:action_dispatch_integration_test) do
+          # Support `as: :mcp`. Public `register_encoder` API is a little too strict.
+          class ActionDispatch::RequestEncoder
+            class McpEncoder < IdentityEncoder
+              header = [ Mime[:mcp], Mime[:json] ].join(",")
+              define_method(:accept_header) { header }
+            end
+
+            @encoders[:mcp] = McpEncoder.new
+          end
+        end
+      end
+
+      rake_tasks do
+        path = File.expand_path("#{gem_root}/tasks/mcp", __dir__)
+        Dir.glob("#{path}/*.rake").each { |f| load f }
+      end
+    end
+  end
+end

data/lib/mcp/rails/server_generator/route_collector.rb

@@ -0,0 +1,84 @@
+module MCP
+  module Rails
+    class ServerGenerator::RouteCollector
+      def self.collect_routes(routes, prefix = "", engine = nil)
+        routes.map do |route|
+          app = route.app.app
+
+          if app.respond_to?(:routes) && app < ::Rails::Engine
+            new_prefix = [ prefix, route.path.spec.to_s ].join
+            collect_routes(app.app.routes.routes, new_prefix, app)
+          else
+            path = [ prefix, route.path.spec.to_s ].join
+            {
+              route: route,
+              path: path.present? ? path : route.path.spec.to_s,
+              engine: engine
+            }
+          end
+        end.flatten
+      end
+
+      def self.process_routes(routes)
+        candidate_routes = routes.select do |wrapped_route|
+          route = wrapped_route[:route]
+          action = route.defaults[:action]&.to_s
+          mcp = route.defaults[:mcp]
+          mcp == true || (mcp.is_a?(Array) && action&.in?(mcp.map(&:to_s)))
+        end
+
+        candidate_routes.map do |wrapped_route|
+          route = wrapped_route[:route]
+          next unless route.defaults[:controller] && route.defaults[:action]
+          next unless route.defaults[:action].to_s.in?(%w[create index show update destroy])
+          next if route.verb.downcase == "put"
+
+          begin
+            controller_class = "#{route.defaults[:controller].camelize}Controller".constantize
+            action = route.defaults[:action].to_sym
+            params_def = controller_class.permitted_params(action)
+          rescue NameError
+            ::Rails.logger.warn("Controller not found for route: #{route.defaults[:controller]}")
+            next
+          end
+
+          full_path = (wrapped_route[:path] || route.path.spec.to_s).sub(/\(\.:format\)$/, "") || ""
+          url_params = extract_url_params(full_path)
+          params_def += url_params unless params_def.any? { |p| url_params.map { |up| up[:name] }.include?(p[:name]) }
+
+          description = controller_class.tool_description(action) || "Handles #{action} for #{route.defaults[:controller]}"
+
+          {
+            tool_name: "#{action}_#{route.defaults[:controller].parameterize}",
+            description: escape_for_ruby_string(description),
+            method: route.verb.downcase.to_sym,
+            path: full_path,
+            url_parameters: url_params,
+            engine: wrapped_route[:engine],
+            accepted_parameters: params_def.map { |param| build_param_structure(param) }
+          }
+        end.compact
+      end
+
+      def self.build_param_structure(param)
+        structure = {
+          name: param[:name],
+          type: param[:type] || :string,
+          required: param[:required]
+        }
+        structure[:item_type] = param[:item_type] if param[:item_type]  # Add item_type for scalar arrays
+        structure[:description] = escape_for_ruby_string(param[:example]) if param[:example]
+        structure[:nested] = param[:nested].map { |n| build_param_structure(n) } if param[:nested]
+        structure
+      end
+
+      def self.escape_for_ruby_string(str)
+        str.to_s.gsub(/[\\"]/) { |m| "\\#{m}" }
+      end
+
+      def self.extract_url_params(path)
+        path.scan(/:([a-zA-Z0-9_]+)/).flatten.map { |name| { name: name, type: "string", required: true } }
+      end
+    end
+  end
+end

data/lib/mcp/rails/server_generator/server_writer.rb

@@ -0,0 +1,242 @@
+module MCP
+  module Rails
+    class ServerGenerator::ServerWriter
+      def self.write_server(routes_data, config, base_url, bypass_csrf_key, engine = nil)
+        # Get engine-specific configuration if available
+        config = config.for_engine(engine)
+
+        file_name = engine ? "#{config.server_name}_server.rb" : "server.rb"
+        file_path = File.join(config.output_directory.to_s, file_name)
+        FileUtils.mkdir_p(File.dirname(file_path))
+
+        File.open(file_path, "w") do |file|
+          file.puts ruby_invocation
+          file.puts
+          file.puts %(require "mcp")
+          file.puts %(require "httparty")
+          file.puts
+          file.puts helper_methods(base_url, bypass_csrf_key)
+          file.puts
+
+          file.puts %(name "#{config.server_name}")
+          file.puts %(version "#{config.server_version}")
+
+          routes_data.each do |route|
+            file.puts %(tool "#{route[:tool_name].underscore}" do)
+            file.puts "  description \"#{route[:description].sub(/\//, ' ')}\""
+            route[:accepted_parameters].each do |param|
+              file.puts generate_parameter(param)
+            end
+            file.puts route_block(route, config).lines.map { |line| "  #{line}" }.join
+            file.puts "end"
+            file.puts
+          end
+        end
+
+        current_mode = File.stat(file_path).mode
+        new_mode = current_mode | 0111  # Add execute (u+x, g+x, o+x)
+        File.chmod(new_mode, file_path)
+
+        file_path
+      end
+
+      def self.type_to_class(type)
+        case type
+        when :string then "String"
+        when :integer then "Integer"
+        when :number then "Float"
+        when :boolean then "TrueClass"
+        when :array then "Array"
+        else "String"  # Default to String
+        end
+      end
+
+      def self.generate_parameter(param, indent_level = 1)
+        indent = "  " * indent_level
+        name = param[:name].to_sym
+        required = param[:required] ? ", required: true" : ""
+        description = param[:description] ? ", description: \"#{param[:description]}\"" : ""
+
+        if param[:type] == :array
+          if param[:item_type]
+            # Scalar array: argument :name, Array, items: Type
+            type_str = "Array, items: #{type_to_class(param[:item_type])}"
+            "#{indent}argument :#{name}, #{type_str}#{required}#{description}"
+          elsif param[:nested]
+            # Array of objects: argument :name, Array do ... end
+            nested_params = param[:nested].map { |np| generate_parameter(np, indent_level + 1) }.join("\n")
+            "#{indent}argument :#{name}, Array#{required}#{description} do\n#{nested_params}\n#{indent}end"
+          else
+            raise "Array parameter must have either item_type or nested parameters"
+          end
+        elsif param[:type] == :object && param[:nested]
+          # Object: argument :name do ... end
+          nested_params = param[:nested].map { |np| generate_parameter(np, indent_level + 1) }.join("\n")
+          "#{indent}argument :#{name}#{required}#{description} do\n#{nested_params}\n#{indent}end"
+        else
+          # Scalar type: argument :name, Type
+          type_str = type_to_class(param[:type])
+          "#{indent}argument :#{name}, #{type_str}#{required}#{description}"
+        end
+      end
+
+      def self.ruby_invocation
+        <<~RUBY
+          #!/usr/bin/env ruby
+
+          # Find the nearest Gemfile by walking up the directory tree
+          def find_nearest_gemfile(start_dir)
+            current_dir = File.expand_path(start_dir)
+            loop do
+              gemfile = File.join(current_dir, "Gemfile")
+              return gemfile if File.exist?(gemfile)
+              parent_dir = File.dirname(current_dir)
+              break if parent_dir == current_dir # Reached root (e.g., "/")
+              current_dir = parent_dir
+            end
+            nil # No Gemfile found
+          end
+
+          # If not already running under bundle exec, re-execute with the nearest Gemfile
+          unless ENV["BUNDLE_GEMFILE"] # Check if already running under Bundler
+            gemfile = find_nearest_gemfile(__dir__) # __dir__ is the script's directory
+            if gemfile
+              ENV["BUNDLE_GEMFILE"] = gemfile
+              exec("bundle", "exec", "ruby", __FILE__, *ARGV) # Re-run with bundle exec
+            else
+              warn "Warning: No Gemfile found in any parent directory."
+            end
+          end
+        RUBY
+      end
+
+      def self.helper_methods(base_uri, bypass_csrf_key)
+        return test_helper_methods(base_uri, bypass_csrf_key) if ::Rails.env.test?
+        <<~RUBY
+          def transform_args(args)
+            if args.is_a?(Hash)
+              args.transform_keys { |key| key.to_s.gsub(/([a-z])([A-Z])/, '\\1_\\2').gsub(/([A-Z])([A-Z][a-z])/, '\\1_\\2').downcase }
+                .transform_values { |value| transform_args(value) }
+            else
+              args # Return non-hash values (e.g., strings, integers) unchanged
+            end
+          end
+
+          def parse_response(response)
+            response_body = JSON.parse(response.body)
+            case response_body
+            when Hash
+              if response_body["status"] == "error"
+                raise "From Rails Server: \#{response_body["message"]}"
+              else
+                response_body.dig("data").to_json
+              end
+            else
+              raise "None MCP response from Rails Server"
+            end
+          rescue => e
+            raise "Parsing JSON failed: \#{e.message}"
+          end
+
+          def get_resource(uri, arguments = {})
+            response = HTTParty.get("#{base_uri}\#{uri}", query: transform_args(arguments), headers: { "Accept" => "application/vnd.mcp+json, application/json" })
+            parse_response(response)
+          end
+
+          def post_resource(uri, payload = {})
+            headers = { "Accept" => "application/vnd.mcp+json, application/json" }
+            headers["X-Bypass-CSRF"] = "#{bypass_csrf_key}"
+            response = HTTParty.post("#{base_uri}\#{uri}", body: transform_args(payload), headers: headers)
+            parse_response(response)
+          end
+
+          def patch_resource(uri, payload = {})
+            headers = { "Accept" => "application/vnd.mcp+json, application/json" }
+            headers["X-Bypass-CSRF"] = "#{bypass_csrf_key}"
+            response = HTTParty.patch("#{base_uri}\#{uri}", body: transform_args(payload), headers: headers)
+            parse_response(response)
+          end
+
+          def delete_resource(uri, payload = {})
+            headers = { "Accept" => "application/vnd.mcp+json, application/json" }
+            headers["X-Bypass-CSRF"] = "#{bypass_csrf_key}"
+            response = HTTParty.delete("#{base_uri}\#{uri}", body: transform_args(payload), headers: headers)
+            parse_response(response)
+          end
+        RUBY
+      end
+
+      def self.route_block(route, config)
+        uri = route[:path]
+        route[:url_parameters].each do |url_parameter|
+          uri = uri.gsub(":#{url_parameter[:name]}", "\#{args[:#{url_parameter[:name]}]}")
+        end
+
+        env_vars = config.env_vars.map do |var|
+          "args[:#{var.downcase}] = ENV['#{var}']"
+        end.join("\n")
+
+        method = route[:method].to_s.downcase
+        helper_method = "#{method}_resource"
+
+        <<~RUBY
+          call do |args|
+            #{env_vars}
+            #{helper_method}("#{uri}", args)
+          end
+        RUBY
+      end
+
+      def self.test_helper_methods(base_uri, bypass_csrf_key)
+        <<~RUBY
+          def parse_response(test_context)
+            # Would be url: #{base_uri}
+            parsed_body = JSON.parse(test_context.response.body)
+            case parsed_body
+            when Hash
+              if parsed_body["status"] == "error"
+                raise "From Rails Server: \#{parsed_body["message"]}"
+              else
+                parsed_body.dig("data")
+              end
+            else
+              raise "None MCP response from Rails Server"
+            end
+          rescue => e
+            raise "Parsing JSON failed: \#{e.message}"
+          end
+
+          def get_resource(uri, arguments = {})
+            test_context = arguments.delete(:test_context)
+            test_context.get uri, params: arguments, headers: { "Accept" => "application/vnd.mcp+json, application/json" }, as: :mcp
+            parse_response(test_context)
+          end
+
+          def post_resource(uri, payload = {}, headers = {})
+            test_context = payload.delete(:test_context)
+            headers = { "Accept" => "application/vnd.mcp+json, application/json" }
+            headers["X-Bypass-CSRF"] = "#{bypass_csrf_key}"
+            test_context.post uri, params: payload, headers: headers, as: :mcp
+            parse_response(test_context)
+          end
+
+          def patch_resource(uri, payload = {})
+            test_context = payload.delete(:test_context)
+            headers = { "Accept" => "application/vnd.mcp+json, application/json" }
+            headers["X-Bypass-CSRF"] = "#{bypass_csrf_key}"
+            test_context.patch uri, params: payload.merge(headers: headers), as: :mcp
+            parse_response(test_context)
+          end
+
+          def delete_resource(uri, payload = {})
+            test_context = payload.delete(:test_context)
+            headers = { "Accept" => "application/vnd.mcp+json, application/json" }
+            headers["X-Bypass-CSRF"] = "#{bypass_csrf_key}"
+            test_context.delete uri, params: payload.merge(headers: headers), as: :mcp
+            parse_response(test_context)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/mcp/rails/server_generator.rb

@@ -0,0 +1,49 @@
+module MCP
+  module Rails
+    class ServerGenerator
+      class << self
+        def generate_files(config = MCP::Rails.configuration)
+          base_url = config.base_url
+          bypass_csrf_key = BypassKeyManager.create_new_key
+
+          all_routes = RouteCollector.collect_routes(::Rails.application.routes.routes).flatten
+          grouped_routes = all_routes.group_by { |r| r[:engine] }
+
+          generated_files = []
+
+          # Process main app routes
+          main_app_routes = RouteCollector.process_routes(grouped_routes[nil] || [])
+          if main_app_routes.any?
+            file_path = ServerWriter.write_server(
+              main_app_routes,
+              config.for_engine(nil),
+              base_url,
+              bypass_csrf_key
+            )
+            generated_files << file_path
+          end
+
+          # Process each engine's routes
+          grouped_routes.each do |engine, routes|
+            next unless engine
+
+            engine_routes = RouteCollector.process_routes(routes)
+            next unless engine_routes.any?
+
+            engine_config = config.for_engine(engine)
+            file_path = ServerWriter.write_server(
+              engine_routes,
+              engine_config,
+              base_url,
+              bypass_csrf_key,
+              engine
+            )
+            generated_files << file_path
+          end
+
+          generated_files
+        end
+      end
+    end
+  end
+end

data/lib/mcp/rails/version.rb

@@ -0,0 +1,5 @@
+module Mcp
+  module Rails
+    VERSION = "0.4.11"
+  end
+end

data/lib/mcp/rails.rb

@@ -0,0 +1,31 @@
+require "mcp/rails/version"
+require "mcp/rails/railtie"
+require "mcp/rails/configuration"
+require "mcp/rails/server_generator"
+require "mcp/rails/bypass_key_manager"
+require "mcp/rails/server_generator/server_writer"
+require "mcp/rails/server_generator/route_collector"
+require_relative "../../test/support/mcp/rails/test_helper"
+
+module MCP
+  module Rails
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+
+      def configuration=(configuration)
+        raise ArgumentError, "configuration must be an instance of MCP::Rails::Configuration" unless configuration.is_a?(Configuration)
+        @configuration = configuration
+      end
+    end
+  end
+end