rails-active-mcp 0.1.1

data/lib/rails_active_mcp/tasks.rake

@@ -0,0 +1,154 @@
+namespace :rails_active_mcp do
+  desc "Check the safety of Ruby code"
+  task :check_safety, [:code] => :environment do |task, args|
+    code = args[:code]
+
+    if code.blank?
+      puts "Usage: rails rails_active_mcp:check_safety['User.count']"
+      exit 1
+    end
+
+    safety_checker = RailsActiveMcp::SafetyChecker.new(RailsActiveMcp.config)
+    analysis = safety_checker.analyze(code)
+
+    puts "Code: #{code}"
+    puts "Safe: #{analysis[:safe] ? 'Yes' : 'No'}"
+    puts "Read-only: #{analysis[:read_only] ? 'Yes' : 'No'}"
+    puts "Summary: #{analysis[:summary]}"
+
+    if analysis[:violations].any?
+      puts "\nViolations:"
+      analysis[:violations].each do |violation|
+        puts "  - #{violation[:description]} (#{violation[:severity]})"
+      end
+    end
+  end
+
+  desc "Execute Ruby code with safety checks"
+  task :execute, [:code] => :environment do |task, args|
+    code = args[:code]
+
+    if code.blank?
+      puts "Usage: rails rails_active_mcp:execute['User.count']"
+      exit 1
+    end
+
+    begin
+      result = RailsActiveMcp.execute(code)
+
+      if result[:success]
+        puts "Result: #{result[:return_value_string] || result[:return_value]}"
+        puts "Output: #{result[:output]}" if result[:output].present?
+        puts "Execution time: #{result[:execution_time]}s" if result[:execution_time]
+      else
+        puts "Error: #{result[:error]}"
+        puts "Error class: #{result[:error_class]}" if result[:error_class]
+      end
+    rescue => e
+      puts "Failed to execute: #{e.message}"
+      exit 1
+    end
+  end
+
+  desc "Test MCP tools"
+  task :test_tools => :environment do
+    puts "Testing Rails Active MCP tools..."
+
+    # Test SafeQueryTool
+    puts "\n1. Testing SafeQueryTool..."
+    if defined?(User)
+      tool = RailsActiveMcp::Tools::SafeQueryTool.new
+      result = tool.call(model: "User", method: "count")
+      puts "  User.count: #{result[:success] ? result[:result] : result[:error]}"
+    else
+      puts "  Skipped (User model not found)"
+    end
+
+    # Test ConsoleExecuteTool
+    puts "\n2. Testing ConsoleExecuteTool..."
+    tool = RailsActiveMcp::Tools::ConsoleExecuteTool.new
+    result = tool.call(code: "1 + 1")
+    puts "  1 + 1: #{result[:success] ? result[:return_value] : result[:error]}"
+
+    # Test DryRunTool
+    puts "\n3. Testing DryRunTool..."
+    tool = RailsActiveMcp::Tools::DryRunTool.new
+    result = tool.call(code: "User.delete_all")
+    puts "  User.delete_all analysis: #{result[:estimated_risk]} risk"
+
+    puts "\nAll tools tested!"
+  end
+
+  desc "Show configuration"
+  task :config => :environment do
+    config = RailsActiveMcp.config
+
+    puts "Rails Active MCP Configuration:"
+    puts "  Enabled: #{config.enabled}"
+    puts "  Safe mode: #{config.safe_mode}"
+    puts "  Default timeout: #{config.default_timeout}s"
+    puts "  Max results: #{config.max_results}"
+    puts "  Log executions: #{config.log_executions}"
+    puts "  Audit file: #{config.audit_file}"
+    puts "  Enable mutation tools: #{config.enable_mutation_tools}"
+    puts "  Execution environment: #{config.execution_environment}"
+
+    if config.allowed_models.any?
+      puts "  Allowed models: #{config.allowed_models.join(', ')}"
+    end
+
+    if config.blocked_models.any?
+      puts "  Blocked models: #{config.blocked_models.join(', ')}"
+    end
+
+    if config.custom_safety_patterns.any?
+      puts "  Custom safety patterns: #{config.custom_safety_patterns.size}"
+    end
+  end
+
+  desc "View audit log"
+  task :audit_log, [:lines] => :environment do |task, args|
+    lines = args[:lines]&.to_i || 10
+    audit_file = RailsActiveMcp.config.audit_file
+
+    unless File.exist?(audit_file)
+      puts "Audit log not found at: #{audit_file}"
+      exit 1
+    end
+
+    puts "Last #{lines} entries from audit log:"
+    puts "=" * 50
+
+    File.readlines(audit_file).last(lines).each do |line|
+      begin
+        entry = JSON.parse(line)
+        timestamp = entry['timestamp']
+        code = entry['code']
+        user = entry.dig('user', 'email') || entry.dig('user', 'environment') || 'unknown'
+
+        puts "#{timestamp} [#{user}]: #{code}"
+
+        if entry['type'] == 'error'
+          puts "  ERROR: #{entry['error']}"
+        elsif entry['safety_check'] && !entry['safety_check']['safe']
+          puts "  SAFETY: #{entry['safety_check']['summary']}"
+        end
+        puts
+      rescue JSON::ParserError
+        puts "Invalid JSON entry: #{line}"
+      end
+    end
+  end
+
+  desc "Clear audit log"
+  task :clear_audit_log => :environment do
+    audit_file = RailsActiveMcp.config.audit_file
+
+    if File.exist?(audit_file)
+      File.truncate(audit_file, 0)
+      puts "Audit log cleared: #{audit_file}"
+    else
+      puts "Audit log not found: #{audit_file}"
+    end
+  end
+end

data/lib/rails_active_mcp/tools/console_execute_tool.rb

@@ -0,0 +1,61 @@
+module RailsActiveMcp
+  module Tools
+    class ConsoleExecuteTool < ApplicationMCPTool
+      tool_name "console_execute"
+      description "Execute Ruby code in Rails console with safety checks"
+
+      property :code, type: "string", description: 'Ruby code to execute in Rails console', required: true
+      property :safe_mode, type: "boolean", description: 'Enable safety checks (default: true)', required: false
+      property :timeout, type: "integer", description: 'Timeout in seconds (default: 30)', required: false
+      property :capture_output, type: "boolean", description: 'Capture console output (default: true)', required: false
+
+      def perform
+        code = properties[:code]
+        safe_mode = properties[:safe_mode]
+        timeout = properties[:timeout]
+        capture_output = properties.fetch(:capture_output, true)
+
+        return render(error: "Rails Active MCP is disabled") unless RailsActiveMcp.config.enabled
+
+        executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
+
+        begin
+          result = executor.execute(
+            code,
+            timeout: timeout,
+            safe_mode: safe_mode,
+            capture_output: capture_output
+          )
+
+          if result[:success]
+            render(text: format_success_result(result))
+          else
+            render(error: [format_error_result(result)])
+          end
+        rescue RailsActiveMcp::SafetyError => e
+          render(error: ["Safety check failed: #{e.message}"])
+        rescue RailsActiveMcp::TimeoutError => e
+          render(error: ["Execution timed out: #{e.message}"])
+        rescue => e
+          render(error: ["Execution failed: #{e.message}"])
+        end
+      end
+
+      private
+
+      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 format_error_result(result)
+        "Error: #{result[:error]} (#{result[:error_class]})"
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/tools/dry_run_tool.rb

@@ -0,0 +1,41 @@
+module RailsActiveMcp
+  module Tools
+    class DryRunTool < ApplicationMCPTool
+      tool_name "dry_run"
+      description "Analyze Ruby code for safety without executing it"
+
+      property :code, type: "string", description: 'Ruby code to analyze for safety', required: true
+
+      def perform
+        return render(error: "Rails Active MCP is disabled") unless RailsActiveMcp.config.enabled
+
+        code = properties[:code]
+        executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
+        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 << "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
+
+        render(text: output.join("\n"))
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/tools/model_info_tool.rb

@@ -0,0 +1,70 @@
+module RailsActiveMcp
+  module Tools
+    class ModelInfoTool < ApplicationMCPTool
+      tool_name "model_info"
+      description "Get information about Rails models including schema and associations"
+
+      property :model, type: "string", description: 'Model class name', required: true
+      property :include_schema, type: "boolean", description: 'Include database schema information', required: false
+      property :include_associations, type: "boolean", description: 'Include model associations', required: false
+      property :include_validations, type: "boolean", description: 'Include model validations', required: false
+
+      def perform
+        return render(error: "Rails Active MCP is disabled") unless RailsActiveMcp.config.enabled
+
+        model = properties[:model]
+        include_schema = properties.fetch(:include_schema, true)
+        include_associations = properties.fetch(:include_associations, true)
+        include_validations = properties.fetch(:include_validations, true)
+
+        begin
+          model_class = model.constantize
+
+          output = []
+          output << "Model: #{model}"
+          output << "Table: #{model_class.table_name}"
+          output << "Primary Key: #{model_class.primary_key}"
+
+          if include_schema
+            output << "\nSchema:"
+            model_class.columns.each do |column|
+              output << "  #{column.name}: #{column.type} (#{column.sql_type})"
+              output << "    - Null: #{column.null}"
+              output << "    - Default: #{column.default}" if column.default
+            end
+          end
+
+          if include_associations
+            output << "\nAssociations:"
+            model_class.reflections.each do |name, reflection|
+              output << "  #{name}: #{reflection.class.name.split('::').last} -> #{reflection.class_name}"
+            end
+          end
+
+          if include_validations
+            validations = {}
+            model_class.validators.each do |validator|
+              validator.attributes.each do |attribute|
+                validations[attribute] ||= []
+                validations[attribute] << validator.class.name.split('::').last
+              end
+            end
+
+            if validations.any?
+              output << "\nValidations:"
+              validations.each do |attr, validators|
+                output << "  #{attr}: #{validators.join(', ')}"
+              end
+            end
+          end
+
+          render(text: output.join("\n"))
+        rescue NameError
+          render(error: ["Model '#{model}' not found"])
+        rescue => e
+          render(error: ["Error analyzing model: #{e.message}"])
+        end
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/tools/safe_query_tool.rb

@@ -0,0 +1,41 @@
+module RailsActiveMcp
+  module Tools
+    class SafeQueryTool < ApplicationMCPTool
+      tool_name "safe_query"
+      description "Execute safe read-only database queries on Rails models"
+
+      property :model, type: "string", description: 'Model class name (e.g., "User", "Product")', required: true
+      property :method, type: "string", description: 'Query method (find, where, count, etc.)', required: true
+      property :args, type: "array", description: 'Arguments for the query method', required: false
+      property :limit, type: "integer", description: 'Limit results (default: 100)', required: false
+
+      def perform
+        return render(error: "Rails Active MCP is disabled") unless RailsActiveMcp.config.enabled
+
+        model = properties[:model]
+        method = properties[:method]
+        args = properties[:args] || []
+        limit = properties[:limit]
+
+        executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
+
+        result = executor.execute_safe_query(
+          model: model,
+          method: method,
+          args: args,
+          limit: limit
+        )
+
+        if result[:success]
+          output = []
+          output << "Query: #{model}.#{method}(#{args.join(', ')})"
+          output << "Count: #{result[:count]}"
+          output << "Result: #{result[:result].inspect}"
+          render(text: output.join("\n"))
+        else
+          render(error: [result[:error]])
+        end
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailsActiveMcp
+  VERSION = '0.1.1'
+end

data/lib/rails_active_mcp.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'logger'
+require_relative 'rails_active_mcp/version'
+require_relative 'rails_active_mcp/configuration'
+require_relative 'rails_active_mcp/safety_checker'
+require_relative 'rails_active_mcp/console_executor'
+require_relative 'rails_active_mcp/mcp_server'
+require_relative 'rails_active_mcp/engine' if defined?(Rails)
+
+
+module RailsActiveMcp
+  class Error < StandardError; end
+
+  class SafetyError < Error; end
+
+  class ExecutionError < Error; end
+
+  class TimeoutError < Error; end
+
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+      configuration
+    end
+
+    def config
+      configuration || configure
+    end
+
+    # Quick access to safety checker
+    def safe?(code)
+      SafetyChecker.new(config).safe?(code)
+    end
+
+    # Quick execution method
+    def execute(code, **options)
+      ConsoleExecutor.new(config).execute(code, **options)
+    end
+
+    # Access to MCP server instance
+    def server
+      @server ||= McpServer.new
+    end
+
+    # Add logger accessor
+    attr_accessor :logger
+
+    def logger
+      @logger ||= defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger ? Rails.logger : Logger.new(STDOUT)
+    end
+  end
+end
+
+# Auto-configure for Rails
+require_relative 'rails_active_mcp/railtie' if defined?(Rails)

data/mcp.ru

@@ -0,0 +1,5 @@
+require_relative "config/environment"
+require_relative "lib/rails_active_mcp"
+
+# Run the Rails Active MCP server
+run RailsActiveMcp::McpServer.new

data/rails_active_mcp.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'lib/rails_active_mcp/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'rails-active-mcp'
+  spec.version = RailsActiveMcp::VERSION
+  spec.authors = ['Brandyn Britton']
+  spec.email = ['brandynbb96@gmail.com']
+
+  spec.summary = 'Rails Console access via Model Context Protocol (MCP)'
+  spec.description = 'Secure Rails console access for AI agents through Model Context Protocol with safety features and read-only modes'
+  spec.homepage = 'https://github.com/goodpie/rails-active-mcp'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Dependencies
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.3.5'
+  spec.add_runtime_dependency 'rails', '~> 7.0'
+
+  spec.add_dependency 'json', '~> 2.0'
+  spec.add_dependency 'rack', '~> 3.0'
+  spec.add_dependency 'timeout', '~> 0.4'
+
+  # Development dependencies - keep versions consistent with Gemfile
+  spec.add_development_dependency 'factory_bot_rails', '~> 6.0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'rubocop', '~> 1.77'
+  spec.add_development_dependency 'rubocop-rails', '~> 2.32'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'sqlite3', '~> 2.7'
+end