ruborg 0.8.1 → 0.9.3

data/lib/ruborg/cli.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require "thor"
+require "json"
 
 module Ruborg
   # Command-line interface for ruborg
   class CLI < Thor
+    DEFAULT_LOCK_WAIT = 300
     class_option :config, type: :string, default: "ruborg.yml", desc: "Path to configuration file"
     class_option :log, type: :string, desc: "Path to log file"
     class_option :repository, type: :string, aliases: "-r", desc: "Repository name (for multi-repo configs)"
@@ -74,11 +76,7 @@ module Ruborg
       merged_config = global_settings.merge(repo_config)
       validate_hostname(merged_config)
       passphrase = fetch_passphrase_for_repo(merged_config)
-      borg_opts = merged_config["borg_options"] || {}
-      borg_path = merged_config["borg_path"]
-
-      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
-                                                 logger: @logger)
+      repo = build_repo(repo_config["path"], merged_config, passphrase)
 
       # Auto-initialize repository if configured
       # Use strict boolean checking: only true enables, everything else disables
@@ -121,11 +119,7 @@ module Ruborg
       merged_config = global_settings.merge(repo_config)
       validate_hostname(merged_config)
       passphrase = fetch_passphrase_for_repo(merged_config)
-      borg_opts = merged_config["borg_options"] || {}
-      borg_path = merged_config["borg_path"]
-
-      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
-                                                 logger: @logger)
+      repo = build_repo(repo_config["path"], merged_config, passphrase)
 
       # Create backup config wrapper for compatibility
       backup_config = BackupConfig.new(repo_config, merged_config)
@@ -161,11 +155,7 @@ module Ruborg
       global_settings = config.global_settings
       merged_config = global_settings.merge(repo_config)
       passphrase = fetch_passphrase_for_repo(merged_config)
-      borg_opts = merged_config["borg_options"] || {}
-      borg_path = merged_config["borg_path"]
-
-      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
-                                                 logger: @logger)
+      repo = build_repo(repo_config["path"], merged_config, passphrase)
 
       # Auto-initialize repository if configured
       # Use strict boolean checking: only true enables, everything else disables
@@ -184,8 +174,23 @@ module Ruborg
       raise
     end
 
-    desc "validate", "Validate configuration file for errors and type issues"
-    def validate_config
+    desc "validate TYPE", "Validate configuration file or repository (TYPE: config or repo)"
+    option :verify_data, type: :boolean, default: false, desc: "Verify repository data (slower, only for 'repo' type)"
+    option :all, type: :boolean, default: false, desc: "Validate all repositories (only for 'repo' type)"
+    def validate(type)
+      case type
+      when "config"
+        validate_config_implementation
+      when "repo"
+        validate_repo_implementation
+      else
+        raise ConfigError, "Invalid validation type: #{type}. Use 'config' or 'repo'"
+      end
+    end
+
+    private
+
+    def validate_config_implementation
       @logger.info("Validating configuration file: #{options[:config]}")
       config = Config.new(options[:config])
 
@@ -201,6 +206,7 @@ module Ruborg
       errors.concat(validate_boolean_setting(global_settings, "auto_init", "global"))
       errors.concat(validate_boolean_setting(global_settings, "auto_prune", "global"))
       errors.concat(validate_boolean_setting(global_settings, "allow_remove_source", "global"))
+      errors.concat(validate_boolean_setting(global_settings, "skip_hash_check", "global"))
 
       # Validate borg_options booleans
       if global_settings["borg_options"]
@@ -214,6 +220,7 @@ module Ruborg
         errors.concat(validate_boolean_setting(repo, "auto_init", repo_name))
         errors.concat(validate_boolean_setting(repo, "auto_prune", repo_name))
         errors.concat(validate_boolean_setting(repo, "allow_remove_source", repo_name))
+        errors.concat(validate_boolean_setting(repo, "skip_hash_check", repo_name))
 
         if repo["borg_options"]
           warnings.concat(validate_borg_option(repo["borg_options"], "allow_relocated_repo", repo_name))
@@ -257,11 +264,203 @@ module Ruborg
       raise
     end
 
-    desc "version", "Show ruborg version"
+    def validate_repo_implementation
+      @logger.info("Validating repository compatibility")
+      config = Config.new(options[:config])
+      global_settings = config.global_settings
+      validate_hostname(global_settings)
+
+      # Show Borg version first
+      borg_version = Repository.borg_version
+      puts "\nBorg version: #{borg_version}\n\n"
+
+      repos_to_validate = if options[:all]
+                            config.repositories
+                          elsif options[:repository]
+                            repo_config = config.get_repository(options[:repository])
+                            raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
+
+                            [repo_config]
+                          else
+                            raise ConfigError, "Please specify --repository or --all"
+                          end
+
+      repos_to_validate.each do |repo_config|
+        validate_repository(repo_config, global_settings)
+      end
+    rescue Error => e
+      @logger.error("Validation failed: #{e.message}")
+      raise
+    end
+
+    def validate_repository(repo_config, global_settings)
+      repo_name = repo_config["name"]
+      puts "--- Validating repository: #{repo_name} ---"
+      @logger.info("Validating repository: #{repo_name}")
+
+      merged_config = global_settings.merge(repo_config)
+      validate_hostname(merged_config)
+      passphrase = fetch_passphrase_for_repo(merged_config)
+      repo = build_repo(repo_config["path"], merged_config, passphrase)
+
+      unless repo.exists?
+        puts "  ✗ Repository does not exist at #{repo_config["path"]}"
+        @logger.error("Repository does not exist: #{repo_name}")
+        puts ""
+        return
+      end
+
+      # Check compatibility
+      compatibility = repo.check_compatibility
+      puts "  Repository version: #{compatibility[:repository_version]}"
+
+      if compatibility[:compatible]
+        puts "  ✓ Compatible with Borg #{compatibility[:borg_version]}"
+        @logger.info("Repository #{repo_name} is compatible")
+      else
+        puts "  ✗ INCOMPATIBLE with Borg #{compatibility[:borg_version]}"
+        repo_ver = compatibility[:repository_version]
+        borg_ver = compatibility[:borg_version]
+        puts "    Repository version #{repo_ver} cannot be read by Borg #{borg_ver}"
+        puts "    Please upgrade Borg or migrate the repository"
+        @logger.error("Repository #{repo_name} is incompatible with installed Borg version")
+      end
+
+      # Run integrity check if requested
+      if options[:verify_data]
+        puts "  Running integrity check..."
+        @logger.info("Running integrity check on #{repo_name}")
+        repo.check
+        puts "  ✓ Integrity check passed"
+        @logger.info("Integrity check passed for #{repo_name}")
+      end
+
+      puts ""
+    rescue BorgError => e
+      puts "  ✗ Validation failed: #{e.message}"
+      @logger.error("Validation failed for #{repo_name}: #{e.message}")
+      puts ""
+    end
+
+    public
+
+    desc "catalog", "Search or browse the local archive metadata catalog (no borg calls)"
+    option :search, type: :string, desc: "Regex pattern to filter by file path"
+    option :stats, type: :boolean, default: false, desc: "Show catalog statistics instead of listing entries"
+    option :json, type: :boolean, default: false, desc: "Output as JSON"
+    def catalog
+      config = Config.new(options[:config])
+
+      raise ConfigError, "Please specify --repository" unless options[:repository]
+
+      repo_config = config.get_repository(options[:repository])
+      raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
+
+      global_settings = config.global_settings
+      merged_config = global_settings.merge(repo_config)
+      cat = Catalog.new(repo_config["path"])
+
+      if options[:stats]
+        print_catalog_stats(cat.stats, options[:json])
+      elsif options[:search]
+        results = cat.search(options[:search])
+        print_catalog_entries(results, options[:json])
+      else
+        print_catalog_entries(cat.list, options[:json])
+      end
+
+      @logger.info("Catalog query on repository '#{merged_config["name"]}'")
+    rescue Error => e
+      @logger.error("Catalog failed: #{e.message}")
+      raise
+    end
+
+    desc "lock", "Check for and optionally break a Borg repository lock"
+    option :break, type: :boolean, default: false,
+                   desc: "Break the lock via borg break-lock (requires --yes)"
+    option :force, type: :boolean, default: false,
+                   desc: "Force-remove lock files directly without invoking borg (requires --yes)"
+    option :yes,   type: :boolean, default: false, desc: "Confirm the destructive operation"
+    def lock
+      config = Config.new(options[:config])
+
+      raise ConfigError, "Please specify --repository" unless options[:repository]
+      raise ConfigError, "Use --break or --force, not both" if options[:break] && options[:force]
+
+      repo_config = config.get_repository(options[:repository])
+      raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
+
+      global_settings = config.global_settings
+      merged_config = global_settings.merge(repo_config)
+      passphrase = fetch_passphrase_for_repo(merged_config)
+      repo = build_repo(repo_config["path"], merged_config, passphrase)
+
+      unless repo.locked?
+        puts "No lock found for repository '#{repo_config["name"]}'"
+        @logger.info("Lock check: no lock found for '#{repo_config["name"]}'")
+        return
+      end
+
+      warn "Lock detected on repository '#{repo_config["name"]}' (#{repo_config["path"]})"
+      @logger.warn("Lock detected on repository '#{repo_config["name"]}'")
+
+      unless options[:break] || options[:force]
+        warn "  Run with --break --yes (via borg) or --force --yes (direct removal)."
+        exit 1
+      end
+
+      unless options[:yes]
+        warn "  Add --yes to confirm."
+        exit 1
+      end
+
+      if options[:force]
+        removed = repo.force_break_lock
+        puts "Force-removed lock files for '#{repo_config["name"]}': #{removed.join(", ")}"
+        @logger.info("Force-removed lock files for '#{repo_config["name"]}'")
+      else
+        repo.break_lock
+        puts "Lock broken for repository '#{repo_config["name"]}'"
+        @logger.info("Lock broken for repository '#{repo_config["name"]}'")
+      end
+    rescue Error => e
+      @logger.error("Lock command failed: #{e.message}")
+      raise
+    end
+
+    desc "version", "Show ruborg and borg versions"
     def version
       require_relative "version"
       puts "ruborg #{Ruborg::VERSION}"
       @logger.info("Version checked: #{Ruborg::VERSION}")
+
+      begin
+        borg_version = Repository.borg_version
+        borg_path = Repository.borg_path
+        puts "borg #{borg_version} (#{borg_path})"
+        @logger.info("Borg version: #{borg_version}, path: #{borg_path}")
+      rescue BorgError => e
+        puts "borg: not found or not executable"
+        @logger.warn("Could not determine Borg version: #{e.message}")
+      end
+    end
+
+    desc "check", "DEPRECATED: Use 'ruborg validate repo' instead"
+    option :verify_data, type: :boolean, default: false, desc: "Verify repository data (slower)"
+    option :all, type: :boolean, default: false, desc: "Validate all repositories"
+    def check
+      puts "\n⚠️  DEPRECATED COMMAND"
+      puts "══════════════════════════════════════════════════════════════════\n\n"
+      puts "The 'ruborg check' command has been renamed for consistency.\n"
+      puts "Please use: ruborg validate repo\n\n"
+      puts "Examples:"
+      puts "  ruborg validate repo --repository documents"
+      puts "  ruborg validate repo --all"
+      puts "  ruborg validate repo --repository documents --verify-data\n\n"
+      puts "══════════════════════════════════════════════════════════════════\n"
+
+      @logger.warn("Deprecated command 'check' was called. User should use 'validate repo' instead.")
+      exit 1
     end
 
     desc "metadata ARCHIVE", "Get file metadata from an archive"
@@ -279,11 +478,7 @@ module Ruborg
       merged_config = global_settings.merge(repo_config)
       validate_hostname(merged_config)
       passphrase = fetch_passphrase_for_repo(merged_config)
-      borg_opts = merged_config["borg_options"] || {}
-      borg_path = merged_config["borg_path"]
-
-      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
-                                                 logger: @logger)
+      repo = build_repo(repo_config["path"], merged_config, passphrase)
 
       raise BorgError, "Repository does not exist at #{repo_config["path"]}" unless repo.exists?
 
@@ -310,93 +505,51 @@ module Ruborg
       raise
     end
 
-    desc "check", "Check repository integrity and compatibility"
-    option :verify_data, type: :boolean, default: false, desc: "Verify repository data (slower)"
-    option :all, type: :boolean, default: false, desc: "Check all repositories"
-    def check
-      @logger.info("Checking repository compatibility")
-      config = Config.new(options[:config])
-      global_settings = config.global_settings
-      validate_hostname(global_settings)
-
-      # Show Borg version first
-      borg_version = Repository.borg_version
-      puts "\nBorg version: #{borg_version}\n\n"
-
-      repos_to_check = if options[:all]
-                         config.repositories
-                       elsif options[:repository]
-                         repo_config = config.get_repository(options[:repository])
-                         raise ConfigError, "Repository '#{options[:repository]}' not found" unless repo_config
-
-                         [repo_config]
-                       else
-                         raise ConfigError, "Please specify --repository or --all"
-                       end
-
-      repos_to_check.each do |repo_config|
-        check_repository(repo_config, global_settings)
-      end
-    rescue Error => e
-      @logger.error("Check failed: #{e.message}")
-      raise
-    end
-
     private
 
-    def check_repository(repo_config, global_settings)
-      repo_name = repo_config["name"]
-      puts "--- Checking repository: #{repo_name} ---"
-      @logger.info("Checking repository: #{repo_name}")
-
-      merged_config = global_settings.merge(repo_config)
-      validate_hostname(merged_config)
-      passphrase = fetch_passphrase_for_repo(merged_config)
-      borg_opts = merged_config["borg_options"] || {}
-      borg_path = merged_config["borg_path"]
-
-      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
-                                                 logger: @logger)
-
-      unless repo.exists?
-        puts "  ✗ Repository does not exist at #{repo_config["path"]}"
-        @logger.error("Repository does not exist: #{repo_name}")
-        puts ""
+    def print_catalog_entries(entries, as_json)
+      if as_json
+        puts JSON.generate(entries.map { |e| stringify_entry(e) })
         return
       end
 
-      # Check compatibility
-      compatibility = repo.check_compatibility
-      puts "  Repository version: #{compatibility[:repository_version]}"
+      if entries.empty?
+        puts "No entries found."
+        return
+      end
 
-      if compatibility[:compatible]
-        puts "  ✓ Compatible with Borg #{compatibility[:borg_version]}"
-        @logger.info("Repository #{repo_name} is compatible")
-      else
-        puts "  ✗ INCOMPATIBLE with Borg #{compatibility[:borg_version]}"
-        repo_ver = compatibility[:repository_version]
-        borg_ver = compatibility[:borg_version]
-        puts "    Repository version #{repo_ver} cannot be read by Borg #{borg_ver}"
-        puts "    Please upgrade Borg or migrate the repository"
-        @logger.error("Repository #{repo_name} is incompatible with installed Borg version")
+      puts "\n#{"FILE PATH".ljust(55)}  #{"SIZE".ljust(10)}  ARCHIVE"
+      puts "-" * 90
+      entries.each do |e|
+        puts "#{truncate(e[:path].to_s, 55).ljust(55)}  #{format_size(e[:size].to_i).ljust(10)}  #{e[:archive_name]}"
       end
+      puts "\n#{entries.size} entry/entries."
+    end
 
-      # Run integrity check if requested
-      if options[:verify_data]
-        puts "  Running integrity check..."
-        @logger.info("Running integrity check on #{repo_name}")
-        repo.check
-        puts "  ✓ Integrity check passed"
-        @logger.info("Integrity check passed for #{repo_name}")
+    def print_catalog_stats(stats, as_json)
+      if as_json
+        puts JSON.generate(stats)
+        return
       end
 
-      puts ""
-    rescue BorgError => e
-      puts "  ✗ Check failed: #{e.message}"
-      @logger.error("Check failed for #{repo_name}: #{e.message}")
+      puts "\n═══════════════════════════════════════════════════════════════"
+      puts "  CATALOG STATISTICS"
+      puts "═══════════════════════════════════════════════════════════════\n\n"
+      puts "  Total archives : #{stats[:total_archives]}"
+      puts "  Unique files   : #{stats[:unique_paths]}"
+      puts "  Source dirs    : #{stats[:source_dirs]}"
+      puts "  Total size     : #{format_size(stats[:total_size])}"
       puts ""
     end
 
+    def stringify_entry(entry)
+      entry.transform_keys(&:to_s)
+    end
+
+    def truncate(str, max)
+      str.length > max ? "...#{str[-(max - 3)..]}" : str
+    end
+
     def show_repositories_summary(config)
       repositories = config.repositories
       global_settings = config.global_settings
@@ -485,7 +638,7 @@ module Ruborg
         unit_index += 1
       end
 
-      format("%.2f %s", size, units[unit_index])
+      "#{format("%.2f", size)} #{units[unit_index]}"
     end
 
     def get_passphrase(passphrase, passbolt_id)
@@ -544,30 +697,31 @@ module Ruborg
       puts "\n--- Backing up repository: #{repo_name} ---"
       @logger.info("Backing up repository: #{repo_name}")
 
-      # Merge global settings with repo-specific settings (repo-specific takes precedence)
       merged_config = global_settings.merge(repo_config)
       validate_hostname(merged_config)
 
+      retention_mode = merged_config["retention_mode"] || "standard"
+      auto_prune = merged_config["auto_prune"] == true
+      retention_policy = merged_config["retention"]
+      will_prune = auto_prune && retention_policy && !retention_policy.empty?
+      stage_total = will_prune ? 3 : 2
+
+      progress = Progress.new
+      progress.stage(1, stage_total, "Verifying repository: #{repo_name}")
+
       passphrase = fetch_passphrase_for_repo(merged_config)
-      borg_opts = merged_config["borg_options"] || {}
-      borg_path = merged_config["borg_path"]
-      repo = Repository.new(repo_config["path"], passphrase: passphrase, borg_options: borg_opts, borg_path: borg_path,
-                                                 logger: @logger)
+      lock_wait = (merged_config["lock_wait"] || DEFAULT_LOCK_WAIT).to_i
+      repo = build_repo(repo_config["path"], merged_config, passphrase)
 
-      # Auto-initialize if configured
-      # Use strict boolean checking: only true enables, everything else disables
-      auto_init = merged_config["auto_init"]
-      auto_init = false unless auto_init == true
+      auto_init = merged_config["auto_init"] == true
       if auto_init && !repo.exists?
         @logger.info("Auto-initializing repository at #{repo_config["path"]}")
         repo.create
         puts "Repository auto-initialized at #{repo_config["path"]}"
       end
 
-      # Get retention mode (defaults to standard)
-      retention_mode = merged_config["retention_mode"] || "standard"
+      wait_for_lock_clear(repo, repo_name, lock_wait, progress)
 
-      # Validate remove_source permission with strict type checking
       if options[:remove_source]
         allow_remove_source = merged_config["allow_remove_source"]
         unless allow_remove_source.is_a?(TrueClass)
@@ -578,10 +732,14 @@ module Ruborg
         end
       end
 
-      # Create backup config wrapper
+      skip_hash_check = merged_config["skip_hash_check"] == true
+
+      backup_label = retention_mode == "per_file" ? "Backing up files (per-file mode)" : "Creating archive"
+      progress.stage(2, stage_total, backup_label)
+
       backup_config = BackupConfig.new(repo_config, merged_config)
       backup = Backup.new(repo, config: backup_config, retention_mode: retention_mode, repo_name: repo_name,
-                                logger: @logger)
+                                logger: @logger, skip_hash_check: skip_hash_check, progress: progress)
 
       archive_name = options[:name] ? sanitize_archive_name(options[:name]) : nil
       @logger.info("Creating archive#{"s" if retention_mode == "per_file"}: #{archive_name || "auto-generated"}")
@@ -592,27 +750,55 @@ module Ruborg
       backup.create(name: archive_name, remove_source: options[:remove_source])
       @logger.info("Backup created successfully")
 
-      if retention_mode == "per_file"
-        puts "✓ Per-file backups created"
-      else
-        puts "✓ Backup created: #{archive_name || "auto-generated"}"
-      end
       puts "  Sources removed" if options[:remove_source]
 
-      # Auto-prune if configured and retention policy exists
-      # Use strict boolean checking: only true enables, everything else disables
-      auto_prune = merged_config["auto_prune"]
-      auto_prune = false unless auto_prune == true
-      retention_policy = merged_config["retention"]
-
-      return unless auto_prune && retention_policy && !retention_policy.empty?
+      return unless will_prune
 
       mode_desc = retention_mode == "per_file" ? "per-file mode" : "standard mode"
+      progress.stage(3, stage_total, "Pruning old archives (#{mode_desc})")
+      progress.spin("Pruning...")
       @logger.info("Auto-pruning repository: #{repo_name} (#{mode_desc})")
-      puts "  Pruning old backups (#{mode_desc})..."
       repo.prune(retention_policy, retention_mode: retention_mode)
       @logger.info("Pruning completed successfully for #{repo_name}")
-      puts "  ✓ Pruning completed"
+      progress.done("Pruning completed")
+    end
+
+    def wait_for_lock_clear(repo, repo_name, lock_wait, progress)
+      return unless repo.locked?
+
+      @logger.warn("Repository '#{repo_name}' is locked — waiting up to #{lock_wait}s")
+      elapsed = 0
+      interval = 5
+
+      progress.spin("Repository locked — waiting for lock to clear (0s / #{lock_wait}s)…")
+
+      while repo.locked? && elapsed < lock_wait
+        sleep interval
+        elapsed += interval
+        progress.spin("Repository locked — waiting for lock to clear (#{elapsed}s / #{lock_wait}s)…")
+      end
+
+      progress.stop_spin
+
+      if repo.locked?
+        raise BorgError,
+              "Repository '#{repo_name}' is still locked after #{lock_wait}s. " \
+              "Run 'ruborg lock --repository #{repo_name}' to inspect, or " \
+              "'ruborg lock --repository #{repo_name} --break --yes' to clear."
+      end
+
+      @logger.info("Lock cleared for '#{repo_name}' after #{elapsed}s")
+    end
+
+    def build_repo(repo_path, merged_config, passphrase)
+      Repository.new(
+        repo_path,
+        passphrase: passphrase,
+        borg_options: merged_config["borg_options"] || {},
+        borg_path: merged_config["borg_path"],
+        lock_wait: merged_config["lock_wait"]&.to_i,
+        logger: @logger
+      )
     end
 
     def fetch_passphrase_for_repo(repo_config)

data/lib/ruborg/config.rb

@@ -41,7 +41,7 @@ module Ruborg
 
     def global_settings
       @data.slice("passbolt", "compression", "encryption", "auto_init", "borg_options", "log_file", "retention",
-                  "auto_prune", "hostname", "allow_remove_source", "borg_path")
+                  "auto_prune", "hostname", "allow_remove_source", "borg_path", "skip_hash_check", "lock_wait")
     end
 
     private
@@ -54,12 +54,12 @@ module Ruborg
     # Valid configuration keys at each level
     VALID_GLOBAL_KEYS = %w[
       hostname compression encryption auto_init auto_prune allow_remove_source
-      log_file borg_path passbolt borg_options retention repositories
+      log_file borg_path passbolt borg_options retention repositories skip_hash_check lock_wait
     ].freeze
 
     VALID_REPOSITORY_KEYS = %w[
       name description path hostname retention_mode passbolt retention sources
-      compression encryption auto_init auto_prune borg_options allow_remove_source
+      compression encryption auto_init auto_prune borg_options allow_remove_source skip_hash_check lock_wait
     ].freeze
 
     VALID_SOURCE_KEYS = %w[name paths exclude].freeze
@@ -122,8 +122,9 @@ module Ruborg
       errors.concat(validate_boolean_config(@data, "auto_init", "global"))
       errors.concat(validate_boolean_config(@data, "auto_prune", "global"))
       errors.concat(validate_boolean_config(@data, "allow_remove_source", "global"))
+      errors.concat(validate_boolean_config(@data, "skip_hash_check", "global"))
 
-      # Note: borg_options are validated as warnings in CLI validate command, not as errors here
+      # NOTE: borg_options are validated as warnings in CLI validate command, not as errors here
 
       # Validate global passbolt
       errors.concat(validate_passbolt_config(@data["passbolt"], "global")) if @data["passbolt"]
@@ -151,6 +152,7 @@ module Ruborg
         errors.concat(validate_boolean_config(repo, "auto_init", repo_name))
         errors.concat(validate_boolean_config(repo, "auto_prune", repo_name))
         errors.concat(validate_boolean_config(repo, "allow_remove_source", repo_name))
+        errors.concat(validate_boolean_config(repo, "skip_hash_check", repo_name))
 
         # Validate retention_mode
         if repo["retention_mode"] && !VALID_RETENTION_MODES.include?(repo["retention_mode"])
@@ -158,7 +160,7 @@ module Ruborg
                     "Must be one of: #{VALID_RETENTION_MODES.join(", ")}"
         end
 
-        # Note: borg_options are validated as warnings in CLI validate command, not as errors here
+        # NOTE: borg_options are validated as warnings in CLI validate command, not as errors here
 
         errors.concat(validate_passbolt_config(repo["passbolt"], repo_name)) if repo["passbolt"]