rails-active-mcp 0.1.6 → 2.0.7

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.6'
+  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,16 @@ module RailsActiveMcp
       ConsoleExecutor.new(config).execute(code, **options)
     end
 
-    # Access to MCP server instance
-    def server
-      @server ||= McpServer.new
-    end
-
-    # Add logger accessor
+    # Logger accessor - configured by engine or defaults to stderr
     attr_accessor :logger
 
     def logger
-      @logger ||= defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger ? Rails.logger : Logger.new(STDOUT)
+      @logger ||= Logger.new($stderr).tap do |logger|
+        logger.level = Logger::INFO
+        logger.formatter = proc do |severity, datetime, progname, msg|
+          "[#{datetime}] #{severity} -- RailsActiveMcp: #{msg}\n"
+        end
+      end
     end
   end
 end

data/rails_active_mcp.gemspec

@@ -30,12 +30,16 @@ Gem::Specification.new do |spec|
   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'
+  # Runtime dependencies - more flexible Rails version support
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.3'
+  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'
-  spec.add_dependency 'rack', '~> 3.0'
+  spec.add_dependency 'rack', '>= 2.0', '< 4.0'
   spec.add_dependency 'timeout', '~> 0.4'
   spec.add_dependency 'webrick', '~> 1.8'