ruborg 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e48935c72c444956ca0b7918efb14bd3d5b8a38273ec6843adec2fbb2da6968
-  data.tar.gz: f200cb546d62431ec1ff84544da0b96b9f84cf7877aa29627608f8c43119d2b7
+  metadata.gz: b3dfe277e22cf29ef1132f479b8e8a969e87c69b383529b7f05eb7238ac5ea07
+  data.tar.gz: fcf98cabcd5f4636fc513e69e3b446747c9ca2f054f6480f4da60416ec865f0d
 SHA512:
-  metadata.gz: 4614d7f78363f420ae4ce80355725fb84e068bfac0d94591f1cee56a6d14c7c6664dd415405462086bdf2fa7543187702f346645655b2bb32b5ffb62fea288a9
-  data.tar.gz: f70898563085b03b78cf4cf140abb5efd9bd3bd6881918aa7a77c976823a15469688e3aeafd6814c4ff880b3e5c8f949264a1c03f9b1251f3467d409ebe1f302
+  metadata.gz: 159296240a1cec2e7791edb3689bf032569d8c1f4fda0ac5c1522e92076fec8c719dba3117326c9fcb9e074ffa295ed71a75b500657625d1ce71fab391b441c2
+  data.tar.gz: f6385fa1ff56520719b1f8b3985931b4083b3139889b34ed4d1dcb5d449eec8ba98e96f030988cf03cdcb5744f47255ef3b7a605e7bb040d6b1f2c0446ab3b81

data/.rspec

@@ -1,3 +1,3 @@
 --require spec_helper
 --color
---format documentation
+--format documentation

data/CHANGELOG.md

@@ -7,6 +7,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2025-10-05
+
+### Added
+- Auto-initialization feature: Set `auto_init: true` in config to automatically initialize repositories on first use
+- Multi-repository configuration support with per-repository sources
+- `--repository` / `-r` option to target specific repository in multi-repo configs
+- `--all` option to backup all repositories at once
+- Repository-specific Passbolt integration (overrides global settings)
+- Per-source exclude patterns in multi-repo configs
+- BackupConfig wrapper class for multi-repo compatibility
+- Automatic format detection (single vs multi-repo)
+- Support for multiple backup sources per repository
+- Global settings with per-repository overrides
+- `log_file` configuration option to set log path in config file
+- Log file priority: CLI option > config file > default
+
+### Changed
+- Config class now detects and handles both single-repo and multi-repo formats
+- Backup command automatically routes to single or multi-repo implementation
+- Archive naming includes repository name for multi-repo configs
+- CLI now reads log_file from config if --log option not provided
+
+## [0.2.0] - 2025-10-05
+
+### Added
+- `--remove-source` option to delete source files after successful backup
+- Comprehensive logging system with daily rotation (default: `~/.ruborg/logs/ruborg.log`)
+- Custom log file support via `--log` option for all commands
+- `--path` option for restore command to extract single files/directories from archives
+- Comprehensive RSpec test suite with mocked Passbolt and actual Borg integration tests
+- Borg installation instructions for macOS and Ubuntu in README
+- Support for environment variables to prevent interactive prompts (`BORG_RELOCATED_REPO_ACCESS_IS_OK`, etc.)
+- Automatic destination directory creation for restore operations
+- Test helpers and fixtures for easier testing
+
+### Fixed
+- Passbolt CLI command corrected from `passbolt get <id>` to `passbolt get resource <id>`
+- Borg commands now properly redirect stdin to prevent interactive passphrase prompts
+- Improved error handling and logging throughout the application
+
+### Changed
+- Refactored Passbolt class to use testable `execute_command` method
+- Enhanced Repository and Backup classes to properly handle environment variables
+- Improved CLI integration with better Passbolt mock support in tests
+
+## [0.1.0] - 2025-10-04
+
 ### Added
 - Initial gem structure
 - Borg repository initialization and management
@@ -14,8 +61,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - YAML configuration file support
 - Passbolt CLI integration for password management
 - Command-line interface with Thor
-
-## [0.1.0] - 2025-10-04
-
-### Added
-- Initial release
+- Basic error handling

data/README.md

@@ -1,7 +1,5 @@
 # Ruborg
 
-> **⚠️ WARNING: This project is under heavy development and is not yet functional. Do not use in production.**
->
 > This gem is being developed with the assistance of Claude AI.
 
 A friendly Ruby frontend for [Borg Backup](https://www.borgbackup.org/). Ruborg simplifies backup management by providing a YAML-based configuration system and seamless integration with Passbolt for encryption password management.
@@ -14,13 +12,37 @@ A friendly Ruby frontend for [Borg Backup](https://www.borgbackup.org/). Ruborg
 - 🔐 **Passbolt Integration** - Secure password management via Passbolt CLI
 - 🎯 **Pattern Exclusions** - Flexible file exclusion patterns
 - 🗜️ **Compression Options** - Support for multiple compression algorithms
+- 🗂️ **Selective Restore** - Restore individual files or directories from archives
+- 🧹 **Auto-cleanup** - Optionally remove source files after successful backup
+- 📊 **Logging** - Comprehensive logging with daily rotation
+- 🗄️ **Multi-Repository** - Manage multiple backup repositories with different sources
+- 🔄 **Auto-initialization** - Automatically initialize repositories on first use
+- ✅ **Well-tested** - Comprehensive test suite with RSpec
 
 ## Prerequisites
 
-- Ruby >= 2.7.0
+- Ruby >= 3.2.0
 - [Borg Backup](https://www.borgbackup.org/) installed and available in PATH
 - [Passbolt CLI](https://github.com/passbolt/go-passbolt-cli) (optional, for password management)
 
+### Installing Borg Backup
+
+**macOS:**
+```bash
+brew install borgbackup
+```
+
+**Ubuntu/Debian:**
+```bash
+sudo apt update
+sudo apt install borgbackup
+```
+
+**Verify installation:**
+```bash
+borg --version
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -43,7 +65,9 @@ gem install ruborg
 
 ## Configuration
 
-Create a `ruborg.yml` configuration file:
+Ruborg supports two configuration formats: **single repository** (legacy) and **multi-repository** (recommended for complex setups).
+
+### Single Repository Configuration
 
 ```yaml
 # Repository path
@@ -53,15 +77,11 @@ repository: /path/to/borg/repository
 backup_paths:
   - /home/user/documents
   - /home/user/projects
-  - /etc
 
 # Exclude patterns
 exclude_patterns:
   - "*.tmp"
   - "*.log"
-  - "*/.cache/*"
-  - "*/node_modules/*"
-  - "*/.git/*"
 
 # Compression algorithm (lz4, zstd, zlib, lzma, none)
 compression: lz4
@@ -72,9 +92,62 @@ encryption: repokey
 # Passbolt integration (optional)
 passbolt:
   resource_id: "your-passbolt-resource-uuid"
+
+# Auto-initialize repository (optional, default: false)
+auto_init: true
+
+# Log file path (optional, default: ~/.ruborg/logs/ruborg.log)
+log_file: /var/log/ruborg.log
 ```
 
-See `ruborg.yml.example` for a complete configuration template.
+### Multi-Repository Configuration
+
+For managing multiple repositories with different sources:
+
+```yaml
+# Global settings (applied to all repositories unless overridden)
+compression: lz4
+encryption: repokey
+auto_init: true
+passbolt:
+  resource_id: "global-passbolt-id"
+
+# Multiple repositories
+repositories:
+  - name: documents
+    path: /mnt/backup/documents
+    sources:
+      - name: home-docs
+        paths:
+          - /home/user/documents
+        exclude:
+          - "*.tmp"
+      - name: work-docs
+        paths:
+          - /home/user/work
+        exclude:
+          - "*.log"
+
+  - name: databases
+    path: /mnt/backup/databases
+    # Repository-specific passbolt (overrides global)
+    passbolt:
+      resource_id: "db-specific-passbolt-id"
+    sources:
+      - name: mysql
+        paths:
+          - /var/lib/mysql/dumps
+      - name: postgres
+        paths:
+          - /var/lib/postgresql/dumps
+```
+
+**Multi-repo benefits:**
+- Organize backups by type (documents, databases, media)
+- Different encryption keys per repository
+- Multiple sources per repository
+- Per-source exclude patterns
+- Repository-specific settings override global ones
 
 ## Usage
 
@@ -90,6 +163,7 @@ ruborg init /path/to/repository --passbolt-id "resource-uuid"
 
 ### Create a Backup
 
+**Single repository:**
 ```bash
 # Using default configuration (ruborg.yml)
 ruborg backup
@@ -99,6 +173,21 @@ ruborg backup --config /path/to/config.yml
 
 # With custom archive name
 ruborg backup --name "my-backup-2025-10-04"
+
+# Remove source files after successful backup
+ruborg backup --remove-source
+```
+
+**Multi-repository:**
+```bash
+# Backup specific repository
+ruborg backup --repository documents
+
+# Backup all repositories
+ruborg backup --all
+
+# Backup specific repository with custom name
+ruborg backup --repository databases --name "db-backup-2025-10-05"
 ```
 
 ### List Archives
@@ -110,11 +199,14 @@ ruborg list
 ### Restore from Archive
 
 ```bash
-# Restore to current directory
+# Restore entire archive to current directory
 ruborg restore archive-name
 
 # Restore to specific directory
 ruborg restore archive-name --destination /path/to/restore
+
+# Restore a single file from archive
+ruborg restore archive-name --path /path/to/file.txt --destination /new/location
 ```
 
 ### View Repository Information
@@ -123,13 +215,50 @@ ruborg restore archive-name --destination /path/to/restore
 ruborg info
 ```
 
+## Logging
+
+Ruborg automatically logs all operations with daily rotation. Log file location priority:
+
+1. **CLI option** (highest priority): `--log /path/to/custom.log`
+2. **Config file**: `log_file: /path/to/log.log`
+3. **Default**: `~/.ruborg/logs/ruborg.log`
+
+**Examples:**
+
+```bash
+# Use CLI option (overrides config)
+ruborg backup --log /var/log/ruborg.log
+
+# Or set in config file
+log_file: /var/log/ruborg.log
+```
+
+**Logs include:**
+- Operation start/completion timestamps
+- Paths being backed up
+- Archive names created
+- Success and error messages
+- Source file removal actions
+
 ## Passbolt Integration
 
 Ruborg can retrieve encryption passphrases from Passbolt using the Passbolt CLI:
 
 1. Install and configure [Passbolt CLI](https://github.com/passbolt/go-passbolt-cli)
-2. Store your Borg repository passphrase in Passbolt
-3. Add the resource ID to your `ruborg.yml`:
+2. Configure Passbolt CLI with your server credentials:
+   ```bash
+   passbolt configure --serverAddress https://server.address \
+                      --userPrivateKeyFile /path/to/private.key \
+                      --userPassword YOUR_PASSWORD
+   ```
+   Or set environment variables:
+   ```bash
+   export PASSBOLT_SERVER_ADDRESS=https://server.address
+   export PASSBOLT_USER_PRIVATE_KEY_FILE=/path/to/private.key
+   export PASSBOLT_USER_PASSWORD=YOUR_PASSWORD
+   ```
+3. Store your Borg repository passphrase in Passbolt
+4. Add the resource ID to your `ruborg.yml`:
 
 ```yaml
 passbolt:
@@ -138,15 +267,41 @@ passbolt:
 
 Ruborg will automatically retrieve the passphrase when performing backup operations.
 
+## Auto-initialization
+
+Set `auto_init: true` in your configuration file to automatically initialize the repository on first use:
+
+```yaml
+repository: /path/to/borg/repository
+auto_init: true
+passbolt:
+  resource_id: "your-passbolt-resource-uuid"
+backup_paths:
+  - /path/to/backup
+```
+
+When enabled, ruborg will automatically run `borg init` if the repository doesn't exist when you run `backup`, `list`, or `info` commands. The passphrase will be retrieved from Passbolt if configured.
+
 ## Command Reference
 
 | Command | Description | Options |
 |---------|-------------|---------|
-| `init REPOSITORY` | Initialize a new Borg repository | `--passphrase`, `--passbolt-id` |
-| `backup` | Create a backup using config file | `--config`, `--name` |
-| `list` | List all archives in repository | `--config` |
-| `restore ARCHIVE` | Restore files from archive | `--config`, `--destination` |
-| `info` | Show repository information | `--config` |
+| `init REPOSITORY` | Initialize a new Borg repository | `--passphrase`, `--passbolt-id`, `--log` |
+| `backup` | Create a backup using config file | `--config`, `--name`, `--remove-source`, `--repository`, `--all`, `--log` |
+| `list` | List all archives in repository | `--config`, `--repository`, `--log` |
+| `restore ARCHIVE` | Restore files from archive | `--config`, `--destination`, `--path`, `--repository`, `--log` |
+| `info` | Show repository information | `--config`, `--repository`, `--log` |
+
+### Global Options
+
+- `--config`: Path to configuration file (default: `ruborg.yml`)
+- `--log`: Path to log file (overrides config, default: `~/.ruborg/logs/ruborg.log`)
+- `--repository` / `-r`: Repository name (required for multi-repo configs)
+
+### Multi-Repository Options
+
+- `--all`: Backup all repositories (multi-repo config only)
+- `--repository NAME`: Target specific repository by name
 
 ## Development
 
@@ -169,9 +324,24 @@ bundle exec rake release
 Run the test suite:
 
 ```bash
+# Run all tests
 bundle exec rspec
+
+# Run only unit tests (no Borg required)
+bundle exec rspec --tag ~borg
+
+# Run only integration tests (requires Borg)
+bundle exec rspec --tag borg
 ```
 
+The test suite includes:
+- Config loading and validation
+- Repository management (with actual Borg integration)
+- Backup and restore operations
+- Passbolt integration (mocked)
+- CLI commands
+- Logging functionality
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/mpantel/ruborg.

data/lib/ruborg/backup.rb

@@ -8,22 +8,33 @@ module Ruborg
       @config = config
     end
 
-    def create(name: nil)
+    def create(name: nil, remove_source: false)
       raise BorgError, "Repository does not exist" unless @repository.exists?
 
       archive_name = name || Time.now.strftime("%Y-%m-%d_%H-%M-%S")
       cmd = build_create_command(archive_name)
 
       execute_borg_command(cmd)
+
+      remove_source_files if remove_source
     end
 
-    def extract(archive_name, destination: ".")
+    def extract(archive_name, destination: ".", path: nil)
       raise BorgError, "Repository does not exist" unless @repository.exists?
 
       cmd = ["borg", "extract", "#{@repository.path}::#{archive_name}"]
-      cmd += ["--destination", destination] if destination != "."
-
-      execute_borg_command(cmd)
+      cmd << path if path
+
+      # Change to destination directory if specified
+      if destination != "."
+        require "fileutils"
+        FileUtils.mkdir_p(destination) unless File.directory?(destination)
+        Dir.chdir(destination) do
+          execute_borg_command(cmd)
+        end
+      else
+        execute_borg_command(cmd)
+      end
     end
 
     def list_archives
@@ -52,10 +63,28 @@ module Ruborg
     end
 
     def execute_borg_command(cmd)
-      result = system(*cmd)
+      env = {}
+      passphrase = @repository.instance_variable_get(:@passphrase)
+      env["BORG_PASSPHRASE"] = passphrase if passphrase
+      env["BORG_RELOCATED_REPO_ACCESS_IS_OK"] = "yes"
+      env["BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK"] = "yes"
+
+      result = system(env, *cmd, in: "/dev/null")
       raise BorgError, "Borg command failed: #{cmd.join(' ')}" unless result
 
       result
     end
+
+    def remove_source_files
+      require "fileutils"
+
+      @config.backup_paths.each do |path|
+        if File.directory?(path)
+          FileUtils.rm_rf(path)
+        elsif File.file?(path)
+          FileUtils.rm(path)
+        end
+      end
+    end
   end
 end

data/lib/ruborg/cli.rb

@@ -6,68 +6,123 @@ module Ruborg
   # Command-line interface for ruborg
   class CLI < Thor
     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)"
+
+    def initialize(*args)
+      super
+      # Priority: CLI option > config file > default
+      log_path = options[:log]
+      unless log_path
+        # Try to load config to get log_file setting
+        config_path = options[:config] || "ruborg.yml"
+        if File.exist?(config_path)
+          config_data = YAML.load_file(config_path) rescue {}
+          log_path = config_data["log_file"]
+        end
+      end
+      @logger = RuborgLogger.new(log_file: log_path)
+    end
 
     desc "init REPOSITORY", "Initialize a new Borg repository"
     option :passphrase, type: :string, desc: "Repository passphrase"
     option :passbolt_id, type: :string, desc: "Passbolt resource ID for passphrase"
     def init(repository_path)
+      @logger.info("Initializing repository at #{repository_path}")
       passphrase = get_passphrase(options[:passphrase], options[:passbolt_id])
       repo = Repository.new(repository_path, passphrase: passphrase)
       repo.create
+      @logger.info("Repository successfully initialized at #{repository_path}")
       puts "Repository initialized at #{repository_path}"
     rescue Error => e
+      @logger.error("Failed to initialize repository: #{e.message}")
       error_exit(e)
     end
 
     desc "backup", "Create a backup using configuration file"
     option :name, type: :string, desc: "Archive name"
+    option :remove_source, type: :boolean, default: false, desc: "Remove source files after successful backup"
+    option :all, type: :boolean, default: false, desc: "Backup all repositories (multi-repo config only)"
     def backup
+      @logger.info("Starting backup operation with config: #{options[:config]}")
       config = Config.new(options[:config])
-      passphrase = fetch_passphrase_from_config(config)
-
-      repo = Repository.new(config.repository, passphrase: passphrase)
-      backup = Backup.new(repo, config: config)
 
-      backup.create(name: options[:name])
-      puts "Backup created successfully"
+      if config.multi_repo?
+        backup_multi_repo(config)
+      else
+        backup_single_repo(config)
+      end
     rescue Error => e
+      @logger.error("Backup failed: #{e.message}")
       error_exit(e)
     end
 
     desc "list", "List all archives in the repository"
     def list
+      @logger.info("Listing archives in repository")
       config = Config.new(options[:config])
       passphrase = fetch_passphrase_from_config(config)
 
       repo = Repository.new(config.repository, passphrase: passphrase)
+
+      # Auto-initialize repository if configured
+      if config.auto_init? && !repo.exists?
+        @logger.info("Auto-initializing repository at #{config.repository}")
+        repo.create
+        puts "Repository auto-initialized at #{config.repository}"
+      end
+
       repo.list
+      @logger.info("Successfully listed archives")
     rescue Error => e
+      @logger.error("Failed to list archives: #{e.message}")
       error_exit(e)
     end
 
     desc "restore ARCHIVE", "Restore files from an archive"
     option :destination, type: :string, default: ".", desc: "Destination directory"
+    option :path, type: :string, desc: "Specific file or directory path to restore from archive"
     def restore(archive_name)
+      restore_target = options[:path] ? "#{options[:path]} from #{archive_name}" : archive_name
+      @logger.info("Restoring #{restore_target} to #{options[:destination]}")
       config = Config.new(options[:config])
       passphrase = fetch_passphrase_from_config(config)
 
       repo = Repository.new(config.repository, passphrase: passphrase)
       backup = Backup.new(repo, config: config)
 
-      backup.extract(archive_name, destination: options[:destination])
-      puts "Archive restored to #{options[:destination]}"
+      backup.extract(archive_name, destination: options[:destination], path: options[:path])
+      @logger.info("Successfully restored #{restore_target} to #{options[:destination]}")
+
+      if options[:path]
+        puts "Restored #{options[:path]} from #{archive_name} to #{options[:destination]}"
+      else
+        puts "Archive restored to #{options[:destination]}"
+      end
     rescue Error => e
+      @logger.error("Failed to restore archive: #{e.message}")
       error_exit(e)
     end
 
     desc "info", "Show repository information"
     def info
+      @logger.info("Retrieving repository information")
       config = Config.new(options[:config])
       passphrase = fetch_passphrase_from_config(config)
 
       repo = Repository.new(config.repository, passphrase: passphrase)
+
+      # Auto-initialize repository if configured
+      if config.auto_init? && !repo.exists?
+        @logger.info("Auto-initializing repository at #{config.repository}")
+        repo.create
+        puts "Repository auto-initialized at #{config.repository}"
+      end
+
       repo.info
+      @logger.info("Successfully retrieved repository information")
     rescue Error => e
+      @logger.error("Failed to get repository info: #{e.message}")
       error_exit(e)
     end
 
@@ -91,5 +146,128 @@ module Ruborg
       puts "Error: #{error.message}"
       exit 1
     end
+
+    # Single repository backup (legacy)
+    def backup_single_repo(config)
+      @logger.info("Backing up paths: #{config.backup_paths.join(', ')}")
+      passphrase = fetch_passphrase_from_config(config)
+
+      repo = Repository.new(config.repository, passphrase: passphrase)
+
+      # Auto-initialize repository if configured
+      if config.auto_init? && !repo.exists?
+        @logger.info("Auto-initializing repository at #{config.repository}")
+        repo.create
+        puts "Repository auto-initialized at #{config.repository}"
+      end
+
+      backup = Backup.new(repo, config: config)
+
+      archive_name = options[:name] || Time.now.strftime("%Y-%m-%d_%H-%M-%S")
+      @logger.info("Creating archive: #{archive_name}")
+      backup.create(name: options[:name], remove_source: options[:remove_source])
+      @logger.info("Backup created successfully: #{archive_name}")
+
+      if options[:remove_source]
+        @logger.info("Removed source files: #{config.backup_paths.join(', ')}")
+      end
+
+      puts "Backup created successfully"
+      puts "Source files removed" if options[:remove_source]
+    end
+
+    # Multi-repository backup
+    def backup_multi_repo(config)
+      global_settings = config.global_settings
+      repos_to_backup = 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 for multi-repo config"
+                        end
+
+      repos_to_backup.each do |repo_config|
+        backup_repository(repo_config, global_settings)
+      end
+    end
+
+    def backup_repository(repo_config, global_settings)
+      repo_name = repo_config["name"]
+      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)
+
+      passphrase = fetch_passphrase_for_repo(merged_config)
+      repo = Repository.new(repo_config["path"], passphrase: passphrase)
+
+      # Auto-initialize if configured
+      auto_init = merged_config["auto_init"] || false
+      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
+
+      # Create backup config wrapper
+      backup_config = BackupConfig.new(repo_config, merged_config)
+      backup = Backup.new(repo, config: backup_config)
+
+      archive_name = options[:name] || "#{repo_name}-#{Time.now.strftime('%Y-%m-%d_%H-%M-%S')}"
+      @logger.info("Creating archive: #{archive_name}")
+
+      sources = repo_config["sources"] || []
+      @logger.info("Backing up #{sources.size} source(s)")
+
+      backup.create(name: archive_name, remove_source: options[:remove_source])
+      @logger.info("Backup created successfully: #{archive_name}")
+
+      puts "✓ Backup created: #{archive_name}"
+      puts "  Sources removed" if options[:remove_source]
+    end
+
+    def fetch_passphrase_for_repo(repo_config)
+      passbolt_config = repo_config["passbolt"]
+      return nil if passbolt_config.nil? || passbolt_config.empty?
+
+      Passbolt.new(resource_id: passbolt_config["resource_id"]).get_password
+    end
+
+    # Wrapper class to adapt multi-repo config to existing Backup class
+    class BackupConfig
+      def initialize(repo_config, merged_settings)
+        @repo_config = repo_config
+        @merged_settings = merged_settings
+      end
+
+      def backup_paths
+        sources = @repo_config["sources"] || []
+        sources.flat_map do |source|
+          source["paths"] || []
+        end
+      end
+
+      def exclude_patterns
+        patterns = []
+        sources = @repo_config["sources"] || []
+        sources.each do |source|
+          patterns += (source["exclude"] || [])
+        end
+        patterns += (@merged_settings["exclude_patterns"] || [])
+        patterns.uniq
+      end
+
+      def compression
+        @merged_settings["compression"] || "lz4"
+      end
+
+      def encryption_mode
+        @merged_settings["encryption"] || "repokey"
+      end
+    end
   end
 end

data/lib/ruborg/config.rb

@@ -11,6 +11,7 @@ module Ruborg
     def initialize(config_path)
       @config_path = config_path
       load_config
+      detect_format
     end
 
     def load_config
@@ -21,6 +22,7 @@ module Ruborg
       raise ConfigError, "Invalid YAML syntax: #{e.message}"
     end
 
+    # Legacy single-repo accessors (for backward compatibility)
     def repository
       @data["repository"]
     end
@@ -44,5 +46,43 @@ module Ruborg
     def passbolt_integration
       @data["passbolt"] || {}
     end
+
+    def auto_init?
+      @data["auto_init"] || false
+    end
+
+    def log_file
+      @data["log_file"]
+    end
+
+    # New multi-repo support
+    def multi_repo?
+      @multi_repo
+    end
+
+    def repositories
+      return [] unless multi_repo?
+      @data["repositories"] || []
+    end
+
+    def get_repository(name)
+      return nil unless multi_repo?
+      repositories.find { |r| r["name"] == name }
+    end
+
+    def repository_names
+      return [] unless multi_repo?
+      repositories.map { |r| r["name"] }
+    end
+
+    def global_settings
+      @data.slice("passbolt", "compression", "encryption", "auto_init")
+    end
+
+    private
+
+    def detect_format
+      @multi_repo = @data.key?("repositories")
+    end
   end
 end

data/lib/ruborg/logger.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "logger"
+require "fileutils"
+
+module Ruborg
+  # Logging functionality for ruborg
+  class RuborgLogger
+    attr_reader :logger
+
+    def initialize(log_file: nil)
+      @log_file = log_file || default_log_file
+      ensure_log_directory
+      @logger = Logger.new(@log_file, "daily")
+      @logger.level = Logger::INFO
+      @logger.formatter = proc do |severity, datetime, progname, msg|
+        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+      end
+    end
+
+    def info(message)
+      @logger.info(message)
+    end
+
+    def error(message)
+      @logger.error(message)
+    end
+
+    def warn(message)
+      @logger.warn(message)
+    end
+
+    def debug(message)
+      @logger.debug(message)
+    end
+
+    private
+
+    def default_log_file
+      File.join(log_directory, "ruborg.log")
+    end
+
+    def log_directory
+      dir = File.expand_path("~/.ruborg/logs")
+      dir
+    end
+
+    def ensure_log_directory
+      FileUtils.mkdir_p(File.dirname(@log_file)) unless File.directory?(File.dirname(@log_file))
+    end
+  end
+end

data/lib/ruborg/passbolt.rb

@@ -13,10 +13,10 @@ module Ruborg
     def get_password
       raise PassboltError, "Resource ID not configured" unless @resource_id
 
-      cmd = ["passbolt", "get", @resource_id, "--json"]
-      output = `#{cmd.join(' ')}`
+      cmd = ["passbolt", "get", "resource", @resource_id, "--json"]
+      output, status = execute_command(cmd)
 
-      raise PassboltError, "Failed to retrieve password from Passbolt" unless $?.success?
+      raise PassboltError, "Failed to retrieve password from Passbolt" unless status
 
       parse_password(output)
     end
@@ -29,6 +29,11 @@ module Ruborg
       end
     end
 
+    def execute_command(cmd)
+      output = `#{cmd.join(' ')}`
+      [output, $?.success?]
+    end
+
     def parse_password(json_output)
       data = JSON.parse(json_output)
       data["password"] || data["secret"]

data/lib/ruborg/repository.rb

@@ -40,8 +40,11 @@ module Ruborg
     def execute_borg_command(cmd)
       env = {}
       env["BORG_PASSPHRASE"] = @passphrase if @passphrase
+      env["BORG_RELOCATED_REPO_ACCESS_IS_OK"] = "yes"
+      env["BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK"] = "yes"
 
-      result = system(env, *cmd)
+      # Redirect stdin from /dev/null to prevent interactive prompts
+      result = system(env, *cmd, in: "/dev/null")
       raise BorgError, "Borg command failed: #{cmd.join(' ')}" unless result
 
       result

data/lib/ruborg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruborg
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/ruborg.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "ruborg/version"
+require_relative "ruborg/logger"
 require_relative "ruborg/config"
 require_relative "ruborg/repository"
 require_relative "ruborg/backup"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruborg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Michail Pantelelis
@@ -115,10 +115,10 @@ files:
 - lib/ruborg/backup.rb
 - lib/ruborg/cli.rb
 - lib/ruborg/config.rb
+- lib/ruborg/logger.rb
 - lib/ruborg/passbolt.rb
 - lib/ruborg/repository.rb
 - lib/ruborg/version.rb
-- ruborg.gemspec
 - ruborg.yml.example
 homepage: https://github.com/mpantel/ruborg
 licenses:

data/ruborg.gemspec

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/ruborg/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "ruborg"
-  spec.version = Ruborg::VERSION
-  spec.authors = ["Michail Pantelelis"]
-  spec.email = ["mpantel@aegean.gr"]
-
-  spec.summary = "A friendly Ruby frontend for Borg backup"
-  spec.description = "Ruborg is a Ruby gem that provides a user-friendly interface to Borg backup. It reads YAML configuration files and orchestrates backup operations, supporting repository creation, backup management, and integration with Passbolt for encryption password management."
-  spec.homepage = "https://github.com/mpantel/ruborg"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.2.0"
-
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "#{spec.homepage}.git"
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
-
-  # Specify which files should be added to the gem when it is released.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
-    end
-  end
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  # Dependencies
-  spec.add_dependency "thor", "~> 1.3"
-  spec.add_dependency "psych", "~> 5.0"
-
-  # Development dependencies
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rubocop", "~> 1.0"
-end