rails-active-mcp 0.1.6 → 2.0.7

data/exe/rails-active-mcp-server

@@ -1,86 +1,197 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'rack'
+# Require essential gems first
 require 'json'
 require 'stringio'
-require_relative '../lib/rails_active_mcp'
-
-# Parse command line options with config defaults
-default_mode = if defined?(RailsActiveMcp) && RailsActiveMcp.respond_to?(:config)
-                 RailsActiveMcp.config.server_mode.to_s
-               else
-                 'stdio'
-               end
-default_port = if defined?(RailsActiveMcp) && RailsActiveMcp.respond_to?(:config)
-                 RailsActiveMcp.config.server_port
-               else
-                 3001
-               end
-default_host = if defined?(RailsActiveMcp) && RailsActiveMcp.respond_to?(:config)
-                 RailsActiveMcp.config.server_host
-               else
-                 'localhost'
-               end
-
-transport = ARGV[0] || default_mode
-port = ARGV.include?('--port') ? ARGV[ARGV.index('--port') + 1].to_i : default_port
-host = ARGV.include?('--host') ? ARGV[ARGV.index('--host') + 1] : default_host
+
+# CRITICAL: Redirect stdout IMMEDIATELY for stdio mode to prevent any output interference
+# This must happen before any other gem loading
+original_stdout = $stdout
+original_stderr = $stderr
+
+# Determine if we should redirect output (stdio mode or explicit request)
+should_redirect = (ARGV.first == 'stdio' || ARGV.first.nil?) && !ENV['RAILS_MCP_DEBUG']
+
+if should_redirect
+  # Create log directory early
+  log_dir = File.join(Dir.pwd, 'log')
+  Dir.mkdir(log_dir) unless Dir.exist?(log_dir)
+
+  # Redirect stderr to log file immediately, before any loading
+  stderr_log = File.join(log_dir, 'rails_mcp_stderr.log')
+  $stderr.reopen(stderr_log, 'a')
+  $stderr.sync = true
+
+  # Use StringIO to capture any unwanted stdout during loading
+  # We'll filter out non-JSON content later
+  captured_stdout = StringIO.new
+  $stdout = captured_stdout
+end
+
+# Initialize Rails environment if available (from current working directory)
+rails_loaded = false
+rails_load_error = nil
+if File.exist?('config/environment.rb')
+  begin
+    require './config/environment'
+    rails_loaded = true
+
+    # Log successful Rails loading
+    warn "[#{Time.now}] [RAILS-MCP] INFO: Rails environment loaded successfully" if should_redirect
+  rescue StandardError => e
+    # Rails loading failed, continue without it
+    rails_load_error = e
+    # Log to stderr (which is already redirected if needed)
+    warn "[#{Time.now}] [RAILS-MCP] WARNING: Failed to load Rails environment: #{e.message}"
+    warn "[#{Time.now}] [RAILS-MCP] WARNING: #{e.backtrace.first(3).join("\n")}" if ENV['RAILS_MCP_DEBUG']
+  end
+elsif should_redirect
+  warn "[#{Time.now}] [RAILS-MCP] INFO: No Rails environment found (config/environment.rb missing)"
+end
+
+# Restore stdout after Rails loading for stdio mode (stderr stays redirected)
+if should_redirect
+  # Check if anything was captured during loading
+  captured_content = captured_stdout.string
+  unless captured_content.empty?
+    # Log any captured content to stderr for debugging
+    warn "[#{Time.now}] [RAILS-MCP] WARNING: Captured stdout during loading: #{captured_content.inspect}"
+    $stderr.flush
+  end
+
+  # Restore original stdout
+  $stdout = original_stdout
+end
+
+# Now load the gem
+begin
+  require_relative '../lib/rails_active_mcp'
+rescue LoadError => e
+  warn "[#{Time.now}] [RAILS-MCP] FATAL: Failed to load rails_active_mcp gem: #{e.message}"
+  exit(1)
+end
+
+# Parse command line options
+transport = ARGV[0] || 'stdio'
+port = ARGV.include?('--port') ? ARGV[ARGV.index('--port') + 1].to_i : 3001
+host = ARGV.include?('--host') ? ARGV[ARGV.index('--host') + 1] : 'localhost'
+
+# Determine and set correct working directory
+def find_rails_root(start_dir = Dir.pwd)
+  current_dir = start_dir
+
+  # Look for Gemfile and config/environment.rb up to 5 levels up
+  5.times do
+    gemfile_path = File.join(current_dir, 'Gemfile')
+    config_path = File.join(current_dir, 'config', 'environment.rb')
+
+    return current_dir if File.exist?(gemfile_path) && File.exist?(config_path)
+
+    parent_dir = File.dirname(current_dir)
+    break if parent_dir == current_dir # reached root
+
+    current_dir = parent_dir
+  end
+
+  nil
+end
+
+# Auto-detect Rails root and change directory if needed
+rails_root = find_rails_root
+if rails_root && rails_root != Dir.pwd
+  warn "[#{Time.now}] [RAILS-MCP] INFO: Detected Rails root at #{rails_root}, changing directory" if should_redirect
+  Dir.chdir(rails_root)
+elsif rails_root.nil?
+  # Check if we're in the gem directory and need to find a Rails app
+  if File.basename(Dir.pwd) == 'rails-active-mcp-gem' || Dir.pwd.include?('rails-active-mcp-gem')
+    warn "[#{Time.now}] [RAILS-MCP] ERROR: Running from gem directory, not Rails application directory"
+    warn "[#{Time.now}] [RAILS-MCP] ERROR: Please run the server from your Rails application root directory"
+    warn "[#{Time.now}] [RAILS-MCP] ERROR: Example: cd /path/to/your/rails/app && /path/to/rails-active-mcp-gem/exe/rails-active-mcp-server stdio"
+    exit(1)
+  end
+
+  # Final check for Gemfile in current directory
+  unless File.exist?('Gemfile')
+    warn "[#{Time.now}] [RAILS-MCP] ERROR: Could not locate Gemfile in current directory: #{Dir.pwd}"
+    warn "[#{Time.now}] [RAILS-MCP] ERROR: Please ensure you're running from a Rails application root directory"
+    warn "[#{Time.now}] [RAILS-MCP] ERROR: Current directory contents:"
+    Dir.entries('.').each { |entry| warn "[#{Time.now}] [RAILS-MCP] ERROR:   #{entry}" unless entry.start_with?('.') }
+    exit(1)
+  end
+end
+
+# Log the working directory for debugging
+warn "[#{Time.now}] [RAILS-MCP] INFO: Working directory: #{Dir.pwd}" if should_redirect
+warn "[#{Time.now}] [RAILS-MCP] INFO: Gemfile found: #{File.exist?('Gemfile')}" if should_redirect
 
 case transport
 when 'stdio'
-  # Stdio transport for Claude Desktop
-  require_relative '../lib/rails_active_mcp/stdio_server'
-
+  # Stdio transport for Claude Desktop using MCP SDK
   begin
-    # Initialize Rails environment if available (from current working directory)
-    if File.exist?('config/environment.rb')
-      # Suppress Rails output to avoid interfering with MCP JSON protocol
-      original_stdout = $stdout
-      $stdout = StringIO.new
-
-      begin
-        require './config/environment'
-      rescue StandardError => e
-        # Log to stderr but don't fail - the server can work without Rails
-        warn "Warning: Could not load Rails environment: #{e.message}"
-      ensure
-        $stdout = original_stdout
-      end
+    require_relative '../lib/rails_active_mcp/sdk/server'
+
+    # Log startup information
+    if should_redirect
+      warn "[#{Time.now}] [RAILS-MCP] INFO: Starting Rails Active MCP Server v#{RailsActiveMcp::VERSION}"
+    end
+    warn "[#{Time.now}] [RAILS-MCP] INFO: Rails loaded: #{rails_loaded}" if should_redirect
+    if rails_load_error && should_redirect
+      warn "[#{Time.now}] [RAILS-MCP] WARNING: Rails load error: #{rails_load_error.class.name}: #{rails_load_error.message}"
     end
 
-    stdio_server = RailsActiveMcp::StdioServer.new
-    stdio_server.run
+    server = RailsActiveMcp::Sdk::Server.new
+    server.run_stdio
   rescue Interrupt
+    warn "[#{Time.now}] [RAILS-MCP] INFO: Server interrupted by user" if should_redirect
     exit(0)
+  rescue LoadError => e
+    warn "[#{Time.now}] [RAILS-MCP] FATAL: MCP SDK not available: #{e.message}"
+    warn "[#{Time.now}] [RAILS-MCP] FATAL: Please install the MCP gem: gem install mcp"
+    exit(1)
+  rescue StandardError => e
+    warn "[#{Time.now}] [RAILS-MCP] FATAL: Server startup failed: #{e.message}"
+    warn "[#{Time.now}] [RAILS-MCP] FATAL: #{e.backtrace.join("\n")}" if ENV['RAILS_MCP_DEBUG']
+    exit(1)
   end
 
 when 'http'
-  # HTTP transport for other integrations
-  puts "Starting Rails Active MCP Server on #{host}:#{port}"
-  puts 'Press Ctrl+C to stop'
+  puts 'Error: HTTP transport is no longer supported in v2.0.0'
+  puts 'Please use stdio mode for MCP integration: rails-active-mcp-server stdio'
+  puts ''
+  puts 'For more information, see the migration guide in the documentation.'
+  exit(1)
 
-  begin
-    require 'webrick'
-    require 'rack/handler/webrick'
-
-    Rack::Handler::WEBrick.run(
-      RailsActiveMcp::McpServer.new,
-      Port: port,
-      Host: host,
-      Logger: WEBrick::Log.new(nil, WEBrick::BasicLog::WARN)
-    )
-  rescue LoadError => e
-    puts 'Error: WEBrick not available. Please install: gem install webrick'
-    puts 'Or use stdio mode for Claude Desktop: rails-active-mcp-server stdio'
-    exit(1)
-  rescue Interrupt
-    puts "\nShutting down server..."
-  end
+when '--help', '-h'
+  puts 'Rails Active MCP Server'
+  puts "Version: #{RailsActiveMcp::VERSION}"
+  puts ''
+  puts 'Usage: rails-active-mcp-server [stdio] [options]'
+  puts '  stdio: For MCP integration (default)'
+  puts ''
+  puts 'Options:'
+  puts '  --help, -h Show this help message'
+  puts ''
+  puts 'Environment variables:'
+  puts '  RAILS_MCP_DEBUG=1  Enable debug logging and disable output redirection'
+  puts ''
+  puts 'Examples:'
+  puts '  rails-active-mcp-server stdio                # Start in stdio mode'
+  puts '  RAILS_MCP_DEBUG=1 rails-active-mcp-server   # Start with debug logging'
+  puts ''
+  puts 'Note: HTTP transport was removed in v2.0.0. Use stdio mode for MCP integration.'
+  exit(0)
 
 else
-  puts 'Usage: rails-active-mcp-server [stdio|http] [--port PORT] [--host HOST]'
-  puts '  stdio: For Claude Desktop integration'
-  puts '  http:  For HTTP-based integrations (default)'
+  puts 'Usage: rails-active-mcp-server [stdio] [options]'
+  puts '  stdio: For MCP integration (default)'
+  puts ''
+  puts 'Options:'
+  puts '  --help, -h Show this help message'
+  puts ''
+  puts 'Environment variables:'
+  puts '  RAILS_MCP_DEBUG=1  Enable debug logging and disable output redirection'
+  puts ''
+  puts 'Note: HTTP transport was removed in v2.0.0. Use stdio mode for MCP integration.'
   exit(1)
 end

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

@@ -11,8 +11,81 @@ module RailsActiveMcp
         template 'initializer.rb', 'config/initializers/rails_active_mcp.rb'
       end
 
-      def create_mcp_route
-        route "mount RailsActiveMcp::McpServer.new, at: '/mcp' # Rails Active MCP"
+      def create_binstub
+        # Create binstub for easy server execution
+        create_file 'bin/rails-active-mcp-server', <<~RUBY
+          #!/usr/bin/env ruby
+
+          # Binstub for Rails Active MCP Server
+          # This ensures the server runs within the Rails project context
+
+          require 'bundler/setup'
+
+          # Set Rails environment
+          ENV['RAILS_ENV'] ||= 'development'
+
+          # Load Rails application first
+          require_relative '../config/environment'
+
+          # Now start the MCP server using the SDK implementation
+          require 'rails_active_mcp/sdk/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
+        say 'Created Rails binstub at bin/rails-active-mcp-server', :green
+
+        # Create environment-aware wrapper for Claude Desktop compatibility
+        ruby_path = `which ruby`.strip
+
+        create_file 'bin/rails-active-mcp-wrapper', <<~BASH
+          #!/usr/bin/env bash
+
+          # Rails Active MCP Wrapper Script
+          # Ensures correct Ruby environment for Claude Desktop execution
+
+          # Fix Claude Desktop environment isolation issues
+          export HOME="${HOME:-#{ENV['HOME']}}"
+          export USER="${USER:-$(whoami)}"
+
+          # Strategy 1: Use absolute Ruby path (most reliable)
+          RUBY_PATH="#{ruby_path}"
+
+          # Strategy 2: Try /usr/local/bin/ruby symlink as fallback
+          if [ ! -x "$RUBY_PATH" ]; then
+              RUBY_PATH="/usr/local/bin/ruby"
+          fi
+
+          # Strategy 3: Setup environment and use PATH resolution as last resort
+          if [ ! -x "$RUBY_PATH" ]; then
+              # Set up asdf environment if available
+              export ASDF_DIR="$HOME/.asdf"
+              if [ -f "$ASDF_DIR/asdf.sh" ]; then
+                  source "$ASDF_DIR/asdf.sh"
+              fi
+          #{'    '}
+              # Add version manager paths
+              export PATH="$HOME/.asdf/shims:$HOME/.rbenv/shims:$HOME/.rvm/bin:$PATH"
+              RUBY_PATH="ruby"
+          fi
+
+          # Change to the Rails project directory
+          cd "$(dirname "$0")/.."
+
+          # Execute with the determined Ruby path
+          exec "$RUBY_PATH" bin/rails-active-mcp-server "$@"
+        BASH
+
+        chmod 'bin/rails-active-mcp-wrapper', 0o755
+        say 'Created environment wrapper at bin/rails-active-mcp-wrapper', :green
       end
 
       def create_mcp_config
@@ -23,6 +96,53 @@ module RailsActiveMcp
         readme 'README.md' if behavior == :invoke
       end
 
+      def show_post_install_instructions
+        return unless behavior == :invoke
+
+        say "\n" + '=' * 50, :green
+        say 'Rails Active MCP Installation Complete!', :green
+        say '=' * 50, :green
+        say "\nFor Claude Desktop configuration:", :green
+        say 'Add this to your claude_desktop_config.json:', :yellow
+        say '', :green
+        say '{', :cyan
+        say '  "mcpServers": {', :cyan
+        say '    "rails-active-mcp": {', :cyan
+        say "      \"command\": \"#{Rails.root}/bin/rails-active-mcp-wrapper\",", :cyan
+        say "      \"cwd\": \"#{Rails.root}\",", :cyan
+        say '      "env": {', :cyan
+        say '        "RAILS_ENV": "development",', :cyan
+        say "        \"HOME\": \"#{ENV['HOME']}\"", :cyan
+        say '      }', :cyan
+        say '    }', :cyan
+        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
+        say '- Works reliably across different development setups', :yellow
+        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', :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
+        say '- Check README.md for more configuration options', :yellow
+        say "\nFor Ruby version manager users (asdf/rbenv/RVM):", :green
+        say 'If you encounter "bundler version" errors, create a system symlink:', :yellow
+        say "sudo ln -sf #{`which ruby`.strip} /usr/local/bin/ruby", :cyan
+        say '=' * 50, :green
+      end
+
       private
 
       def readme(path)
@@ -30,7 +150,7 @@ module RailsActiveMcp
         if File.exist?(readme_path)
           say IO.read(readme_path), :green
         else
-          say "README file not found at #{readme_path}", :yellow
+          say "README file not found at #{readme_path}", :green
         end
       rescue StandardError => e
         say "Error reading README: #{e.message}", :red

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

@@ -1,148 +1,54 @@
 ================================================================================
-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": "bundle",
-         "args": ["exec", "rails-active-mcp-server", "stdio"],
-         "cwd": "/path/to/your/rails/project"
+         "command": "/path/to/your/project/bin/rails-active-mcp-wrapper",
+         "cwd": "/path/to/your/project",
+         "env": {
+           "RAILS_ENV": "development",
+           "HOME": "/Users/your-username"
+         }
        }
      }
    }
 
-   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
+3. Restart Claude Desktop and start using the tools!
 
-View Claude Desktop logs:
-$ tail -f ~/Library/Logs/Claude/mcp*.log  # macOS
-$ tail -f ~/.config/claude-desktop/logs/*.log  # Linux
+⚙️ 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)
 
-Common 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
-- Enable debug logging with RAILS_MCP_DEBUG=1 for detailed output
+🔧 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.