rails-active-mcp 0.1.7 → 2.0.8

data/lib/rails_active_mcp/configuration.rb

@@ -1,119 +1,58 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 
 module RailsActiveMcp
   class Configuration
-    attr_accessor :enabled, :safe_mode, :default_timeout, :max_results,
-                  :allowed_models, :blocked_models, :custom_safety_patterns,
-                  :log_executions, :audit_file, :enable_mutation_tools,
-                  :require_confirmation_for, :execution_environment, :server_mode,
-                  :server_host, :server_port
+    # Core configuration options
+    attr_accessor :allowed_commands, :command_timeout, :enable_logging, :log_level
+
+    # Safety and execution options
+    attr_accessor :safe_mode, :default_timeout, :max_results, :log_executions, :audit_file
+    attr_accessor :custom_safety_patterns, :allowed_models
 
     def initialize
-      @enabled = true
+      @allowed_commands = %w[
+        ls pwd cat head tail grep find wc
+        rails console rails runner
+        bundle exec rspec bundle exec test
+        git status git log git diff
+      ]
+      @command_timeout = 30
+      @enable_logging = true
+      @log_level = :info
+
+      # Safety and execution defaults
       @safe_mode = true
       @default_timeout = 30
       @max_results = 100
-      @allowed_models = [] # Empty means all models allowed
-      @blocked_models = []
+      @log_executions = false
+      @audit_file = nil
       @custom_safety_patterns = []
-      @log_executions = true
-      # Safe Rails.root access
-      if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-        @audit_file = rails_root_join('log',
-                                      'rails_active_mcp.log')
-      end
-      @enable_mutation_tools = false
-      @require_confirmation_for = %i[delete destroy update_all delete_all]
-      @execution_environment = :current # :current, :sandbox, :readonly_replica
-      @server_mode = :stdio # :stdio, :http
-      @server_host = 'localhost'
-      @server_port = 3001
-    end
-
-    # Safety configuration
-    def strict_mode!
-      @safe_mode = true
-      @enable_mutation_tools = false
-      @default_timeout = 15
-      @max_results = 50
-    end
-
-    def permissive_mode!
-      @safe_mode = false
-      @enable_mutation_tools = true
-      @default_timeout = 60
-      @max_results = 1000
-    end
-
-    def production_mode!
-      strict_mode!
-      @execution_environment = :readonly_replica
-      @log_executions = true
-      @require_confirmation_for = %i[delete destroy update create save]
-    end
-
-    # Model access configuration
-    def allow_models(*models)
-      @allowed_models.concat(models.map(&:to_s))
-    end
-
-    def block_models(*models)
-      @blocked_models.concat(models.map(&:to_s))
+      @allowed_models = []
     end
 
-    def add_safety_pattern(pattern, description = nil)
-      @custom_safety_patterns << { pattern: pattern, description: description }
-    end
-
-    # Server configuration
-    def stdio_mode!
-      @server_mode = :stdio
-    end
-
-    def http_mode!(host: 'localhost', port: 3001)
-      @server_mode = :http
-      @server_host = host
-      @server_port = port
-    end
-
-    def server_mode_valid?
-      %i[stdio http].include?(@server_mode)
-    end
-
-    # Validation
     def model_allowed?(model_name)
-      model_str = model_name.to_s
-
-      # Check if specifically blocked
-      return false if @blocked_models.include?(model_str)
-
-      # If allow list is empty, allow all (except blocked)
-      return true if @allowed_models.empty?
+      return true if @allowed_models.empty? # Allow all if none specified
 
-      # Check allow list
-      @allowed_models.include?(model_str)
+      @allowed_models.include?(model_name.to_s)
     end
 
-    def validate!
-      raise ArgumentError, 'timeout must be positive' if @default_timeout <= 0
-      raise ArgumentError, 'max_results must be positive' if @max_results <= 0
-      raise ArgumentError, "invalid server_mode: #{@server_mode}" unless server_mode_valid?
-      raise ArgumentError, 'server_port must be positive' if @server_port <= 0
-
-      return unless defined?(Rails) && @audit_file
-
-      audit_dir = File.dirname(@audit_file)
-      FileUtils.mkdir_p(audit_dir) unless File.directory?(audit_dir)
+    def valid?
+      allowed_commands.is_a?(Array) &&
+        command_timeout.is_a?(Numeric) && command_timeout > 0 &&
+        [true, false].include?(enable_logging) &&
+        %i[debug info warn error].include?(log_level) &&
+        [true, false].include?(safe_mode) &&
+        default_timeout.is_a?(Numeric) && default_timeout > 0 &&
+        max_results.is_a?(Numeric) && max_results > 0 &&
+        [true, false].include?(log_executions) &&
+        custom_safety_patterns.is_a?(Array) &&
+        allowed_models.is_a?(Array)
     end
 
-    private
-
-    def rails_root_join(*args)
-      if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
-        Rails.root.join(*args)
-      else
-        File.join(Dir.pwd, *args)
-      end
+    def reset!
+      initialize
     end
   end
 end

data/lib/rails_active_mcp/console_executor.rb

@@ -194,10 +194,13 @@ module RailsActiveMcp
     def execute_with_captured_output(code)
       # Thread-safe output capture using mutex
       @execution_mutex.synchronize do
-        # Capture both stdout and the return value
+        # Capture both stdout and stderr to prevent any Rails output leakage
         old_stdout = $stdout
+        old_stderr = $stderr
         captured_output = StringIO.new
+        captured_errors = StringIO.new
         $stdout = captured_output
+        $stderr = captured_errors
 
         begin
           # Create thread-safe execution context
@@ -209,17 +212,22 @@ module RailsActiveMcp
           execution_time = Time.now - start_time
 
           output = captured_output.string
+          errors = captured_errors.string
+
+          # Combine output and errors for comprehensive result
+          combined_output = [output, errors].reject(&:empty?).join("\n")
 
           {
             success: true,
             return_value: return_value,
-            output: output,
+            output: combined_output,
             return_value_string: safe_inspect(return_value),
             execution_time: execution_time,
             code: code
           }
         rescue StandardError => e
           execution_time = Time.now - start_time if defined?(start_time)
+          errors = captured_errors.string
 
           {
             success: false,
@@ -227,10 +235,12 @@ module RailsActiveMcp
             error_class: e.class.name,
             backtrace: e.backtrace&.first(10),
             execution_time: execution_time,
-            code: code
+            code: code,
+            stderr: errors.empty? ? nil : errors
           }
         ensure
           $stdout = old_stdout if old_stdout
+          $stderr = old_stderr if old_stderr
         end
       end
     end

data/lib/rails_active_mcp/engine.rb

@@ -6,6 +6,37 @@ module RailsActiveMcp
 
     config.rails_active_mcp = ActiveSupport::OrderedOptions.new
 
+    # Ensure configuration is available very early
+    initializer 'rails_active_mcp.early_configuration', before: :load_config_initializers do
+      RailsActiveMcp.configure unless RailsActiveMcp.configuration
+    end
+
+    # Configure logging with Rails 7.1+ compatibility
+    initializer 'rails_active_mcp.logger', after: :initialize_logger, before: :set_clear_dependencies_hook do
+      # Only set logger if Rails logger is available and responds to logging methods
+      RailsActiveMcp.logger = if defined?(Rails.logger) && Rails.logger.respond_to?(:info)
+                                # Check if Rails logger is using semantic logger or other custom loggers
+                                if Rails.logger.class.name.include?('SemanticLogger')
+                                  # For semantic logger, we need to create a tagged logger
+                                  Rails.logger.tagged('RailsActiveMcp')
+                                else
+                                  # For standard Rails logger, use it directly
+                                  Rails.logger
+                                end
+                              else
+                                # Fallback to our own logger if Rails logger is not available
+                                Logger.new(STDERR).tap do |logger|
+                                  logger.level = Rails.env.production? ? Logger::WARN : Logger::INFO
+                                  logger.formatter = proc do |severity, datetime, progname, msg|
+                                    "[#{datetime}] #{severity} -- RailsActiveMcp: #{msg}\n"
+                                  end
+                                end
+                              end
+
+      # Log that the logger has been initialized
+      RailsActiveMcp.logger.info "Rails Active MCP logger initialized (#{RailsActiveMcp.logger.class.name})"
+    end
+
     # Add generators configuration
     config.generators do |g|
       g.test_framework :rspec, fixture: false
@@ -13,22 +44,6 @@ module RailsActiveMcp
       g.helper false
     end
 
-    # Define routes for the engine
-    routes do
-      # Main MCP endpoint for HTTP clients
-      post '/', to: 'mcp#handle'
-      post '/messages', to: 'mcp#handle'
-
-      # SSE endpoint for better MCP client compatibility
-      get '/sse', to: 'mcp#sse'
-
-      # Health check endpoint
-      get '/health', to: 'mcp#health'
-
-      # Root redirect
-      root to: 'mcp#info'
-    end
-
     initializer 'rails_active_mcp.configure' do |app|
       # Load configuration from Rails config if present
       if app.config.respond_to?(:rails_active_mcp)
@@ -39,18 +54,15 @@ module RailsActiveMcp
         end
       end
 
-      # Set default audit file location
-      RailsActiveMcp.config.audit_file ||= Rails.root.join('log', 'rails_active_mcp.log')
-
       # Validate configuration
-      RailsActiveMcp.config.validate!
+      RailsActiveMcp.config.valid?
     end
 
-    # Add our tools directory to the load path
-    config.autoload_paths << root.join('lib', 'rails_active_mcp', 'tools')
+    # Add our SDK tools directory to the load path
+    config.autoload_paths << root.join('lib', 'rails_active_mcp', 'sdk', 'tools')
 
-    # Ensure our tools are eager loaded in production
-    config.eager_load_paths << root.join('lib', 'rails_active_mcp', 'tools')
+    # Ensure our SDK tools are eager loaded in production
+    config.eager_load_paths << root.join('lib', 'rails_active_mcp', 'sdk', 'tools')
 
     # Add rake tasks
     rake_tasks do

data/lib/rails_active_mcp/sdk/server.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'mcp'
+require 'stringio'
+require 'fileutils'
+
+# Require all SDK tools
+require_relative 'tools/console_execute_tool'
+require_relative 'tools/model_info_tool'
+require_relative 'tools/safe_query_tool'
+require_relative 'tools/dry_run_tool'
+
+module RailsActiveMcp
+  module Sdk
+    class Server
+      attr_reader :mcp_server
+
+      def initialize
+        # Store original streams for restoration
+        @original_stdout = $stdout
+        @original_stderr = $stderr
+
+        # Set up output redirection BEFORE any Rails interaction
+        setup_output_redirection
+
+        # Configure MCP first
+        configure_mcp
+
+        # Create the MCP server with our tools
+        @mcp_server = MCP::Server.new(
+          name: 'rails-active-mcp',
+          version: RailsActiveMcp::VERSION,
+          tools: discover_tools,
+          server_context: server_context
+        )
+
+        # Set up server handlers
+        setup_server_handlers
+      end
+
+      def run_stdio
+        # Ensure output redirection is active for stdio mode
+        ensure_output_redirection_for_stdio
+
+        require 'mcp/transports/stdio'
+        transport = MCP::Transports::StdioTransport.new(@mcp_server)
+        transport.open
+      rescue StandardError => e
+        # Log to stderr (which is redirected to file) and re-raise
+        warn "[#{Time.now}] [RAILS-MCP] FATAL: SDK Server crashed: #{e.message}"
+        warn "[#{Time.now}] [RAILS-MCP] FATAL: #{e.backtrace.join("\n")}"
+        raise
+      ensure
+        restore_output_streams
+      end
+
+      def run_http(port: 3001)
+        # HTTP transport might not be available in the SDK yet
+        # For now, fall back to a basic implementation or error
+        raise NotImplementedError, 'HTTP transport not yet implemented with official MCP SDK'
+      end
+
+      private
+
+      def setup_output_redirection
+        # Skip redirection if in debug mode
+        return if ENV['RAILS_MCP_DEBUG'] == '1'
+
+        # Create log directory
+        log_dir = File.join(Dir.pwd, 'log')
+        FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+
+        # Redirect stderr to log file
+        stderr_log = File.join(log_dir, 'rails_mcp_stderr.log')
+        @stderr_file = File.open(stderr_log, 'a')
+        @stderr_file.sync = true
+        $stderr = @stderr_file
+
+        # Capture stdout during initialization to prevent interference
+        @stdout_buffer = StringIO.new
+        $stdout = @stdout_buffer
+
+        # Log redirection setup
+        warn "[#{Time.now}] [RAILS-MCP] INFO: Output redirection enabled. stderr -> #{stderr_log}"
+      end
+
+      def ensure_output_redirection_for_stdio
+        # Skip if in debug mode
+        return if ENV['RAILS_MCP_DEBUG'] == '1'
+
+        # Check if anything was captured during initialization
+        if @stdout_buffer && !@stdout_buffer.string.empty?
+          captured = @stdout_buffer.string
+          warn "[#{Time.now}] [RAILS-MCP] WARNING: Captured stdout during initialization: #{captured.inspect}"
+        end
+
+        # Restore original stdout for MCP communication, keep stderr redirected
+        $stdout = @original_stdout
+        warn "[#{Time.now}] [RAILS-MCP] INFO: stdout restored for MCP communication, stderr remains redirected"
+      end
+
+      def restore_output_streams
+        return if ENV['RAILS_MCP_DEBUG'] == '1'
+
+        begin
+          $stdout = @original_stdout if @original_stdout
+          $stderr = @original_stderr if @original_stderr
+          @stderr_file&.close
+        rescue StandardError => e
+          # Best effort cleanup
+          warn "Failed to restore output streams: #{e.message}" if @original_stderr
+        end
+      end
+
+      def discover_tools
+        [
+          RailsActiveMcp::Sdk::Tools::ConsoleExecuteTool,
+          RailsActiveMcp::Sdk::Tools::ModelInfoTool,
+          RailsActiveMcp::Sdk::Tools::SafeQueryTool,
+          RailsActiveMcp::Sdk::Tools::DryRunTool
+        ]
+      end
+
+      def configure_mcp
+        # Configure MCP SDK with Rails-specific handlers
+        MCP.configure do |config|
+          config.exception_reporter = method(:handle_rails_exception)
+          config.instrumentation_callback = method(:log_mcp_calls)
+        end
+      end
+
+      def setup_server_handlers
+        # Set up resource read handler (for future use)
+        @mcp_server.resources_read_handler do |params|
+          [
+            {
+              uri: params[:uri],
+              mimeType: 'text/plain',
+              text: "Rails Active MCP Resource: #{params[:uri]}"
+            }
+          ]
+        end
+      end
+
+      def handle_rails_exception(exception, context)
+        # Use stderr which is redirected to log file
+        warn "[#{Time.now}] [RAILS-MCP] ERROR: MCP Exception: #{exception.message}"
+        warn "[#{Time.now}] [RAILS-MCP] ERROR: #{exception.backtrace.join("\n")}" if ENV['RAILS_MCP_DEBUG'] == '1'
+
+        # Log context for debugging
+        return unless context && ENV['RAILS_MCP_DEBUG'] == '1'
+
+        warn "[#{Time.now}] [RAILS-MCP] DEBUG: MCP Context: #{context.inspect}"
+      end
+
+      def log_mcp_calls(data)
+        return unless ENV['RAILS_MCP_DEBUG'] == '1'
+
+        duration_ms = (data[:duration] * 1000).round(2)
+
+        log_message = "MCP #{data[:method]}"
+        log_message += " [#{data[:tool_name]}]" if data[:tool_name]
+        log_message += " (#{duration_ms}ms)"
+
+        warn "[#{Time.now}] [RAILS-MCP] DEBUG: #{log_message}"
+
+        # Log errors separately
+        return unless data[:error]
+
+        warn "[#{Time.now}] [RAILS-MCP] ERROR: MCP Call Error: #{data[:error]}"
+      end
+
+      def server_context
+        {
+          rails_env: defined?(Rails) ? Rails.env : 'unknown',
+          rails_root: defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.to_s : Dir.pwd,
+          config: RailsActiveMcp.config,
+          gem_version: RailsActiveMcp::VERSION
+        }
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/sdk/tools/console_execute_tool.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module RailsActiveMcp
+  module Sdk
+    module Tools
+      class ConsoleExecuteTool < MCP::Tool
+        description 'Execute Ruby code in Rails console with safety checks'
+
+        input_schema(
+          properties: {
+            code: {
+              type: 'string',
+              description: 'Ruby code to execute in Rails console'
+            },
+            safe_mode: {
+              type: 'boolean',
+              description: 'Enable safety checks (default: true)'
+            },
+            timeout: {
+              type: 'integer',
+              description: 'Timeout in seconds (default: 30)'
+            },
+            capture_output: {
+              type: 'boolean',
+              description: 'Capture console output (default: true)'
+            }
+          },
+          required: ['code']
+        )
+
+        annotations(
+          title: 'Rails Console Executor',
+          destructive_hint: true,
+          read_only_hint: false,
+          idempotent_hint: false,
+          open_world_hint: false
+        )
+
+        def self.call(code:, server_context:, safe_mode: true, timeout: 30, capture_output: true)
+          config = RailsActiveMcp.config
+
+          # Create executor with config
+          executor = RailsActiveMcp::ConsoleExecutor.new(config)
+
+          begin
+            result = executor.execute(
+              code,
+              timeout: timeout,
+              safe_mode: safe_mode,
+              capture_output: capture_output
+            )
+
+            if result[:success]
+              MCP::Tool::Response.new([
+                                        { type: 'text', text: format_success_result(result) }
+                                      ])
+            else
+              MCP::Tool::Response.new([
+                                        { type: 'text', text: format_error_result(result) }
+                                      ])
+            end
+          rescue RailsActiveMcp::SafetyError => e
+            error_response("Safety check failed: #{e.message}")
+          rescue RailsActiveMcp::TimeoutError => e
+            error_response("Execution timed out: #{e.message}")
+          rescue StandardError => e
+            error_response("Execution failed: #{e.message}")
+          end
+        end
+
+        private
+
+        def self.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 self.format_error_result(result)
+          error_msg = "Error: #{result[:error]}"
+          error_msg += " (#{result[:error_class]})" if result[:error_class]
+          error_msg
+        end
+
+        def self.error_response(message)
+          MCP::Tool::Response.new([
+                                    { type: 'text', text: message }
+                                  ])
+        end
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/sdk/tools/dry_run_tool.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module RailsActiveMcp
+  module Sdk
+    module Tools
+      class DryRunTool < MCP::Tool
+        description 'Analyze Ruby code for safety without executing it'
+
+        input_schema(
+          properties: {
+            code: {
+              type: 'string',
+              description: 'Ruby code to analyze for safety'
+            }
+          },
+          required: ['code']
+        )
+
+        annotations(
+          title: 'Code Safety Analyzer',
+          destructive_hint: false,
+          read_only_hint: true,
+          idempotent_hint: true,
+          open_world_hint: false
+        )
+
+        def self.call(code:, server_context:, check_safety: true, analyze_dependencies: true)
+          config = RailsActiveMcp.config
+
+          # Create safety checker
+
+          executor = RailsActiveMcp::ConsoleExecutor.new(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
+
+          MCP::Tool::Response.new([
+                                    { type: 'text', text: output.join("\n") }
+                                  ])
+        end
+
+        private
+
+        def self.error_response(message)
+          MCP::Tool::Response.new([
+                                    { type: 'text', text: message }
+                                  ])
+        end
+      end
+    end
+  end
+end