grim-reaper 1.0.32 → 1.0.34

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad023d285c9eddc7d9830c5b42a5cffb63fa9bda24609aa457096e9fa8048a7a
-  data.tar.gz: ed148f4368b822553d9de0cf4cabf96422e9ed81cba3818231f1a5cbeefef1bf
+  metadata.gz: 3e995dc62a1b7e977043d7356552ca215771c85375621edaaf9b4ee9e62ccdc5
+  data.tar.gz: f01964b9bb32a4d6ca739e4f78ed9da9af81638832bd7967cadf441ae415e83b
 SHA512:
-  metadata.gz: 3c2be16ed625e568f46db78326a26f1a4e8947cf8b3e39555f53a3e76843cc88256464bb52a0cb9ab69f0fd3bfd6e00934cae0d9c2de0a50d7e2e63c0bb4a840
-  data.tar.gz: 8d31592c0c1457643655835ce2b02a198b5ecdf367a390f6aeaec17a8612aaea906f6ca5a8028019520f559889f0a5baf9140d97b6371196bc7c7b3d52e9b0d8
+  metadata.gz: 9ce86d8d9daee4c5aa4a70d04008bf2608840696b111227c7480535b25208f17766207bd0bf54576896df2ccbb00b9e202797d2ac251eb1267b8c2a6314aa18b
+  data.tar.gz: 74b57781c00e33a617a08b86a3a2c4dffd27b25d60fe9e443649711af5c36057b0090d9bcd5e1e45d06bd193cb28aee5355b40e336a12718c9a02c5326ed136f

data/README.md

@@ -8,12 +8,117 @@
 
 Enterprise-grade data protection platform with AI-powered backup decisions, military-grade encryption, multi-algorithm compression, content-based deduplication, real-time monitoring, and automated threat response.
 
+## 🚀 What's New in v1.0.34
+
+### 🆕 **Latest.tar.gz Auto-Download System**
+- **Direct Install**: Now downloads complete Grim system from `get.grim.so/latest.tar.gz`
+- **Smart Extraction**: Properly handles `graveyard/reaper/` structure with `--strip-components=2`
+- **Auto-Environment**: Automatically sets `GRIM_ROOT`, `GRIM_LICENSE=FREE`, `GRIM_REAPER=FALSE`
+- **Intelligent Paths**: Tries `/root/.grim`, `$HOME/.grim`, or local directory
+- **Executable Scripts**: Automatically makes all scripts executable
+- **Bashrc Integration**: Adds environment to `~/.bashrc` for persistence
+
+### 🏗️ **Professional Tier System (July 2025)**
+Complete overhaul of pricing structure with 6-tier system:
+
+- **🆓 FREE** ($0) - 1GB storage, 15 commands, encrypted auto-backups
+- **💼 BASIC** ($19) - 25GB cloud, 35 commands, removes encryption friction  
+- **🚀 PRO** ($49) - 100GB storage, 60 commands, AI-powered decisions
+- **⚔️ MASTER** ($99) - 1TB storage, 200+ commands, enterprise compliance
+- **💀 REAPER** ($499) - Unlimited storage, custom development, 24/7 support
+- **🏢 ENTERPRISE** (Custom) - Global deployment, source code access, strategic partnership
+
+### 🔧 **Critical Infrastructure Fixes (July 26-27, 2025)**
+- **SSL Certificate Crisis**: Fixed `up.grim.so` SSL mismatch (was `cyberboost.com`)
+- **Port Configuration**: Corrected auto-update service from `4745` → `5001`
+- **Auto-Update Daemon**: Restored background version checking for 5000+ installations
+- **Nginx Proxy**: Fixed proxy configuration for proper request routing
+- **Function Dependencies**: Resolved `log_update` function order bugs
+
+### 🔐 **Enhanced Security Features**
+- **OTP Authentication**: TOTP support with QR codes and backup codes
+- **Environment Protection**: Smart environment variable detection and setup
+- **Secure Downloads**: HTTPS-only downloads with SSL verification
+- **Permission Management**: Automatic executable permissions for all scripts
+
 ## 🚀 Quick Install
 
 ```bash
 gem install grim-reaper
 ```
 
+## 🎯 Quick Start Commands
+
+```bash
+# Download and install complete Grim system
+grim download-latest
+
+# Setup complete environment (Python, Go, Shell, Scythe)
+grim setup-complete
+
+# Check installation status
+grim check-installation
+
+# Health check all modules
+grim health
+```
+
+## 🔐 Enhanced OTP Authentication
+
+Enhanced security with One-Time Password (TOTP) authentication:
+
+```bash
+# Setup OTP authentication
+grim otp-setup
+
+# Use OTP with commands
+grim health --otp 123456
+grim setup-complete --otp 789012
+
+# Check OTP status
+grim otp-status
+
+# Verify OTP code
+grim otp-verify 123456
+```
+
+## 🎯 Ruby Integration
+
+```ruby
+require 'grim_reaper'
+
+# Initialize with auto-download
+grim = GrimReaper.new
+
+# Download latest if not installed
+installer = GrimReaper::Installer.new
+installer.download_latest_grim unless installer.find_grim_root
+
+# Quick operations
+grim.backup('/important/data')
+grim.monitor('/var/log')
+grim.security
+```
+
+## 📥 Installation Options
+
+### Option 1: Ruby Gem (Recommended)
+```bash
+gem install grim-reaper
+grim download-latest
+```
+
+### Option 2: Direct Download
+```bash
+curl -sSL get.grim.so | sudo bash
+```
+
+### Option 3: Manual Setup
+```bash
+gem install grim-reaper
+grim setup-complete
+```
+
 ## 🎯 Quick Start
 
 ```ruby

data/bin/grim

@@ -12,6 +12,7 @@ class GrimCLI < Thor
   class_option :config, type: :string, default: "grim.yml", desc: "Configuration file path"
   class_option :verbose, type: :boolean, default: false, desc: "Enable verbose output"
   class_option :json, type: :boolean, default: false, desc: "Output in JSON format"
+  class_option :otp, type: :string, desc: "One-Time Password for secure authentication"
   
   desc "version", "Show Grim Reaper version"
   def version
@@ -19,23 +20,173 @@ class GrimCLI < Thor
     puts "The Ultimate Backup, Monitoring, and Security System"
     puts "By Bernie Gengel and his beagle Buddy"
   end
+
+  desc "otp-setup", "Setup OTP authentication for Grim Reaper"
+  def otp_setup
+    puts "🔐 Setting up OTP authentication...".colorize(:cyan)
+    
+    begin
+      grim = GrimReaper::Core.new(load_config)
+      otp_module = grim.get_otp_module
+      
+      if otp_module.setup_otp
+        puts "✅ OTP authentication setup complete!".colorize(:green)
+        puts "📱 Scan the QR code with your authenticator app".colorize(:blue)
+        puts "🔑 Save your backup codes in a secure location".colorize(:yellow)
+      else
+        puts "❌ OTP setup failed".colorize(:red)
+        exit 1
+      end
+    rescue => e
+      puts "❌ OTP setup failed: #{e.message}".colorize(:red)
+      exit 1
+    end
+  end
+
+  desc "otp-verify CODE", "Verify OTP code"
+  def otp_verify(code)
+    puts "🔓 Verifying OTP code...".colorize(:cyan)
+    
+    begin
+      grim = GrimReaper::Core.new(load_config)
+      otp_module = grim.get_otp_module
+      
+      if otp_module.verify_otp(code)
+        puts "✅ OTP verification successful!".colorize(:green)
+      else
+        puts "❌ Invalid OTP code".colorize(:red)
+        exit 1
+      end
+    rescue => e
+      puts "❌ OTP verification failed: #{e.message}".colorize(:red)
+      exit 1
+    end
+  end
+
+  desc "otp-status", "Check OTP authentication status"
+  def otp_status
+    puts "📊 Checking OTP status...".colorize(:cyan)
+    
+    begin
+      grim = GrimReaper::Core.new(load_config)
+      otp_module = grim.get_otp_module
+      status = otp_module.status
+      
+      if options[:json]
+        puts JSON.pretty_generate(status)
+      else
+        puts "OTP Status: #{status[:enabled] ? 'Enabled'.colorize(:green) : 'Disabled'.colorize(:red)}"
+        puts "Last Authentication: #{status[:last_auth] || 'Never'}"
+        puts "Failed Attempts: #{status[:failed_attempts] || 0}"
+      end
+    rescue => e
+      puts "❌ Status check failed: #{e.message}".colorize(:red)
+    end
+  end
   
   desc "setup-complete", "Setup complete Grim Reaper environment (installs Python, Go, Shell, Scythe components)"
   def setup_complete
+    if options[:otp] && !validate_otp_access
+      return
+    end
+    
     puts "🗡️  Setting up complete Grim Reaper environment...".colorize(:cyan)
     
     begin
       installer = GrimReaper::Installer.new
-      installer.setup_complete_environment
-      puts "✅ Complete Grim Reaper environment setup finished!".colorize(:green)
+      if installer.setup_complete_environment
+        puts "✅ Complete Grim Reaper environment setup finished!".colorize(:green)
+        puts "📁 Installation directory: #{ENV['GRIM_ROOT']}".colorize(:blue)
+        puts "🔧 Run 'source ~/.bashrc' to reload environment".colorize(:yellow)
+      else
+        puts "❌ Setup failed".colorize(:red)
+        exit 1
+      end
     rescue => e
       puts "❌ Setup failed: #{e.message}".colorize(:red)
       exit 1
     end
   end
+
+  desc "download-latest", "Download and install latest Grim Reaper from get.grim.so"
+  def download_latest
+    if options[:otp] && !validate_otp_access
+      return
+    end
+    
+    puts "📥 Downloading latest Grim Reaper...".colorize(:cyan)
+    
+    begin
+      installer = GrimReaper::Installer.new
+      if installer.download_latest_grim
+        puts "✅ Download and installation complete!".colorize(:green)
+        puts "📁 Installation directory: #{ENV['GRIM_ROOT']}".colorize(:blue)
+        puts "🔧 Run 'source ~/.bashrc' to reload environment".colorize(:yellow)
+        puts ""
+        puts "Available commands:".colorize(:blue)
+        puts "  grim backup <path>    - Create backup"
+        puts "  grim monitor <path>   - Start monitoring"
+        puts "  grim security         - Security status"
+        puts "  grim rb-setup         - Setup Ruby environment"
+      else
+        puts "❌ Download failed".colorize(:red)
+        exit 1
+      end
+    rescue => e
+      puts "❌ Download failed: #{e.message}".colorize(:red)
+      exit 1
+    end
+  end
+
+  desc "check-installation", "Check if Grim Reaper is properly installed"
+  def check_installation
+    puts "🔍 Checking Grim Reaper installation...".colorize(:cyan)
+    
+    begin
+      installer = GrimReaper::Installer.new
+      grim_root = ENV["GRIM_ROOT"]
+      
+      if grim_root && Dir.exist?(grim_root)
+        puts "✅ GRIM_ROOT found: #{grim_root}".colorize(:green)
+        
+        # Check key components
+        components = [
+          "throne/grim_throne.sh",
+          "install.sh",
+          ".rip"
+        ]
+        
+        components.each do |component|
+          path = File.join(grim_root, component)
+          if File.exist?(path)
+            puts "✅ #{component}".colorize(:green)
+          else
+            puts "❌ #{component} - Missing".colorize(:red)
+          end
+        end
+        
+        puts ""
+        puts "Environment Variables:".colorize(:blue)
+        puts "  GRIM_ROOT=#{ENV['GRIM_ROOT']}".colorize(:blue)
+        puts "  GRIM_LICENSE=#{ENV['GRIM_LICENSE']}".colorize(:blue)
+        puts "  GRIM_REAPER=#{ENV['GRIM_REAPER']}".colorize(:blue)
+        
+      else
+        puts "❌ Grim Reaper not installed".colorize(:red)
+        puts "💡 Run 'grim download-latest' to install".colorize(:yellow)
+      end
+      
+    rescue => e
+      puts "❌ Check failed: #{e.message}".colorize(:red)
+    end
+  end
   
   desc "health", "Check health of all Grim Reaper modules"
   def health
+    if options[:otp] && !validate_otp_access
+      return
+    end
+    
     puts "🏥 Checking Grim Reaper health...".colorize(:cyan)
     
     begin
@@ -48,19 +199,19 @@ class GrimCLI < Thor
         puts "Grim Reaper Health Status:".colorize(:cyan)
         all_healthy = true
         
-        status_data.each do |module_name, data|
-          if data[:status] == 'ready' || data[:status] == 'healthy'
-            puts "  ✅ #{module_name}: #{data[:status]}".colorize(:green)
-          else
-            puts "  ❌ #{module_name}: #{data[:status]}".colorize(:red)
+        status_data.each do |module_name, result|
+          if result.is_a?(Hash) && result[:error]
+            puts "  #{module_name}: ❌ #{result[:error]}".colorize(:red)
             all_healthy = false
+          else
+            puts "  #{module_name}: ✅ Healthy".colorize(:green)
           end
         end
         
         if all_healthy
-          puts "\n🎉 All modules are healthy!".colorize(:green)
+          puts "\n🎉 All modules healthy!".colorize(:green)
         else
-          puts "\n⚠️  Some modules have issues.".colorize(:yellow)
+          puts "\n⚠️  Some modules need attention".colorize(:yellow)
         end
       end
     rescue => e
@@ -309,6 +460,11 @@ class GrimCLI < Thor
     puts "  install              Install dependencies"
     puts "  update               Update all modules"
     puts ""
+    puts "🔐 OTP Security Commands:"
+    puts "  otp-setup            Setup OTP authentication"
+    puts "  otp-verify CODE      Verify OTP code"
+    puts "  otp-status           Check OTP authentication status"
+    puts ""
     puts "💎 Ruby-Specific Commands:"
     puts "  rb-setup             Setup Ruby environment"
     puts "  rb-analyze PATH      Analyze Ruby code quality"
@@ -324,29 +480,17 @@ class GrimCLI < Thor
     puts "  --config FILE        Configuration file path (default: grim.yml)"
     puts "  --verbose            Enable verbose output"
     puts "  --json               Output in JSON format"
+    puts "  --otp CODE           One-Time Password for secure authentication"
     puts ""
-    puts "Examples:"
-    puts "  grim setup-complete  # Install all Grim Reaper components"
-    puts "  grim health          # Check health of all modules"
-    puts "  grim rb-setup        # Setup Ruby environment"
-    puts "  grim rb-analyze /app # Analyze Ruby code"
-    puts "  grim status"
-    puts "  grim backup /home/user"
-    puts "  grim deploy production --verbose"
-    puts "  grim execute 'ls -la' --json"
+    puts "🔐 Security Features:"
+    puts "  • Two-Factor Authentication (TOTP)"
+    puts "  • Backup codes for recovery"
+    puts "  • Secure command execution"
+    puts "  • Authentication tracking"
     puts ""
-    puts "🚀 Full Grim Reaper CLI Features:"
-    puts "  • 50+ backup commands (backup-create, backup-verify, etc.)"
-    puts "  • 30+ monitoring commands (monitor-start, monitor-events, etc.)"
-    puts "  • 20+ security commands (security-audit, quarantine-isolate, etc.)"
-    puts "  • 15+ AI/ML commands (ai-analyze, ai-train, ai-predict, etc.)"
-    puts "  • 10+ optimization commands (optimize-all, heal, etc.)"
-    puts "  • License protection system"
-    puts "  • Emergency commands"
-    puts "  • Web interface and admin server"
-    puts ""
-    puts "💡 For the complete Grim Reaper experience, visit: https://get.grim.so"
-    puts "📦 Or run: curl -sSL https://get.grim.so | bash"
+    puts "📖 Documentation: https://grim.so/docs"
+    puts "🌐 Full Installation: https://get.grim.so"
+    puts "💎 Gem Page: https://rubygems.org/gems/grim-reaper"
   end
   
   private
@@ -362,10 +506,81 @@ class GrimCLI < Thor
       {}
     end
   end
-  
-  def redirect_to_grim_so(command)
-    puts "\n💡 Command '#{command}' not available in this installation.".colorize(:yellow)
-    puts "🌐 Visit https://get.grim.so to install the full Grim Reaper CLI".colorize(:cyan)
+
+  private
+
+  def load_config
+    config_file = options[:config]
+    return {} unless File.exist?(config_file)
+    
+    case File.extname(config_file)
+    when '.yml', '.yaml'
+      YAML.load_file(config_file) || {}
+    when '.json'
+      JSON.parse(File.read(config_file))
+    else
+      {}
+    end
+  rescue => e
+    warn "Warning: Could not load config file #{config_file}: #{e.message}"
+    {}
+  end
+
+  def validate_otp_access
+    return true unless options[:otp]
+    
+    begin
+      grim = GrimReaper::Core.new(load_config)
+      otp_module = grim.get_otp_module
+      
+      if otp_module.verify_otp(options[:otp])
+        puts "✅ OTP authentication successful".colorize(:green)
+        return true
+      else
+        puts "❌ Invalid OTP code".colorize(:red)
+        exit 1
+      end
+    rescue => e
+      puts "❌ OTP verification failed: #{e.message}".colorize(:red)
+      exit 1
+    end
+  end
+
+  def execute(command, *args)
+    begin
+      grim = GrimReaper::Core.new(load_config)
+      result = grim.execute(command, *args)
+      
+      if options[:json]
+        puts JSON.pretty_generate(result)
+      else
+        result.each do |module_name, data|
+          if data.is_a?(Hash) && data[:error]
+            puts "  #{module_name}: ❌ #{data[:error]}".colorize(:red)
+          else
+            puts "  #{module_name}: ✅ #{data}".colorize(:green)
+          end
+        end
+      end
+    rescue => e
+      puts "❌ Command failed: #{e.message}".colorize(:red)
+      exit 1
+    end
+  end
+
+     def redirect_to_grim_so(command)
+     puts "\n🌐 This command is not available in the Ruby gem.".colorize(:yellow)
+     puts "For the complete Grim Reaper ecosystem with all commands, visit:".colorize(:blue)
+     puts "  🔗 https://get.grim.so - Complete installation".colorize(:cyan)
+     puts "  📚 https://grim.so/docs - Documentation".colorize(:cyan)
+     puts "  💎 gem install grim-reaper - Ruby gem".colorize(:cyan)
+     puts "\nThe Ruby gem provides Ruby-specific commands and interfaces to other modules."
+     puts "For command '#{command}', you'll need the full Grim Reaper installation."
+   end
+end
+
+# Start the CLI if this file is executed directly
+GrimCLI.start(ARGV) if __FILE__ == $0
     puts "📦 Or run: curl -sSL https://get.grim.so | bash".colorize(:cyan)
     puts ""
     puts "Available commands in this installation:".colorize(:green)

data/lib/grim_reaper/core.rb

@@ -62,10 +62,24 @@ module GrimReaper
       @modules[:python] = PythonModule.new(@config, @grim_root)
       @modules[:go] = GoModule.new(@config, @grim_root)
       @modules[:security] = SecurityModule.new(@config, @grim_root)
+      @modules[:otp] = OtpModule.new(@config, @grim_root)
     rescue LoadError => e
       warn "Warning: Could not load module: #{e.message}"
     end
 
+    # Get OTP module instance
+    def get_otp_module
+      @modules[:otp] || OtpModule.new(@config, @grim_root)
+    end
+
+    # Validate OTP access if provided
+    def validate_otp_access(otp_code)
+      return true unless otp_code
+      
+      otp_module = get_otp_module
+      return otp_module.verify_otp(otp_code)
+    end
+
     # Execute a command across all modules
     def execute(command, *args)
       results = {}

data/lib/grim_reaper/installer.rb

@@ -2,6 +2,8 @@
 
 require "open3"
 require "fileutils"
+require "net/http"
+require "uri"
 
 module GrimReaper
   # Ruby-specific installer and dependency manager
@@ -12,6 +14,152 @@ module GrimReaper
       @grim_root = find_grim_root
       @backup_dir = ENV["HOME"] + "/.graveyard"
       @install_dir = ENV["HOME"] + "/reaper"
+      setup_environment_variables
+    end
+
+    # Setup environment variables
+    def setup_environment_variables
+      # Set GRIM_ROOT if not already set
+      unless ENV["GRIM_ROOT"]
+        if File.writable?("/root/")
+          ENV["GRIM_ROOT"] = "/root/.grim"
+        elsif File.writable?(ENV["HOME"])
+          ENV["GRIM_ROOT"] = ENV["HOME"] + "/.grim"
+        else
+          ENV["GRIM_ROOT"] = Dir.pwd + "/.grim"
+        end
+      end
+      
+      # Set default license tier to FREE
+      ENV["GRIM_LICENSE"] ||= "FREE"
+      
+      # Set GRIM_REAPER to FALSE for normal install
+      ENV["GRIM_REAPER"] ||= "FALSE"
+      
+      puts "🗡️  Grim environment configured:"
+      puts "   GRIM_ROOT=#{ENV['GRIM_ROOT']}"
+      puts "   GRIM_LICENSE=#{ENV['GRIM_LICENSE']}"
+      puts "   GRIM_REAPER=#{ENV['GRIM_REAPER']}"
+    end
+
+    # Download and install latest Grim Reaper from get.grim.so
+    def download_latest_grim
+      puts "📥 Downloading latest Grim Reaper from get.grim.so..."
+      
+      install_dir = ENV["GRIM_ROOT"] || (ENV["HOME"] + "/.grim")
+      FileUtils.mkdir_p(install_dir)
+      
+      temp_file = File.join(install_dir, "grim-latest.tar.gz")
+      
+      begin
+        # Download latest.tar.gz
+        uri = URI("https://get.grim.so/latest.tar.gz")
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          request = Net::HTTP::Get.new(uri)
+          response = http.request(request)
+          
+          if response.code == "200"
+            File.open(temp_file, "wb") { |file| file.write(response.body) }
+            puts "✅ Download complete"
+          else
+            raise "Failed to download: HTTP #{response.code}"
+          end
+        end
+        
+        # Extract with proper graveyard/reaper/ handling (strip 2 components)
+        puts "📦 Extracting Grim Reaper..."
+        success = system("tar", "-xzf", temp_file, "--strip-components=2", "-C", install_dir)
+        
+        unless success
+          raise "Failed to extract tarball"
+        end
+        
+        # Remove temp file
+        File.delete(temp_file) if File.exist?(temp_file)
+        
+        # Make scripts executable
+        make_scripts_executable(install_dir)
+        
+        # Setup environment file
+        setup_environment_file(install_dir)
+        
+        puts "✅ Grim Reaper installation complete!"
+        puts "📁 Installed to: #{install_dir}"
+        
+        return true
+        
+      rescue => e
+        puts "❌ Download failed: #{e.message}"
+        File.delete(temp_file) if File.exist?(temp_file)
+        return false
+      end
+    end
+
+    # Make scripts executable
+    def make_scripts_executable(install_dir)
+      puts "🔧 Making scripts executable..."
+      
+      scripts = [
+        "throne/grim_throne.sh",
+        "throne/sh_grim_throne.sh", 
+        "throne/py_grim_throne.sh",
+        "throne/rb_grim_throne.sh",
+        "throne/go_grim_throne.sh",
+        "install.sh",
+        "master-install.sh",
+        "sh_grim/*.sh",
+        "py_grim/*.py",
+        "go_grim/build/*",
+        ".rip/*.sh",
+        "auto_backups/*.sh"
+      ]
+      
+      scripts.each do |script_pattern|
+        Dir.glob(File.join(install_dir, script_pattern)).each do |script|
+          begin
+            File.chmod(0755, script)
+          rescue => e
+            puts "⚠️  Could not make #{script} executable: #{e.message}"
+          end
+        end
+      end
+    end
+
+    # Setup environment file for persistence
+    def setup_environment_file(install_dir)
+      puts "📝 Setting up environment file..."
+      
+      env_file = File.join(install_dir, ".grim_env")
+      
+      env_content = <<~ENV
+        # Grim Reaper Environment Configuration
+        export GRIM_ROOT="#{ENV['GRIM_ROOT']}"
+        export GRIM_LICENSE="#{ENV['GRIM_LICENSE']}"
+        export GRIM_REAPER="#{ENV['GRIM_REAPER']}"
+        export PATH="$PATH:#{install_dir}/throne:#{install_dir}/sh_grim:#{install_dir}/py_grim"
+        
+        # Load Grim functions
+        if [ -f "#{install_dir}/throne/grim_throne.sh" ]; then
+          source "#{install_dir}/throne/grim_throne.sh"
+        fi
+      ENV
+      
+      File.write(env_file, env_content)
+      
+      # Add to bashrc if possible
+      bashrc_path = ENV["HOME"] + "/.bashrc"
+      if File.exist?(bashrc_path) && File.writable?(bashrc_path)
+        source_line = "[ -f #{env_file} ] && source #{env_file}"
+        bashrc_content = File.read(bashrc_path)
+        
+        unless bashrc_content.include?(source_line)
+          File.open(bashrc_path, "a") do |f|
+            f.puts "\n# Grim Reaper Environment"
+            f.puts source_line
+          end
+          puts "✅ Added Grim environment to ~/.bashrc"
+        end
+      end
     end
 
     # Find Grim Reaper root directory
@@ -54,10 +202,16 @@ module GrimReaper
       raise Error, "Could not find Grim Reaper root directory"
     end
 
-    # Setup complete Grim Reaper environment (like npm/pip packages)
+    # Setup complete Grim Reaper environment (installs Python, Go, Shell, Scythe components)
     def setup_complete_environment
       puts "🗡️  Setting up complete Grim Reaper environment..."
       
+      # First download the latest version
+      unless download_latest_grim
+        puts "❌ Failed to download Grim Reaper"
+        return false
+      end
+      
       # Setup Ruby environment
       setup_ruby_environment
       
@@ -76,10 +230,8 @@ module GrimReaper
       # Create necessary directories
       create_directories
       
-      # Setup environment file
-      setup_environment_file
-      
       puts "✅ Complete Grim Reaper environment setup finished"
+      return true
     end
 
     # Setup Ruby environment
@@ -400,25 +552,6 @@ module GrimReaper
       end
     end
 
-    # Setup environment file
-    def setup_environment_file
-      env_file = File.join(@grim_root, ".env")
-      scythe_dir = File.join(@grim_root, ".graveyard", ".rip", ".scythe")
-      env_content = <<~ENV
-        # Grim Reaper Environment Configuration
-        GRIM_ROOT=#{@grim_root}
-        SCYTHE_DIR=#{scythe_dir}
-        GRIM_BACKUP_DIR=#{@backup_dir}
-        GRIM_HOME=#{@install_dir}
-        GRIM_RUBY_VERSION=#{`ruby -e "puts RUBY_VERSION"`.strip}
-        GRIM_PYTHON_VERSION=#{`python3 --version 2>/dev/null | cut -d' ' -f2` || 'Not installed'}
-        GRIM_GO_VERSION=#{`go version 2>/dev/null | cut -d' ' -f3` || 'Not installed'}
-      ENV
-
-      File.write(env_file, env_content)
-      puts "📄 Created environment file: #{env_file}"
-    end
-
     # Verify installation
     def verify_installation
       puts "🔍 Verifying installation..."

data/lib/grim_reaper/otp_module.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "base64"
+require "uri"
+require "json"
+require "fileutils"
+
+module GrimReaper
+  # OTP (One-Time Password) authentication module
+  class OtpModule
+    attr_reader :config, :grim_root, :secret_file, :config_file
+
+    def initialize(config = {}, grim_root = nil)
+      @config = config
+      @grim_root = grim_root || Dir.pwd
+      @secret_file = File.join(@grim_root, ".grim_otp_secret")
+      @config_file = File.join(@grim_root, ".grim_otp_config")
+    end
+
+    # Setup OTP authentication
+    def setup_otp
+      secret = generate_secret
+      
+      # Save secret securely
+      File.write(@secret_file, secret)
+      File.chmod(0o600, @secret_file)
+      
+      # Generate QR code URL
+      qr_url = generate_qr_url(secret)
+      
+      # Generate backup codes
+      backup_codes = generate_backup_codes
+      
+      # Save configuration
+      otp_config = {
+        enabled: true,
+        created_at: Time.now.iso8601,
+        backup_codes: backup_codes.map { |code| { code: code, used: false } },
+        failed_attempts: 0,
+        last_auth: nil
+      }
+      
+      File.write(@config_file, JSON.pretty_generate(otp_config))
+      File.chmod(0o600, @config_file)
+      
+      puts "🔑 OTP Secret: #{secret}".colorize(:green)
+      puts "📱 QR Code URL: #{qr_url}".colorize(:blue)
+      puts "💾 Backup Codes:".colorize(:yellow)
+      backup_codes.each_with_index do |code, index|
+        puts "   #{index + 1}. #{code}".colorize(:cyan)
+      end
+      puts "⚠️  Save these backup codes in a secure location!".colorize(:red)
+      
+      true
+    rescue => e
+      puts "Error setting up OTP: #{e.message}".colorize(:red)
+      false
+    end
+
+    # Verify OTP code
+    def verify_otp(code)
+      return false unless otp_enabled?
+      
+      config_data = load_config
+      secret = load_secret
+      
+      # Check if it's a backup code
+      if verify_backup_code(code, config_data)
+        mark_backup_code_used(code, config_data)
+        update_last_auth(config_data)
+        return true
+      end
+      
+      # Verify TOTP code
+      current_time = Time.now.to_i / 30
+      
+      # Check current and previous time windows (to handle clock skew)
+      [-1, 0, 1].each do |offset|
+        if generate_totp(secret, current_time + offset) == code.to_s.rjust(6, '0')
+          update_last_auth(config_data)
+          reset_failed_attempts(config_data)
+          return true
+        end
+      end
+      
+      # Increment failed attempts
+      increment_failed_attempts(config_data)
+      false
+    rescue => e
+      puts "Error verifying OTP: #{e.message}".colorize(:red)
+      false
+    end
+
+    # Check OTP status
+    def status
+      if otp_enabled?
+        config_data = load_config
+        {
+          enabled: true,
+          last_auth: config_data['last_auth'],
+          failed_attempts: config_data['failed_attempts'] || 0,
+          backup_codes_remaining: count_unused_backup_codes(config_data)
+        }
+      else
+        {
+          enabled: false,
+          last_auth: nil,
+          failed_attempts: 0,
+          backup_codes_remaining: 0
+        }
+      end
+    rescue => e
+      { error: e.message }
+    end
+
+    # Execute OTP-related commands
+    def execute(command, *args)
+      case command
+      when 'setup'
+        setup_otp
+      when 'verify'
+        verify_otp(args.first)
+      when 'status'
+        status
+      when 'disable'
+        disable_otp
+      when 'regenerate-backup-codes'
+        regenerate_backup_codes
+      else
+        { error: "Unknown OTP command: #{command}" }
+      end
+    end
+
+    # Disable OTP authentication
+    def disable_otp
+      File.delete(@secret_file) if File.exist?(@secret_file)
+      File.delete(@config_file) if File.exist?(@config_file)
+      puts "🔓 OTP authentication disabled".colorize(:yellow)
+      true
+    rescue => e
+      puts "Error disabling OTP: #{e.message}".colorize(:red)
+      false
+    end
+
+    # Regenerate backup codes
+    def regenerate_backup_codes
+      return false unless otp_enabled?
+      
+      config_data = load_config
+      backup_codes = generate_backup_codes
+      
+      config_data['backup_codes'] = backup_codes.map { |code| { code: code, used: false } }
+      
+      File.write(@config_file, JSON.pretty_generate(config_data))
+      
+      puts "💾 New Backup Codes:".colorize(:yellow)
+      backup_codes.each_with_index do |code, index|
+        puts "   #{index + 1}. #{code}".colorize(:cyan)
+      end
+      
+      true
+    rescue => e
+      puts "Error regenerating backup codes: #{e.message}".colorize(:red)
+      false
+    end
+
+    private
+
+    # Check if OTP is enabled
+    def otp_enabled?
+      File.exist?(@secret_file) && File.exist?(@config_file)
+    end
+
+    # Load OTP configuration
+    def load_config
+      return {} unless File.exist?(@config_file)
+      JSON.parse(File.read(@config_file))
+    rescue JSON::ParserError
+      {}
+    end
+
+    # Load OTP secret
+    def load_secret
+      return nil unless File.exist?(@secret_file)
+      File.read(@secret_file).strip
+    end
+
+    # Generate a random secret for TOTP
+    def generate_secret
+      Base64.encode64(OpenSSL::Random.random_bytes(20)).gsub(/\W/, '')[0, 32]
+    end
+
+    # Generate TOTP code
+    def generate_totp(secret, time_counter)
+      # Convert secret from base64
+      key = Base64.decode64(secret)
+      
+      # Create HMAC-SHA1
+      time_bytes = [time_counter].pack('Q>')
+      hmac = OpenSSL::HMAC.digest('sha1', key, time_bytes)
+      
+      # Dynamic truncation
+      offset = hmac[-1].ord & 0x0f
+      code = hmac[offset, 4].unpack('N').first & 0x7fffffff
+      
+      # Return 6-digit code
+      sprintf('%06d', code % 1000000)
+    end
+
+    # Generate QR code URL for authenticator apps
+    def generate_qr_url(secret)
+      account = "grim-reaper@#{Socket.gethostname}"
+      issuer = "Grim Reaper"
+      
+      params = {
+        secret: secret,
+        issuer: issuer,
+        algorithm: 'SHA1',
+        digits: 6,
+        period: 30
+      }
+      
+      query_string = URI.encode_www_form(params)
+      "otpauth://totp/#{URI.encode_www_form_component(account)}?#{query_string}"
+    end
+
+    # Generate backup codes
+    def generate_backup_codes(count = 10)
+      Array.new(count) do
+        # Generate 8-character alphanumeric codes
+        Array.new(8) { [*'0'..'9', *'A'..'Z'].sample }.join
+      end
+    end
+
+    # Verify backup code
+    def verify_backup_code(code, config_data)
+      backup_codes = config_data['backup_codes'] || []
+      backup_codes.any? { |bc| bc['code'] == code.upcase && !bc['used'] }
+    end
+
+    # Mark backup code as used
+    def mark_backup_code_used(code, config_data)
+      backup_codes = config_data['backup_codes'] || []
+      backup_code = backup_codes.find { |bc| bc['code'] == code.upcase }
+      backup_code['used'] = true if backup_code
+      
+      File.write(@config_file, JSON.pretty_generate(config_data))
+    end
+
+    # Count unused backup codes
+    def count_unused_backup_codes(config_data)
+      backup_codes = config_data['backup_codes'] || []
+      backup_codes.count { |bc| !bc['used'] }
+    end
+
+    # Update last authentication time
+    def update_last_auth(config_data)
+      config_data['last_auth'] = Time.now.iso8601
+      File.write(@config_file, JSON.pretty_generate(config_data))
+    end
+
+    # Reset failed attempts counter
+    def reset_failed_attempts(config_data)
+      config_data['failed_attempts'] = 0
+      File.write(@config_file, JSON.pretty_generate(config_data))
+    end
+
+    # Increment failed attempts counter
+    def increment_failed_attempts(config_data)
+      config_data['failed_attempts'] = (config_data['failed_attempts'] || 0) + 1
+      File.write(@config_file, JSON.pretty_generate(config_data))
+    end
+  end
+end 

data/lib/grim_reaper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GrimReaper
-  VERSION = "1.0.32"
+  VERSION = "1.0.34"
 end 

data/lib/grim_reaper.rb

@@ -6,6 +6,7 @@ require_relative "grim_reaper/shell_module"
 require_relative "grim_reaper/python_module"
 require_relative "grim_reaper/go_module"
 require_relative "grim_reaper/security_module"
+require_relative "grim_reaper/otp_module"
 require_relative "grim_reaper/installer"
 
 # Grim Reaper - The Ultimate Backup, Monitoring, and Security System
@@ -38,4 +39,12 @@ module GrimReaper
   def self.security
     Core.new.execute('security')
   end
+
+  def self.setup_otp
+    Core.new.get_otp_module.setup_otp
+  end
+
+  def self.verify_otp(code)
+    Core.new.get_otp_module.verify_otp(code)
+  end
 end 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grim-reaper
 version: !ruby/object:Gem::Version
-  version: 1.0.32
+  version: 1.0.34
 platform: ruby
 authors:
 - Bernie Gengel and his beagle Buddy
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-26 00:00:00.000000000 Z
+date: 2025-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -181,8 +181,8 @@ dependencies:
 description: When data death comes knocking, Grim ensures resurrection is just a command
   away. License management, auto backups, highly compressed backups, multi-algorithm
   compression, content-based deduplication, smart storage tiering save up to 60% space,
-  military-grade encryption, license protection, security surveillance, and automated
-  threat response.
+  military-grade encryption, license protection, security surveillance, OTP authentication,
+  and automated threat response.
 email:
 - rip@grim.so
 executables:
@@ -206,6 +206,7 @@ files:
 - lib/grim_reaper/core.rb
 - lib/grim_reaper/go_module.rb
 - lib/grim_reaper/installer.rb
+- lib/grim_reaper/otp_module.rb
 - lib/grim_reaper/python_module.rb
 - lib/grim_reaper/security_module.rb
 - lib/grim_reaper/shell_module.rb
@@ -219,13 +220,17 @@ metadata:
   source_code_uri: https://github.com/cyber-boost/grim
   changelog_uri: https://github.com/cyber-boost/grim/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message: "\U0001F5E1️  Grim Reaper Ruby Gem v1.0.32 installed successfully!\n\nThe
-  gem provides a unified interface to all Grim Reaper modules:\n- Python components
-  (scythe, py_grim)\n- Go components (go_grim)\n- Shell components (sh_grim)\n- Ruby
-  components (rb_grim)\n\nRun 'grim rb-setup' to configure your environment and install
-  all components.\nRun 'grim help' to see all available commands.\n\nFor automatic
-  installation of all Grim Reaper components, run:\ngrim setup-complete\n\n\U0001F4A1
-  For missing commands, visit: https://get.grim.so\n"
+post_install_message: "\U0001F5E1️  Grim Reaper Ruby Gem v1.0.34 installed successfully!\n\n\U0001F195
+  NEW: OTP (One-Time Password) Authentication Support!\nRun 'grim otp-setup' to enable
+  secure two-factor authentication.\n\nThe gem provides a unified interface to all
+  Grim Reaper modules:\n- Python components (scythe, py_grim)\n- Go components (go_grim)\n-
+  Shell components (sh_grim)\n- Ruby components (rb_grim)\n- OTP Security Module (NEW!)\n\nRun
+  'grim rb-setup' to configure your environment and install all components.\nRun 'grim
+  help' to see all available commands.\n\nFor automatic installation of all Grim Reaper
+  components, run:\ngrim setup-complete\n\n\U0001F510 Security Enhancement:\n• Use
+  --otp flag for secure command execution\n• Setup OTP: grim otp-setup\n• Verify OTP:
+  grim otp-verify <code>\n• Check status: grim otp-status\n\n\U0001F4A1 For missing
+  commands, visit: https://get.grim.so\n"
 rdoc_options: []
 require_paths:
 - lib
@@ -243,5 +248,5 @@ requirements: []
 rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
-summary: 'Grim: Unified Data Protection Ecosystem'
+summary: 'Grim: Unified Data Protection Ecosystem with OTP Security'
 test_files: []