rails-active-mcp 0.1.5 → 0.1.7

data/lib/rails_active_mcp/console_executor.rb

@@ -5,9 +5,15 @@ require 'rails'
 
 module RailsActiveMcp
   class ConsoleExecutor
+    # Thread-safe execution errors
+    class ExecutionError < StandardError; end
+    class ThreadSafetyError < StandardError; end
+
     def initialize(config)
       @config = config
       @safety_checker = SafetyChecker.new(config)
+      # Thread-safe mutex for critical sections
+      @execution_mutex = Mutex.new
     end
 
     def execute(code, timeout: nil, safe_mode: nil, capture_output: true)
@@ -17,16 +23,14 @@ module RailsActiveMcp
       # Pre-execution safety check
       if safe_mode
         safety_analysis = @safety_checker.analyze(code)
-        unless safety_analysis[:safe]
-          raise SafetyError, "Code failed safety check: #{safety_analysis[:summary]}"
-        end
+        raise SafetyError, "Code failed safety check: #{safety_analysis[:summary]}" unless safety_analysis[:safe]
       end
 
       # Log execution if enabled
       log_execution(code) if @config.log_executions
 
-      # Execute with timeout and output capture
-      result = execute_with_timeout(code, timeout, capture_output)
+      # Execute with Rails 7.1 compatible thread safety
+      result = execute_with_rails_executor(code, timeout, capture_output)
 
       # Post-execution processing
       process_result(result)
@@ -36,16 +40,13 @@ module RailsActiveMcp
       limit ||= @config.max_results
 
       # Validate model access
-      unless @config.model_allowed?(model)
-        raise SafetyError, "Access to model '#{model}' is not allowed"
-      end
+      raise SafetyError, "Access to model '#{model}' is not allowed" unless @config.model_allowed?(model)
 
       # Validate method safety
-      unless safe_query_method?(method)
-        raise SafetyError, "Method '#{method}' is not allowed for safe queries"
-      end
+      raise SafetyError, "Method '#{method}' is not allowed for safe queries" unless safe_query_method?(method)
 
-      begin
+      # Execute with proper Rails executor and connection management
+      execute_with_rails_executor_and_connection do
         model_class = model.to_s.constantize
 
         # Build and execute query
@@ -56,9 +57,7 @@ module RailsActiveMcp
                 end
 
         # Apply limit for enumerable results
-        if query.respond_to?(:limit) && !count_method?(method)
-          query = query.limit(limit)
-        end
+        query = query.limit(limit) if query.respond_to?(:limit) && !count_method?(method)
 
         result = execute_query_with_timeout(query)
 
@@ -71,7 +70,7 @@ module RailsActiveMcp
           count: calculate_count(result),
           executed_at: Time.now
         }
-      rescue => e
+      rescue StandardError => e
         log_error(e, { model: model, method: method, args: args })
         {
           success: false,
@@ -99,6 +98,87 @@ module RailsActiveMcp
 
     private
 
+    def execute_with_rails_executor(code, timeout, capture_output)
+      if defined?(Rails) && Rails.application
+        # Handle development mode reloading if needed
+        handle_development_reloading if Rails.env.development?
+
+        # Rails 7.1 compatible execution with proper dependency loading
+        if defined?(ActiveSupport::Dependencies) && ActiveSupport::Dependencies.respond_to?(:interlock)
+          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+            Rails.application.executor.wrap do
+              execute_with_connection_pool(code, timeout, capture_output)
+            end
+          end
+        else
+          # Fallback for older Rails versions
+          Rails.application.executor.wrap do
+            execute_with_connection_pool(code, timeout, capture_output)
+          end
+        end
+      else
+        # Non-Rails execution
+        execute_with_timeout(code, timeout, capture_output)
+      end
+    rescue TimeoutError => e
+      # Re-raise timeout errors as-is
+      raise e
+    rescue StandardError => e
+      raise ThreadSafetyError, "Thread-safe execution failed: #{e.message}"
+    end
+
+    # Manage ActiveRecord connection pool properly
+    def execute_with_connection_pool(code, timeout, capture_output)
+      if defined?(ActiveRecord::Base)
+        ActiveRecord::Base.connection_pool.with_connection do
+          execute_with_timeout(code, timeout, capture_output)
+        end
+      else
+        execute_with_timeout(code, timeout, capture_output)
+      end
+    ensure
+      # Clean up connections to prevent pool exhaustion
+      if defined?(ActiveRecord::Base)
+        ActiveRecord::Base.clear_active_connections!
+        # Probabilistic garbage collection for long-running processes
+        GC.start if rand(100) < 5
+      end
+    end
+
+    # Helper method for safe queries with proper Rails executor and connection management
+    def execute_with_rails_executor_and_connection(&block)
+      if defined?(Rails) && Rails.application
+        if defined?(ActiveSupport::Dependencies) && ActiveSupport::Dependencies.respond_to?(:interlock)
+          ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+            Rails.application.executor.wrap do
+              if defined?(ActiveRecord::Base)
+                ActiveRecord::Base.connection_pool.with_connection(&block)
+              else
+                yield
+              end
+            end
+          end
+        else
+          Rails.application.executor.wrap do
+            if defined?(ActiveRecord::Base)
+              ActiveRecord::Base.connection_pool.with_connection(&block)
+            else
+              yield
+            end
+          end
+        end
+      else
+        yield
+      end
+    ensure
+      # Clean up connections
+      if defined?(ActiveRecord::Base)
+        ActiveRecord::Base.clear_active_connections!
+        # Probabilistic garbage collection for long-running processes
+        GC.start if rand(100) < 5
+      end
+    end
+
     def execute_with_timeout(code, timeout, capture_output)
       Timeout.timeout(timeout) do
         if capture_output
@@ -112,46 +192,52 @@ module RailsActiveMcp
     end
 
     def execute_with_captured_output(code)
-      # Capture both stdout and the return value
-      old_stdout = $stdout
-      captured_output = StringIO.new
-      $stdout = captured_output
-
-      # Create execution context
-      binding_context = create_console_binding
-
-      # Execute code
-      start_time = Time.now
-      return_value = binding_context.eval(code)
-      execution_time = Time.now - start_time
-
-      output = captured_output.string
-      $stdout = old_stdout
-
-      {
-        success: true,
-        return_value: return_value,
-        output: output,
-        return_value_string: safe_inspect(return_value),
-        execution_time: execution_time,
-        code: code
-      }
-    rescue => e
-      $stdout = old_stdout if old_stdout
-      execution_time = Time.now - start_time if defined?(start_time)
-
-      {
-        success: false,
-        error: e.message,
-        error_class: e.class.name,
-        backtrace: e.backtrace&.first(10),
-        execution_time: execution_time,
-        code: code
-      }
+      # Thread-safe output capture using mutex
+      @execution_mutex.synchronize do
+        # Capture both stdout and the return value
+        old_stdout = $stdout
+        captured_output = StringIO.new
+        $stdout = captured_output
+
+        begin
+          # Create thread-safe execution context
+          binding_context = create_thread_safe_console_binding
+
+          # Execute code
+          start_time = Time.now
+          return_value = binding_context.eval(code)
+          execution_time = Time.now - start_time
+
+          output = captured_output.string
+
+          {
+            success: true,
+            return_value: return_value,
+            output: 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)
+
+          {
+            success: false,
+            error: e.message,
+            error_class: e.class.name,
+            backtrace: e.backtrace&.first(10),
+            execution_time: execution_time,
+            code: code
+          }
+        ensure
+          $stdout = old_stdout if old_stdout
+        end
+      end
     end
 
     def execute_direct(code)
-      binding_context = create_console_binding
+      # Create thread-safe binding context
+      binding_context = create_thread_safe_console_binding
       start_time = Time.now
 
       result = binding_context.eval(code)
@@ -163,7 +249,7 @@ module RailsActiveMcp
         execution_time: execution_time,
         code: code
       }
-    rescue => e
+    rescue StandardError => e
       execution_time = Time.now - start_time if defined?(start_time)
 
       {
@@ -186,35 +272,47 @@ module RailsActiveMcp
       end
     end
 
-    def create_console_binding
-      # Create a clean binding with Rails console helpers
+    # Thread-safe console binding creation
+    def create_thread_safe_console_binding
+      # Create a new binding context for each execution to avoid shared state
       console_context = Object.new
 
       console_context.instance_eval do
-        # Add Rails helpers if available
+        # Add Rails helpers if available (thread-safe)
         if defined?(Rails) && Rails.application
-          extend Rails.application.routes.url_helpers if Rails.application.routes
+          # Only extend if routes are available and it's safe to do so
+          extend Rails.application.routes.url_helpers if Rails.application.routes && !Rails.env.production?
 
           def reload!
-            Rails.application.reloader.reload!
-            "Reloaded!"
+            if defined?(Rails) && Rails.application && Rails.application.respond_to?(:reloader)
+              Rails.application.reloader.reload!
+              'Reloaded!'
+            else
+              'Reload not available'
+            end
           end
 
           def app
-            Rails.application
+            Rails.application if defined?(Rails)
           end
 
           def helper
-            ApplicationController.helpers if defined?(ApplicationController)
+            return unless defined?(ApplicationController) && ApplicationController.respond_to?(:helpers)
+
+            ApplicationController.helpers
           end
         end
 
-        # Add common console helpers
+        # Add common console helpers (thread-safe)
         def sql(query)
+          raise NoMethodError, 'ActiveRecord not available' unless defined?(ActiveRecord::Base)
+
           ActiveRecord::Base.connection.select_all(query).to_a
         end
 
         def schema(table_name)
+          raise NoMethodError, 'ActiveRecord not available' unless defined?(ActiveRecord::Base)
+
           ActiveRecord::Base.connection.columns(table_name)
         end
       end
@@ -222,6 +320,12 @@ module RailsActiveMcp
       console_context.instance_eval { binding }
     end
 
+    # Previous methods remain the same but are now called within thread-safe context
+    def create_console_binding
+      # Delegate to thread-safe version
+      create_thread_safe_console_binding
+    end
+
     def safe_query_method?(method)
       safe_methods = %w[
         find find_by find_each find_in_batches
@@ -274,18 +378,16 @@ module RailsActiveMcp
 
     def safe_inspect(object)
       object.inspect
-    rescue => e
+    rescue StandardError => e
       "#<#{object.class}:0x#{object.object_id.to_s(16)} (inspect failed: #{e.message})>"
     end
 
     def process_result(result)
       # Apply max results limit to output
-      if result[:success] && result[:return_value].is_a?(Array)
-        if result[:return_value].size > @config.max_results
-          result[:return_value] = result[:return_value].first(@config.max_results)
-          result[:truncated] = true
-          result[:note] = "Result truncated to #{@config.max_results} items"
-        end
+      if result[:success] && result[:return_value].is_a?(Array) && (result[:return_value].size > @config.max_results)
+        result[:return_value] = result[:return_value].first(@config.max_results)
+        result[:truncated] = true
+        result[:note] = "Result truncated to #{@config.max_results} items"
       end
 
       result
@@ -310,16 +412,16 @@ module RailsActiveMcp
       recommendations = []
 
       if safety_analysis[:violations].any?
-        recommendations << "Consider using read-only alternatives"
-        recommendations << "Review the code for unintended side effects"
+        recommendations << 'Consider using read-only alternatives'
+        recommendations << 'Review the code for unintended side effects'
 
         if safety_analysis[:violations].any? { |v| v[:severity] == :critical }
-          recommendations << "This code contains critical safety violations and should not be executed"
+          recommendations << 'This code contains critical safety violations and should not be executed'
         end
       end
 
       unless safety_analysis[:read_only]
-        recommendations << "Consider using the safe_query tool for read-only operations"
+        recommendations << 'Consider using the safe_query tool for read-only operations'
       end
 
       recommendations
@@ -338,9 +440,9 @@ module RailsActiveMcp
       File.open(@config.audit_file, 'a') do |f|
         f.puts(JSON.generate(log_entry))
       end
-    rescue => e
+    rescue StandardError => e
       # Don't fail execution due to logging issues
-      Rails.logger.warn "Failed to log Rails Active MCP execution: #{e.message}" if defined?(Rails)
+      RailsActiveMcp.logger.warn "Failed to log Rails Active MCP execution: #{e.message}"
     end
 
     def log_error(error, context = {})
@@ -358,7 +460,7 @@ module RailsActiveMcp
       File.open(@config.audit_file, 'a') do |f|
         f.puts(JSON.generate(log_entry))
       end
-    rescue
+    rescue StandardError
       # Silently fail logging
     end
 
@@ -371,8 +473,20 @@ module RailsActiveMcp
       else
         { environment: Rails.env }
       end
-    rescue
+    rescue StandardError
       { unknown: true }
     end
+
+    # Handle development mode reloading safely
+    def handle_development_reloading
+      return unless Rails.env.development?
+      return unless defined?(Rails.application.reloader)
+
+      # Check if reloading is needed and safe to do
+      Rails.application.reloader.reload! if Rails.application.reloader.check!
+    rescue StandardError => e
+      # Log but don't fail execution due to reloading issues
+      RailsActiveMcp.logger.warn "Failed to reload in development: #{e.message}" if defined?(RailsActiveMcp.logger)
+    end
   end
 end

data/lib/rails_active_mcp/engine.rb

@@ -13,6 +13,22 @@ 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)

data/lib/rails_active_mcp/mcp_server.rb

@@ -26,21 +26,15 @@ module RailsActiveMcp
         data = JSON.parse(body)
         response = handle_jsonrpc_request(data)
 
-        [200, {'Content-Type' => 'application/json'}, [response.to_json]]
+        [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)
+      rescue StandardError => e
+        RailsActiveMcp.logger.error "MCP Server Error: #{e.message}"
         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'
@@ -53,11 +47,21 @@ module RailsActiveMcp
         handle_resources_list(data)
       when 'resources/read'
         handle_resources_read(data)
+      when 'ping'
+        handle_ping(data)
       else
-        jsonrpc_error(data['id'], -32601, 'Method not found')
+        jsonrpc_error(data['id'], -32_601, 'Method not found')
       end
     end
 
+    def handle_ping(data)
+      {
+        jsonrpc: JSONRPC_VERSION,
+        id: data['id'],
+        result: {}
+      }
+    end
+
     def handle_initialize(data)
       {
         jsonrpc: JSONRPC_VERSION,
@@ -91,9 +95,7 @@ module RailsActiveMcp
         }
 
         # Add annotations if present
-        if tool[:annotations] && !tool[:annotations].empty?
-          tool_def[:annotations] = tool[:annotations]
-        end
+        tool_def[:annotations] = tool[:annotations] if tool[:annotations] && !tool[:annotations].empty?
 
         tool_def
       end
@@ -110,7 +112,7 @@ module RailsActiveMcp
       arguments = data.dig('params', 'arguments') || {}
 
       tool = @tools[tool_name]
-      return jsonrpc_error(data['id'], -32602, "Tool '#{tool_name}' not found") unless tool
+      return jsonrpc_error(data['id'], -32_602, "Tool '#{tool_name}' not found") unless tool
 
       begin
         result = tool[:handler].call(arguments)
@@ -119,8 +121,8 @@ module RailsActiveMcp
           id: data['id'],
           result: { content: [{ type: 'text', text: result.to_s }] }
         }
-      rescue => e
-        jsonrpc_error(data['id'], -32603, "Tool execution failed: #{e.message}")
+      rescue StandardError => e
+        jsonrpc_error(data['id'], -32_603, "Tool execution failed: #{e.message}")
       end
     end
 
@@ -150,6 +152,12 @@ module RailsActiveMcp
       }
     end
 
+    private
+
+    def json_request?(request)
+      request.content_type&.include?('application/json')
+    end
+
     def register_default_tools
       register_tool(
         'rails_console_execute',
@@ -207,7 +215,7 @@ module RailsActiveMcp
             query: { type: 'string', description: 'Safe query to execute' },
             model: { type: 'string', description: 'Model class name' }
           },
-          required: ['query', 'model']
+          required: %w[query model]
         },
         # Safe read-only query tool
         {
@@ -244,7 +252,7 @@ module RailsActiveMcp
     end
 
     def execute_console_code(args)
-      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+      return 'Rails Active MCP is disabled' unless RailsActiveMcp.config.enabled
 
       executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
 
@@ -265,13 +273,13 @@ module RailsActiveMcp
         "Safety check failed: #{e.message}"
       rescue RailsActiveMcp::TimeoutError => e
         "Execution timed out: #{e.message}"
-      rescue => e
+      rescue StandardError => e
         "Execution failed: #{e.message}"
       end
     end
 
     def get_model_info(model_name)
-      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+      return 'Rails Active MCP is disabled' unless RailsActiveMcp.config.enabled
 
       begin
         model_class = model_name.constantize
@@ -285,20 +293,21 @@ module RailsActiveMcp
         info.join("\n")
       rescue NameError
         "Model '#{model_name}' not found"
-      rescue => e
+      rescue StandardError => e
         "Error getting model info: #{e.message}"
       end
     end
 
     def execute_safe_query(args)
-      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+      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?]
+        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)
@@ -307,13 +316,13 @@ module RailsActiveMcp
         result.to_s
       rescue NameError
         "Model '#{args['model']}' not found"
-      rescue => e
+      rescue StandardError => e
         "Error executing query: #{e.message}"
       end
     end
 
     def dry_run_analysis(code)
-      return "Rails Active MCP is disabled" unless RailsActiveMcp.config.enabled
+      return 'Rails Active MCP is disabled' unless RailsActiveMcp.config.enabled
 
       executor = RailsActiveMcp::ConsoleExecutor.new(RailsActiveMcp.config)
 
@@ -343,7 +352,7 @@ module RailsActiveMcp
         end
 
         output.join("\n")
-      rescue => e
+      rescue StandardError => e
         "Analysis failed: #{e.message}"
       end
     end
@@ -367,7 +376,7 @@ module RailsActiveMcp
     end
 
     def error_response(status, message)
-      [status, {'Content-Type' => 'application/json'}, 
+      [status, { 'Content-Type' => 'application/json' },
        [{ error: message }.to_json]]
     end
   end

data/lib/rails_active_mcp/railtie.rb

@@ -25,9 +25,31 @@ module RailsActiveMcp
       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)
+    # Configure logging - Fixed for 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
+                                # This should not happen in normal Rails apps but provides safety
+                                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
   end