rails-active-mcp 0.1.7 → 2.0.7

data/lib/generators/rails_active_mcp/install/install_generator.rb

@@ -20,30 +20,24 @@ module RailsActiveMcp
           # This ensures the server runs within the Rails project context
 
           require 'bundler/setup'
-          require 'stringio'
 
           # Set Rails environment
           ENV['RAILS_ENV'] ||= 'development'
 
-          # Suppress Rails loading output for MCP JSON protocol
-          unless ENV['RAILS_MCP_DEBUG'] == '1'
-            original_stdout = $stdout
-            original_stderr = $stderr
-            $stdout = StringIO.new
-            $stderr = StringIO.new
-          end
-
-          # Load Rails application
+          # Load Rails application first
           require_relative '../config/environment'
 
-          # Restore output streams
-          unless ENV['RAILS_MCP_DEBUG'] == '1'
-            $stdout = original_stdout
-            $stderr = original_stderr
-          end
+          # Now start the MCP server using the SDK implementation
+          require 'rails_active_mcp/sdk/server'
 
-          # Now run the actual MCP server
-          load Gem.bin_path('rails_active_mcp', 'rails-active-mcp-server')
+          begin
+            server = RailsActiveMcp::SDK::Server.new
+            server.run
+          rescue StandardError => e
+            warn "Error starting Rails Active MCP server: \#{e.message}"
+            warn e.backtrace if ENV['RAILS_MCP_DEBUG'] == '1'
+            exit 1
+          end
         RUBY
 
         chmod 'bin/rails-active-mcp-server', 0o755
@@ -57,7 +51,6 @@ module RailsActiveMcp
 
           # Rails Active MCP Wrapper Script
           # Ensures correct Ruby environment for Claude Desktop execution
-          # Research-based solution for version manager compatibility
 
           # Fix Claude Desktop environment isolation issues
           export HOME="${HOME:-#{ENV['HOME']}}"
@@ -95,24 +88,6 @@ module RailsActiveMcp
         say 'Created environment wrapper at bin/rails-active-mcp-wrapper', :green
       end
 
-      def create_mcp_route
-        # Check if routes file exists and is writable
-        routes_file = 'config/routes.rb'
-        return unless File.exist?(routes_file)
-
-        # Read current routes to check for conflicts
-        routes_content = File.read(routes_file)
-
-        if routes_content.include?('/mcp')
-          say "Warning: Route '/mcp' already exists. Skipping route creation.", :yellow
-          say "Manual setup: Add 'mount RailsActiveMcp::Engine, at: \"/mcp\"' to your routes.rb", :yellow
-        else
-          # Use Engine mounting instead of direct server mounting
-          route "mount RailsActiveMcp::Engine, at: '/mcp'"
-          say "Added MCP route at '/mcp'. You can change this in config/routes.rb", :green
-        end
-      end
-
       def create_mcp_config
         template 'mcp.ru', 'mcp.ru'
       end
@@ -134,7 +109,6 @@ module RailsActiveMcp
         say '  "mcpServers": {', :cyan
         say '    "rails-active-mcp": {', :cyan
         say "      \"command\": \"#{Rails.root}/bin/rails-active-mcp-wrapper\",", :cyan
-        say '      "args": ["stdio"],', :cyan
         say "      \"cwd\": \"#{Rails.root}\",", :cyan
         say '      "env": {', :cyan
         say '        "RAILS_ENV": "development",', :cyan
@@ -144,6 +118,12 @@ module RailsActiveMcp
         say '  }', :cyan
         say '}', :cyan
         say '', :green
+        say "\nAvailable Tools in Claude Desktop:", :green
+        say '- console_execute: Execute Ruby code with safety checks', :yellow
+        say '- model_info: Get detailed information about Rails models', :yellow
+        say '- safe_query: Execute safe read-only database queries', :yellow
+        say '- dry_run: Analyze Ruby code for safety without execution', :yellow
+        say '', :green
         say "\nWhy use the wrapper?", :green
         say '- Handles Ruby version manager environments (asdf, rbenv, etc.)', :yellow
         say '- Prevents "bundler version" and "Ruby version" conflicts', :yellow
@@ -151,8 +131,8 @@ module RailsActiveMcp
         say "\nAlternative (if wrapper doesn't work):", :green
         say 'Use bin/rails-active-mcp-server instead of the wrapper', :yellow
         say "\nTesting:", :green
-        say '1. Test manually: bin/rails-active-mcp-wrapper stdio', :yellow
-        say '2. Should output JSON (not plain text)', :yellow
+        say '1. Test manually: bin/rails-active-mcp-wrapper', :yellow
+        say '2. Should output JSON responses (not plain text)', :yellow
         say '3. Restart Claude Desktop after config changes', :yellow
         say "\nTroubleshooting:", :green
         say '- Set RAILS_MCP_DEBUG=1 for verbose logging', :yellow

data/lib/generators/rails_active_mcp/install/templates/README.md

@@ -1,48 +1,32 @@
 ================================================================================
-Rails Active MCP has been installed!
+Rails Active MCP Installation Complete!
 ================================================================================
 
-Configuration:
-- Initializer created at: config/initializers/rails_active_mcp.rb
-- Custom MCP server mounted at: /mcp
-- MCP server configuration: mcp.ru
-- Audit log will be created at: log/rails_active_mcp.log
+🎉 Rails Active MCP v2.0 with Official MCP Ruby SDK has been installed!
 
-Next Steps:
+📁 Files Created:
+- config/initializers/rails_active_mcp.rb (Configuration)
+- bin/rails-active-mcp-server (Main server executable)
+- bin/rails-active-mcp-wrapper (Environment wrapper for Claude Desktop)
+- mcp.ru (Rack configuration file)
 
-1. Review and customize the configuration in config/initializers/rails_active_mcp.rb
+🛠️ Available MCP Tools:
+- console_execute: Execute Ruby code with safety checks
+- model_info: Get detailed information about Rails models  
+- safe_query: Execute safe read-only database queries
+- dry_run: Analyze Ruby code for safety without execution
 
-2. Configure server mode in config/initializers/rails_active_mcp.rb:
-   config.server_mode = :stdio    # For Claude Desktop (default)
-   config.server_mode = :http     # For HTTP-based integrations
-   config.server_host = 'localhost'
-   config.server_port = 3001
+🚀 Quick Start:
 
-3. Start the MCP server:
-   Option A: Use configured mode (RECOMMENDED)
-   $ bundle exec rails-active-mcp-server
-
-   Option B: Override mode via command line
-   $ bundle exec rails-active-mcp-server stdio  # Force stdio mode
-   $ bundle exec rails-active-mcp-server http   # Force HTTP mode
-
-   Option C: Rails-mounted server (HTTP)
-   $ rails server
-
-   Option D: Using rackup
-   $ rackup mcp.ru -p 3001
-
-4. For Claude Desktop integration, add this to your Claude Desktop configuration:
-
-   Location: ~/.config/claude-desktop/claude_desktop_config.json (Linux/macOS)
-   Location: %APPDATA%\Claude\claude_desktop_config.json (Windows)
+1. Test the server:
+   $ ./bin/rails-active-mcp-server
 
+2. For Claude Desktop, add to claude_desktop_config.json:
    {
      "mcpServers": {
        "rails-active-mcp": {
-         "command": "<%= Rails.root %>/bin/rails-active-mcp-wrapper",
-         "args": ["stdio"],
-         "cwd": "<%= Rails.root %>", 
+         "command": "/path/to/your/project/bin/rails-active-mcp-wrapper",
+         "cwd": "/path/to/your/project",
          "env": {
            "RAILS_ENV": "development",
            "HOME": "/Users/your-username"
@@ -51,138 +35,20 @@ Next Steps:
      }
    }
 
-   OR if you've installed the gem globally:
-
-   {
-     "mcpServers": {
-       "rails-active-mcp": {
-         "command": "rails-active-mcp-server",
-         "args": ["stdio"],
-         "cwd": "/path/to/your/rails/project"
-       }
-     }
-   }
-
-5. For other MCP clients (HTTP-based), add this to your MCP configuration:
-   {
-     "mcpServers": {
-       "rails-console": {
-         "command": "curl",
-         "args": ["-X", "POST", "-H", "Content-Type: application/json", "-d", "@-", "http://localhost:3000/mcp"]
-       }
-     }
-   }
-
-6. Test the installation:
-   $ rails console
-   > RailsActiveMcp.safe?("User.count")
-   > RailsActiveMcp.execute("User.count")
-
-Built-in Tools Available in Claude:
-- rails_console_execute: Execute Ruby code in Rails console with safety checks
-- rails_model_info: Get detailed information about Rails models
-- rails_safe_query: Execute safe read-only database queries
-- rails_dry_run: Analyze Ruby code for safety without execution
-
-Extend with custom tools by modifying the MCP server implementation.
-
-Security Notes:
-- Production mode enables strict safety by default
-- All executions are logged to the audit file
-- Dangerous operations are blocked in safe mode
-- Review the safety patterns in the configuration
-
-Transport Modes:
-- stdio: For Claude Desktop and compatible MCP clients (recommended)
-- http: For HTTP-based integrations and web applications
-
-Configuration Examples:
-
-For Claude Desktop (default):
-  config.server_mode = :stdio
-
-For HTTP web integrations:
-  config.server_mode = :http
-  config.server_host = 'localhost'
-  config.server_port = 3001
-
-For Docker/remote access:
-  config.http_mode!(host: '0.0.0.0', port: 8080)
-
-For development with multiple transport modes:
-  if Rails.env.development?
-    config.stdio_mode!  # Claude Desktop
-  else
-    config.http_mode!(host: '0.0.0.0', port: 3001)  # Production HTTP
-  end
-
-Custom MCP Server Benefits:
-- No external dependencies
-- Full control over implementation
-- Simplified deployment
-- Enhanced security
-- Works with Claude Desktop
-
-Debugging and Troubleshooting:
-
-For interactive debugging, use the MCP Inspector:
-$ bin/debug-mcp-server --mode inspector
-
-This will:
-- Launch the MCP Inspector connected to your server
-- Allow interactive testing of all tools
-- Show real-time debug output and logs
-
-Debug logging:
-$ RAILS_MCP_DEBUG=1 bundle exec rails-active-mcp-server stdio
-
-View Claude Desktop logs:
-$ tail -f ~/Library/Logs/Claude/mcp*.log  # macOS
-$ tail -f ~/.config/claude-desktop/logs/*.log  # Linux
-
-Common issues:
-
-1. Ruby Version Manager Conflicts (Most Common Issue):
-   If you see errors like "Could not find 'bundler' (X.X.X)" or "Your Ruby version is X.X.X, but your Gemfile specified Y.Y.Y":
-   
-   This happens because Claude Desktop uses system Ruby instead of your project's Ruby version.
-   
-   Solution A - Use the wrapper script (Recommended):
-   In claude_desktop_config.json, use:
-   "command": "<%= Rails.root %>/bin/rails-active-mcp-wrapper"
-   
-   Solution B - Create system symlink:
-   $ sudo ln -sf $(which ruby) /usr/local/bin/ruby
-   
-   Solution C - Use absolute Ruby path:
-   In claude_desktop_config.json, change "command" to your full Ruby path:
-   "command": "$(which ruby)"
-   "args": ["<%= Rails.root %>/bin/rails-active-mcp-server", "stdio"]
-
-2. Environment Variable Issues:
-   If you see "error loading config: $HOME is not defined":
-   
-   This happens because Claude Desktop doesn't inherit all environment variables.
-   
-   Solution: Add HOME to your env section in claude_desktop_config.json:
-   "env": {
-     "RAILS_ENV": "development",
-     "HOME": "/Users/your-username"
-   }
+3. Restart Claude Desktop and start using the tools!
 
-3. General Environment Issues:
-   - Ensure your Rails environment loads properly in the project directory
-   - Check that the gem is properly installed and configured  
-   - Verify the Rails application starts without errors
-   - Make sure the cwd path in Claude Desktop config is correct
+⚙️ Configuration:
+Edit config/initializers/rails_active_mcp.rb to customize:
+- allowed_commands: Shell commands that can be executed
+- command_timeout: Execution timeout in seconds
+- enable_logging: Enable/disable logging
+- log_level: Logging verbosity (:debug, :info, :warn, :error)
 
-4. Debug Steps:
-   - Test manually: $ ./bin/rails-active-mcp-wrapper stdio
-   - Should output JSON (not plain text)
-   - Enable debug logging with RAILS_MCP_DEBUG=1 for detailed output
-   - Check Claude logs: $ tail -f ~/Library/Logs/Claude/mcp*.log
-   - Test environment variables: $ echo $HOME (should show your home directory)
+🔧 Troubleshooting:
+- Use the wrapper script to avoid Ruby version manager conflicts
+- Set RAILS_MCP_DEBUG=1 for verbose logging
+- Ensure Claude Desktop has correct paths and environment variables
 
-For more information: https://github.com/goodpie/rails-active-mcp
+📚 Documentation: https://github.com/goodpie/rails-active-mcp
 
 ================================================================================

data/lib/generators/rails_active_mcp/install/templates/initializer.rb

@@ -1,43 +1,42 @@
 require 'rails_active_mcp'
 
 RailsActiveMcp.configure do |config|
-  # Enable/disable the MCP server
-  config.enabled = true
-
-  # Safety configuration
-  config.safe_mode = Rails.env.production? # Always safe in production
-  config.default_timeout = 30 # seconds
-  config.max_results = 100
-
-  # Model access control
-  # config.allowed_models = %w[User Post Comment]  # Empty means all allowed
-  # config.blocked_models = %w[AdminUser Secret]   # Models to never allow access
-
-  # Mutation tools (dangerous operations)
-  config.enable_mutation_tools = !Rails.env.production?
-
-  # Logging and auditing
-  config.log_executions = true
-  config.audit_file = Rails.root.join('log', 'rails_active_mcp.log')
-
-  # Server configuration
-  config.server_mode = :stdio # :stdio for Claude Desktop, :http for web integrations
-  config.server_host = 'localhost'
-  config.server_port = 3001
-
-  # Environment-specific settings
-  case Rails.env
-  when 'production'
-    config.production_mode! # Very strict settings
-  when 'development'
-    config.permissive_mode! # More relaxed for development
-  when 'test'
-    config.strict_mode! # Safe for testing
+  # Core configuration options
+  config.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
+  ]
+
+  # Execution timeout in seconds
+  config.command_timeout = 30
+
+  # Logging configuration
+  config.enable_logging = true
+  config.log_level = :info # :debug, :info, :warn, :error
+
+  # Environment-specific adjustments
+  if Rails.env.production?
+    # More restrictive settings for production
+    config.log_level = :warn
+    config.command_timeout = 15
+  elsif Rails.env.development?
+    # More permissive settings for development
+    config.log_level = :debug
+    config.command_timeout = 60
   end
-
-  # Add custom safety patterns
-  # config.add_safety_pattern(/CustomDangerousMethod/, "Custom dangerous operation")
-
-  # Operations that require manual confirmation
-  config.require_confirmation_for = %i[delete destroy update_all delete_all]
 end
+
+# Rails Active MCP is now ready!
+#
+# Available MCP Tools:
+# - console_execute: Execute Ruby code with safety checks
+# - model_info: Get detailed information about Rails models
+# - safe_query: Execute safe read-only database queries
+# - dry_run: Analyze Ruby code for safety without execution
+#
+# To start the server:
+#   bin/rails-active-mcp-server
+#
+# For Claude Desktop integration, see the post-install instructions.

data/lib/generators/rails_active_mcp/install/templates/mcp.ru

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 
 require_relative 'config/environment'
-require 'rails_active_mcp'
+require 'rails_active_mcp/sdk/server'
 
-# Run the Rails Active MCP server
-run RailsActiveMcp::McpServer.new
+# Run the Rails Active MCP server using the official MCP Ruby SDK
+# Note: This file is primarily for reference. The recommended way to run
+# the server is using: bin/rails-active-mcp-server
+
+server = RailsActiveMcp::SDK::Server.new
+server.run

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