grim-reaper 1.0.32 → 1.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad023d285c9eddc7d9830c5b42a5cffb63fa9bda24609aa457096e9fa8048a7a
-  data.tar.gz: ed148f4368b822553d9de0cf4cabf96422e9ed81cba3818231f1a5cbeefef1bf
+  metadata.gz: cf90fc5100b580ffa60500f336ca9133ef028fc34256926c6c275a8701c7f257
+  data.tar.gz: 0d87a9ec5d696cbf214ecc99778a5e74694cdd9704a05cebb8370e1892f2c89c
 SHA512:
-  metadata.gz: 3c2be16ed625e568f46db78326a26f1a4e8947cf8b3e39555f53a3e76843cc88256464bb52a0cb9ab69f0fd3bfd6e00934cae0d9c2de0a50d7e2e63c0bb4a840
-  data.tar.gz: 8d31592c0c1457643655835ce2b02a198b5ecdf367a390f6aeaec17a8612aaea906f6ca5a8028019520f559889f0a5baf9140d97b6371196bc7c7b3d52e9b0d8
+  metadata.gz: dbaa23420bd55bfa12531eae985d01bdec6251737922e079a48fd934c1c7c7343e9fb6d1d85dde978fa7ead83deef69890ef08c5cba40563543f606becc187b7
+  data.tar.gz: 35cbdafb5c311119d9b88f697e669d1a5d99fe3890a9ab6e468f878370e5fb3b745b8df9dc218fb4ef52c2c3e7820e221acef31922b20ee29e13bc1a95d0dba3

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,9 +20,76 @@ 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
@@ -36,6 +104,10 @@ class GrimCLI < Thor
   
   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 +120,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 +381,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 +401,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 ""
-    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 "🔐 Security Features:"
+    puts "  • Two-Factor Authentication (TOTP)"
+    puts "  • Backup codes for recovery"
+    puts "  • Secure command execution"
+    puts "  • Authentication tracking"
     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 +427,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/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.33"
 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.33
 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.33 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: []