rails-active-mcp 0.1.1

data/lib/rails_active_mcp/mcp_server.rb

@@ -0,0 +1,374 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rack'
+
+module RailsActiveMcp
+  class McpServer
+    JSONRPC_VERSION = '2.0'
+    MCP_VERSION = '2025-06-18'
+
+    def initialize(app = nil)
+      @app = app
+      @tools = {}
+      @resources = {}
+      register_default_tools
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      return [405, {}, ['Method Not Allowed']] unless request.post?
+      return [400, {}, ['Invalid Content-Type']] unless json_request?(request)
+
+      begin
+        body = request.body.read
+        data = JSON.parse(body)
+        response = handle_jsonrpc_request(data)
+
+        [200, {'Content-Type' => 'application/json'}, [response.to_json]]
+      rescue JSON::ParserError
+        error_response(400, 'Invalid JSON')
+      rescue => e
+        Rails.logger.error "MCP Server Error: #{e.message}" if defined?(Rails)
+        error_response(500, 'Internal Server Error')
+      end
+    end
+
+    private
+
+    def json_request?(request)
+      request.content_type&.include?('application/json')
+    end
+
+    def handle_jsonrpc_request(data)
+      case data['method']
+      when 'initialize'
+        handle_initialize(data)
+      when 'tools/list'
+        handle_tools_list(data)
+      when 'tools/call'
+        handle_tools_call(data)
+      when 'resources/list'
+        handle_resources_list(data)
+      when 'resources/read'
+        handle_resources_read(data)
+      else
+        jsonrpc_error(data['id'], -32601, 'Method not found')
+      end
+    end
+
+    def handle_initialize(data)
+      {
+        jsonrpc: JSONRPC_VERSION,
+        id: data['id'],
+        result: {
+          protocolVersion: MCP_VERSION,
+          capabilities: {
+            tools: {
+              list: true,
+              call: true
+            },
+            resources: {
+              read: true,
+              list: true
+            }
+          },
+          serverInfo: {
+            name: 'rails-active-mcp',
+            version: RailsActiveMcp::VERSION
+          }
+        }
+      }
+    end
+
+    def handle_tools_list(data)
+      tools_array = @tools.values.map do |tool|
+        tool_def = {
+          name: tool[:name],
+          description: tool[:description],
+          inputSchema: tool[:input_schema]
+        }
+
+        # Add annotations if present
+        if tool[:annotations] && !tool[:annotations].empty?
+          tool_def[:annotations] = tool[:annotations]
+        end
+
+        tool_def
+      end
+
+      {
+        jsonrpc: JSONRPC_VERSION,
+        id: data['id'],
+        result: { tools: tools_array }
+      }
+    end
+
+    def handle_tools_call(data)
+      tool_name = data.dig('params', 'name')
+      arguments = data.dig('params', 'arguments') || {}
+
+      tool = @tools[tool_name]
+      return jsonrpc_error(data['id'], -32602, "Tool '#{tool_name}' not found") unless tool
+
+      begin
+        result = tool[:handler].call(arguments)
+        {
+          jsonrpc: JSONRPC_VERSION,
+          id: data['id'],
+          result: { content: [{ type: 'text', text: result.to_s }] }
+        }
+      rescue => e
+        jsonrpc_error(data['id'], -32603, "Tool execution failed: #{e.message}")
+      end
+    end
+
+    def handle_resources_list(data)
+      {
+        jsonrpc: JSONRPC_VERSION,
+        id: data['id'],
+        result: { resources: [] }
+      }
+    end
+
+    def handle_resources_read(data)
+      {
+        jsonrpc: JSONRPC_VERSION,
+        id: data['id'],
+        result: { contents: [] }
+      }
+    end
+
+    def register_tool(name, description, input_schema, annotations = {}, &handler)
+      @tools[name] = {
+        name: name,
+        description: description,
+        input_schema: input_schema,
+        annotations: annotations,
+        handler: handler
+      }
+    end
+
+    def register_default_tools
+      register_tool(
+        'rails_console_execute',
+        'Execute Ruby code in Rails console context',
+        {
+          type: 'object',
+          properties: {
+            code: { type: 'string', description: 'Ruby code to execute' },
+            timeout: { type: 'number', description: 'Timeout in seconds', default: 30 },
+            safe_mode: { type: 'boolean', description: 'Enable safety checks', default: true },
+            capture_output: { type: 'boolean', description: 'Capture console output', default: true }
+          },
+          required: ['code']
+        },
+        # Add MCP tool annotations
+        {
+          title: 'Rails Console Executor',
+          readOnlyHint: false,
+          destructiveHint: true,
+          idempotentHint: false,
+          openWorldHint: false
+        }
+      ) do |args|
+        execute_console_code(args)
+      end
+
+      register_tool(
+        'rails_model_info',
+        'Get information about Rails models',
+        {
+          type: 'object',
+          properties: {
+            model_name: { type: 'string', description: 'Name of the model to inspect' }
+          },
+          required: ['model_name']
+        },
+        # Safe read-only tool
+        {
+          title: 'Rails Model Inspector',
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        }
+      ) do |args|
+        get_model_info(args['model_name'])
+      end
+
+      register_tool(
+        'rails_safe_query',
+        'Execute safe read-only database queries',
+        {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'Safe query to execute' },
+            model: { type: 'string', description: 'Model class name' }
+          },
+          required: ['query', 'model']
+        },
+        # Safe read-only query tool
+        {
+          title: 'Rails Safe Query Executor',
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        }
+      ) do |args|
+        execute_safe_query(args)
+      end
+
+      register_tool(
+        'rails_dry_run',
+        'Analyze Ruby code safety without execution',
+        {
+          type: 'object',
+          properties: {
+            code: { type: 'string', description: 'Ruby code to analyze' }
+          },
+          required: ['code']
+        },
+        {
+          title: 'Rails Code Safety Analyzer',
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        }
+      ) do |args|
+        dry_run_analysis(args['code'])
+      end
+    end
+
+    def execute_console_code(args)
+      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+
+      executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
+
+      begin
+        result = executor.execute(
+          args['code'],
+          timeout: args['timeout'] || 30,
+          safe_mode: args['safe_mode'] != false,
+          capture_output: args['capture_output'] != false
+        )
+
+        if result[:success]
+          format_success_result(result)
+        else
+          "Error: #{result[:error]} (#{result[:error_class]})"
+        end
+      rescue RailsActiveMcp::SafetyError => e
+        "Safety check failed: #{e.message}"
+      rescue RailsActiveMcp::TimeoutError => e
+        "Execution timed out: #{e.message}"
+      rescue => e
+        "Execution failed: #{e.message}"
+      end
+    end
+
+    def get_model_info(model_name)
+      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+
+      begin
+        model_class = model_name.constantize
+        return "#{model_name} is not an ActiveRecord model" unless model_class < ActiveRecord::Base
+
+        info = []
+        info << "Model: #{model_class.name}"
+        info << "Table: #{model_class.table_name}"
+        info << "Columns: #{model_class.column_names.join(', ')}"
+        info << "Associations: #{model_class.reflect_on_all_associations.map(&:name).join(', ')}"
+        info.join("\n")
+      rescue NameError
+        "Model '#{model_name}' not found"
+      rescue => e
+        "Error getting model info: #{e.message}"
+      end
+    end
+
+    def execute_safe_query(args)
+      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+
+      begin
+        model_class = args['model'].constantize
+        return "#{args['model']} is not an ActiveRecord model" unless model_class < ActiveRecord::Base
+
+        # Only allow safe read-only methods
+        safe_methods = %w[find find_by where select count sum average maximum minimum first last pluck ids exists? empty? any? many? include?]
+        query_method = args['query'].split('.').first
+
+        return "Unsafe query method: #{query_method}" unless safe_methods.include?(query_method)
+
+        result = model_class.instance_eval(args['query'])
+        result.to_s
+      rescue NameError
+        "Model '#{args['model']}' not found"
+      rescue => e
+        "Error executing query: #{e.message}"
+      end
+    end
+
+    def dry_run_analysis(code)
+      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+
+      executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
+
+      begin
+        analysis = executor.dry_run(code)
+
+        output = []
+        output << "Code: #{analysis[:code]}"
+        output << "Safe: #{analysis[:safety_analysis][:safe] ? 'Yes' : 'No'}"
+        output << "Read-only: #{analysis[:safety_analysis][:read_only] ? 'Yes' : 'No'}"
+        output << "Risk level: #{analysis[:estimated_risk]}"
+        output << "Would execute: #{analysis[:would_execute] ? 'Yes' : 'No'}"
+        output << "Summary: #{analysis[:safety_analysis][:summary]}"
+
+        if analysis[:safety_analysis][:violations].any?
+          output << "\nViolations:"
+          analysis[:safety_analysis][:violations].each do |violation|
+            output << "  - #{violation[:description]} (#{violation[:severity]})"
+          end
+        end
+
+        if analysis[:recommendations].any?
+          output << "\nRecommendations:"
+          analysis[:recommendations].each do |rec|
+            output << "  - #{rec}"
+          end
+        end
+
+        output.join("\n")
+      rescue => e
+        "Analysis failed: #{e.message}"
+      end
+    end
+
+    def format_success_result(result)
+      output = []
+      output << "Code: #{result[:code]}"
+      output << "Result: #{result[:return_value_string] || result[:return_value]}"
+      output << "Output: #{result[:output]}" if result[:output].present?
+      output << "Execution time: #{result[:execution_time]}s" if result[:execution_time]
+      output << "Note: #{result[:note]}" if result[:note]
+      output.join("\n")
+    end
+
+    def jsonrpc_error(id, code, message)
+      {
+        jsonrpc: JSONRPC_VERSION,
+        id: id,
+        error: { code: code, message: message }
+      }
+    end
+
+    def error_response(status, message)
+      [status, {'Content-Type' => 'application/json'}, 
+       [{ error: message }.to_json]]
+    end
+  end
+end

data/lib/rails_active_mcp/railtie.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RailsActiveMcp
+  class Railtie < ::Rails::Railtie
+    railtie_name :rails_active_mcp
+
+    # Ensure configuration is available very early
+    config.before_initialize do
+      RailsActiveMcp.configure unless RailsActiveMcp.configuration
+    end
+
+    # Add rake tasks
+    rake_tasks do
+      load 'rails_active_mcp/tasks.rake'
+    end
+
+    # Add generators
+    generators do
+      # Generators are auto-discovered from lib/generators following Rails conventions
+    end
+
+    # Console hook for easier access
+    console do
+      # Add convenience methods to console
+      Rails::ConsoleMethods.include(RailsActiveMcp::ConsoleMethods) if defined?(Rails::ConsoleMethods)
+    end
+
+    # Configure logging
+    initializer 'rails_active_mcp.logger' do
+      RailsActiveMcp.logger = Rails.logger if defined?(Rails.logger)
+    end
+  end
+
+  # Console convenience methods
+  module ConsoleMethods
+    def mcp_execute(code, **options)
+      RailsActiveMcp.execute(code, **options)
+    end
+
+    def mcp_safe?(code)
+      RailsActiveMcp.safe?(code)
+    end
+
+    def mcp_config
+      RailsActiveMcp.config
+    end
+  end
+end

data/lib/rails_active_mcp/safety_checker.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RailsActiveMcp
+  class SafetyChecker
+    DANGEROUS_PATTERNS = [
+      { pattern: /\.delete_all\b/, description: 'Mass deletion of records', severity: :high },
+      { pattern: /\.destroy_all\b/, description: 'Mass destruction of records', severity: :high },
+      { pattern: /\.drop\b/, description: 'Database table dropping', severity: :critical },
+      { pattern: /system\s*\(/, description: 'System command execution', severity: :critical },
+      { pattern: /Kernel\.system\s*\(/, description: 'Kernel system command execution', severity: :critical },
+      { pattern: /exec\s*\(/, description: 'Process execution', severity: :critical },
+      { pattern: /`[^`]*`/, description: 'Shell command execution', severity: :critical },
+      { pattern: /File\.delete/, description: 'File deletion', severity: :high },
+      { pattern: /FileUtils\./, description: 'File system operations', severity: :high },
+      { pattern: /Dir\.delete/, description: 'Directory deletion', severity: :high },
+      { pattern: /ActiveRecord::Base\.connection\.execute/, description: 'Raw SQL execution', severity: :medium },
+      { pattern: /\.update_all\(/, description: 'Mass update without callbacks', severity: :medium },
+      { pattern: /eval\s*\(/, description: 'Dynamic code evaluation', severity: :high },
+      { pattern: /send\s*\(/, description: 'Dynamic method calling', severity: :medium },
+      { pattern: /const_set/, description: 'Dynamic constant definition', severity: :medium },
+      { pattern: /remove_const/, description: 'Constant removal', severity: :high },
+      { pattern: /undef_method/, description: 'Method removal', severity: :high },
+      { pattern: /alias_method/, description: 'Method aliasing', severity: :medium },
+      { pattern: /load\s*\(/, description: 'Code loading', severity: :medium },
+      { pattern: /require\s*\(/, description: 'Library requiring', severity: :low },
+      { pattern: /exit/, description: 'Process termination', severity: :high },
+      { pattern: /abort/, description: 'Process abortion', severity: :high },
+      { pattern: /fork/, description: 'Process forking', severity: :high },
+      { pattern: /Thread\.new/, description: 'Thread creation', severity: :medium },
+      { pattern: /\$LOAD_PATH/, description: 'Load path manipulation', severity: :medium },
+      { pattern: /ENV\[/, description: 'Environment variable access', severity: :low },
+      { pattern: /Rails\.env\s*=/, description: 'Environment changing', severity: :high },
+      { pattern: /Rails\.application\.secrets/, description: 'Secrets access', severity: :medium }
+    ].freeze
+
+    READ_ONLY_PATTERNS = [
+      /\.(find|find_by|find_each|find_in_batches)\b/,
+      /\.(where|all|first|last|take)\b/,
+      /\.(count|sum|average|maximum|minimum|size|length)\b/,
+      /\.(pluck|ids|exists\?|empty\?|any\?|many\?)\b/,
+      /\.(select|distinct|group|order|limit|offset)\b/,
+      /\.(includes|joins|left_joins|preload|eager_load)\b/,
+      /\.(to_a|to_sql|explain|inspect|as_json|to_json)\b/,
+      /\.(attributes|attribute_names|column_names)\b/,
+      /\.model_name\b/,
+      /\.table_name\b/,
+      /\.primary_key\b/,
+      /\.connection\.schema_cache/,
+      /Rails\.(env|root|application\.class|version)/
+    ].freeze
+
+    def initialize(config)
+      @config = config
+    end
+
+    def safe?(code)
+
+      analysis = analyze(code)
+      analysis[:safe]
+    end
+
+    def analyze(code)
+      violations = []
+
+      # Check against dangerous patterns
+      dangerous_patterns.each do |pattern_info|
+        violations << pattern_info if code.match?(pattern_info[:pattern])
+      end
+
+      # Check custom patterns
+      @config.custom_safety_patterns.each do |custom_pattern|
+        next unless code.match?(custom_pattern[:pattern])
+
+        violations << {
+          pattern: custom_pattern[:pattern],
+          description: custom_pattern[:description] || 'Custom safety rule',
+          severity: :custom
+        }
+      end
+
+      # Determine if code is read-only
+      read_only = read_only?(code)
+
+      # Calculate safety
+      critical_violations = violations.select { |v| v[:severity] == :critical }
+      high_violations = violations.select { |v| v[:severity] == :high }
+
+      safe = (@config.safe_mode && read_only && critical_violations.empty? && high_violations.empty?) ||
+             (!@config.safe_mode && critical_violations.empty?)
+
+      {
+        safe: safe,
+        read_only: read_only,
+        violations: violations,
+        summary: generate_summary(violations, read_only)
+      }
+    end
+
+    def read_only?(code)
+      # Must contain at least one read-only pattern
+      has_read_only = READ_ONLY_PATTERNS.any? { |pattern| code.match?(pattern) }
+
+      # Must not contain any obvious mutation patterns
+      mutation_patterns = [
+        /\.(save|create|update|delete|destroy)\b/,
+        /\.(save!|create!|update!|delete!|destroy!)\b/,
+        /\.reload\b/,
+        /\.transaction\b/,
+        /=\s*[^=]/ # Assignment (basic check)
+      ]
+
+      has_mutations = mutation_patterns.any? { |pattern| code.match?(pattern) }
+
+      has_read_only && !has_mutations
+    end
+
+    private
+
+    def dangerous_patterns
+      base_patterns = DANGEROUS_PATTERNS.dup
+
+      # Add custom patterns from config
+      @config.custom_safety_patterns.each do |custom|
+        base_patterns << {
+          pattern: custom[:pattern],
+          description: custom[:description] || 'Custom rule',
+          severity: :custom
+        }
+      end
+
+      base_patterns
+    end
+
+    def generate_summary(violations, read_only)
+      if violations.empty?
+        read_only ? 'Code appears safe and read-only' : 'Code appears safe'
+      else
+        severity_counts = violations.group_by { |v| v[:severity] }.transform_values(&:count)
+        parts = []
+
+        severity_counts.each do |severity, count|
+          parts << "#{count} #{severity} violation#{'s' if count > 1}"
+        end
+
+        "Found #{parts.join(', ')}"
+      end
+    end
+  end
+end