rails-active-mcp 0.1.7 → 2.0.7

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

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module RailsActiveMcp
+  module Sdk
+    module Tools
+      class ModelInfoTool < MCP::Tool
+        description 'Get information about Rails models including schema and associations'
+
+        input_schema(
+          properties: {
+            model: {
+              type: 'string',
+              description: 'Model class name'
+            },
+            include_schema: {
+              type: 'boolean',
+              description: 'Include database schema information'
+            },
+            include_associations: {
+              type: 'boolean',
+              description: 'Include model associations'
+            },
+            include_validations: {
+              type: 'boolean',
+              description: 'Include model validations'
+            }
+          },
+          required: ['model']
+        )
+
+        annotations(
+          title: 'Rails Model Inspector',
+          destructive_hint: false,
+          read_only_hint: true,
+          idempotent_hint: true,
+          open_world_hint: false
+        )
+
+        def self.call(model:, server_context:, include_schema: true, include_associations: true,
+                      include_validations: true)
+          config = RailsActiveMcp.config
+
+          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
+
+            MCP::Tool::Response.new([
+                                      { type: 'text', text: output.join("\n") }
+                                    ])
+          rescue NameError
+            error_response("Model '#{model}' not found")
+          rescue StandardError => e
+            error_response("Error analyzing model: #{e.message}")
+          end
+        end
+
+        private
+
+        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/safe_query_tool.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'mcp'
+
+module RailsActiveMcp
+  module Sdk
+    module Tools
+      class SafeQueryTool < MCP::Tool
+        description 'Execute safe read-only database queries on Rails models'
+
+        input_schema(
+          properties: {
+            model: {
+              type: 'string',
+              description: 'Model class name (e.g., "User", "Product")'
+            },
+            method: {
+              type: 'string',
+              description: 'Query method (find, where, count, etc.)'
+            },
+            args: {
+              type: 'array',
+              description: 'Arguments for the query method'
+            },
+            limit: {
+              type: 'integer',
+              description: 'Limit results (default: 100)'
+            }
+          },
+          required: %w[model method]
+        )
+
+        annotations(
+          title: 'Safe Query Executor',
+          destructive_hint: false,
+          read_only_hint: true,
+          idempotent_hint: true,
+          open_world_hint: false
+        )
+
+        def self.call(model:, method:, server_context:, args: [], limit: 100)
+          config = RailsActiveMcp.config
+
+          executor = RailsActiveMcp::ConsoleExecutor.new(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]}" if result[:count]
+            output << "Result: #{result[:result].inspect}"
+
+            MCP::Tool::Response.new([
+                                      { type: 'text', text: output.join("\n") }
+                                    ])
+          else
+            error_response(result[:error])
+          end
+        end
+
+        private
+
+        def self.error_response(message)
+          MCP::Tool::Response.new([
+                                    { type: 'text', text: message }
+                                  ])
+        end
+      end
+    end
+  end
+end

data/lib/rails_active_mcp/version.rb

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

data/lib/rails_active_mcp.rb

@@ -5,18 +5,17 @@ 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'
+
+# Load SDK server
+require_relative 'rails_active_mcp/sdk/server'
 
 # Load Engine for Rails integration
 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
@@ -42,16 +41,11 @@ module RailsActiveMcp
       ConsoleExecutor.new(config).execute(code, **options)
     end
 
-    # Access to MCP server instance
-    def server
-      @server ||= McpServer.new
-    end
-
-    # Logger accessor - configured by railtie or defaults to stderr
+    # Logger accessor - configured by engine or defaults to stderr
     attr_accessor :logger
 
     def logger
-      @logger ||= Logger.new(STDERR).tap do |logger|
+      @logger ||= Logger.new($stderr).tap do |logger|
         logger.level = Logger::INFO
         logger.formatter = proc do |severity, datetime, progname, msg|
           "[#{datetime}] #{severity} -- RailsActiveMcp: #{msg}\n"

data/rails_active_mcp.gemspec

@@ -32,7 +32,10 @@ Gem::Specification.new do |spec|
 
   # Runtime dependencies - more flexible Rails version support
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.3'
-  spec.add_runtime_dependency 'rails', '>= 6.1', '< 8.0'
+  spec.add_runtime_dependency 'rails', '>= 6.1', '< 9.0'
+
+  # MCP SDK - Core protocol implementation
+  spec.add_runtime_dependency 'mcp', '~> 0.1.0'
 
   # Core dependencies
   spec.add_dependency 'json', '~> 2.0'