Merge #136: Implement dependency installation logic with async Rust converters for bash scripts

6e0b214 test: [#117] suppress stderr in error exit code test for clean output (Jose Celano)
a0d9276 fix: [#117] correct test file paths in dependency-installer Cargo.toml (Jose Celano)
1e1ee7d docs: [#117] integrate dependency-installer package into global documentation (Jose Celano)
d9db859 refactor: [#117] rename integration test files for clarity (Jose Celano)
4f25a43 test: [#117] use exit codes instead of parsing output in dependency-installer tests (Jose Celano)
04c9381 refactor: [#117] simplify error handling with automatic conversions (Jose Celano)
c6f7898 feat: [#117] add snapd to Dockerfile and document LXD test limitations (Jose Celano)
9b5767a feat: [#117] optimize OpenTofu installer tests by moving dependencies to Dockerfile (Jose Celano)
92dc7a1 feat: [#117] add ImageBuilder to auto-build Docker images for package tests (Jose Celano)
a453356 perf: [#117] optimize Ansible installer by removing apt-get update (Jose Celano)
c2df939 perf: [#117] optimize Docker tests by pre-building container image with OS dependencies (Jose Celano)
65cc194 fix: conditionally import unused modules on Windows (copilot-swe-agent[bot])
1ebd884 fix: resolve Windows compilation errors in OpenTofu installer (copilot-swe-agent[bot])
2cd4101 fix: address code review feedback - async sleep and cross-platform concerns (copilot-swe-agent[bot])
edbfde5 docs: update README with install command and fix clippy warnings (copilot-swe-agent[bot])
1706359 fix: format code and fix detector test imports (copilot-swe-agent[bot])
8ce6ca9 test: add Docker tests for install command (copilot-swe-agent[bot])
39f4f98 feat: add installer trait and implementations with install command (copilot-swe-agent[bot])
f3f8feb Initial plan (copilot-swe-agent[bot])

Pull request description:

  Implement Installation Logic (Issue #117)

  This PR implements the installation logic for the dependency-installer package, converting bash scripts to Rust implementations with structured logging.

  **Implementation Status**: ✅ Complete

  All phases completed:
  - [x] Phase 1: Installer trait and error types
  - [x] Phase 2: Installer implementations (4 dependencies)
  - [x] Phase 3: DependencyManager extensions
  - [x] Phase 4: Install command handler
  - [x] Phase 5: CLI and app updates
  - [x] Phase 6: Docker tests
  - [x] Phase 7: Testing and validation
  - [x] Phase 8: Documentation

  **Recent Fixes**:
  - Fixed Windows compilation errors by restructuring OpenTofu installer to return early on non-Unix systems
  - Fixed unused import warnings by making imports conditional with #[cfg(unix)]

  **Test Results**:
  - All 17 tests pass (6 non-ignored, 5 ignored for expensive operations, 6 unit tests)
  - Zero clippy warnings
  - Code properly formatted
  - Cross-platform compilation verified (Unix and Windows)

  <!-- START COPILOT CODING AGENT SUFFIX -->

  <details>

  <summary>Original prompt</summary>

  ----

  *This section details on the original issue you should resolve*

  <issue_title>Implement Installation Logic</issue_title>
  <issue_description># Implement Installation Logic (Issue 1-1-4)

  ## Overview

  Implement the installation logic for all 4 dependencies (cargo-machete, OpenTofu, Ansible, LXD) and add the `install` command to the CLI. This completes the dependency installer package by converting bash installation scripts to Rust with structured logging for automation and CI/CD integration.

  **Design Philosophy**: Uses **structured logging only** (tracing crate) - no user-facing `println!()` output. Designed for automation and CI/CD pipelines.

  ## Parent Issue

  [#113](#113) - Create Dependency Installation Package for E2E Tests

  ## Dependencies

  **Depends On**:

  - [#116](#116) - Create Docker Test Infrastructure (Issue 1-1-3)

  **Blocks**:

  - Issue 1-2: Integrate dependency-installer with E2E tests

  ## Objectives

  - [ ] Define `DependencyInstaller` trait for installation abstraction
  - [ ] Convert bash scripts (`scripts/setup/`) to Rust installer implementations
  - [ ] Add `install` command to CLI binary with handler-based architecture
  - [ ] Extend `DependencyManager` to coordinate installation
  - [ ] Extend Docker tests to verify actual installations
  - [ ] Use structured logging (tracing) throughout for observability
  - [ ] Document exit codes and usage patterns

  ## Key Components

  ### DependencyInstaller Trait

  ```rust
  #[async_trait]
  pub trait DependencyInstaller: Send + Sync {
      fn name(&self) -> &str;
      fn dependency(&self) -> Dependency;
      async fn install(&self) -> Result<(), InstallationError>;
      fn requires_sudo(&self) -> bool { false }
  }
  ```

  ### Installer Implementations

  Convert bash scripts to Rust:

  1. **CargoMacheteInstaller** (`scripts/setup/install-cargo-machete.sh`)
     - Uses `cargo install cargo-machete`
     - No sudo required

  2. **OpenTofuInstaller** (`scripts/setup/install-opentofu.sh`)
     - Downloads installer script with curl
     - Runs with sudo
     - Multi-step: download → chmod → execute → cleanup

  3. **AnsibleInstaller** (`scripts/setup/install-ansible.sh`)
     - Uses apt-get package manager
     - Requires sudo

  4. **LxdInstaller** (`scripts/setup/install-lxd.sh`)
     - Uses snap for installation
     - Configures user groups
     - Requires sudo

  ### Extended DependencyManager

  Add installation methods to existing manager:

  ```rust
  impl DependencyManager {
      pub fn get_installer(&self, dep: Dependency) -> Box<dyn DependencyInstaller>;
      pub async fn install(&self, dep: Dependency) -> Result<(), InstallationError>;
      pub async fn install_all(&self) -> Result<Vec<InstallResult>, InstallationError>;
  }
  ```

  ### Install Command Handler

  New handler following existing pattern:

  ```rust
  // src/handlers/install.rs
  pub async fn handle_install(
      manager: &DependencyManager,
      dependency: Option<Dependency>,
  ) -> Result<(), InstallError> {
      // Handler implementation with structured logging
  }
  ```

  ### CLI Command

  Add to existing CLI:

  ```bash
  # Install all dependencies
  dependency-installer install

  # Install specific dependency
  dependency-installer install --dependency opentofu

  # With verbose logging
  dependency-installer install --verbose
  ```

  ### Docker Tests

  Extend testing to verify actual installations:

  ```rust
  // tests/docker_install_command.rs
  #[tokio::test]
  async fn test_install_cargo_machete() {
      // Verify installation in clean container
  }

  #[tokio::test]
  async fn test_install_idempotent() {
      // Install twice, both should succeed
  }

  #[tokio::test]
  async fn test_install_all() {
      // Install all dependencies
  }
  ```

  ## Architecture

  ### Directory Structure

  ```text
  packages/dependency-installer/
  ├── src/
  │   ├── manager.rs            # Add installation methods
  │   ├── detector/             # Existing detection logic
  │   ├── installer/            # NEW: Installation logic
  │   │   ├── mod.rs            # Trait + error types
  │   │   ├── cargo_machete.rs
  │   │   ├── opentofu.rs
  │   │   ├── ansible.rs
  │   │   └── lxd.rs
  │   ├── handlers/             # Extend with install
  │   │   ├── check.rs          # Existing
  │   │   ├── list.rs           # Existing
  │   │   └── install.rs        # NEW
  │   └── cli.rs                # Add Install command
  └── tests/
      └── docker_install_command.rs  # NEW tests
  ```

  ### Handler-Based Architecture

  Following existing pattern:

  ```rust
  // src/app.rs
  match cli.command {
      Commands::Check { dependency } => {
          check::handle_check(&manager, dependency)?;
      }
      Commands::List => {
          list::handle_list(&manager)?;
      }
      Commands::Install { dependency } => {  // NEW
          install::handle_install(&manager, dependency).await?;
      }
  }
  ```

  ## Structured Logging Examples

  All output uses `tracing` crate - no `println!()` statements:

  ### Installing All Dependencies

  ```bash
  $ dependency-installer install
  2...

  </details>

  - Fixes #117

  <!-- START COPILOT CODING AGENT TIPS -->
  ---

  💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more [Copilot coding agent tips](https://gh.io/copilot-coding-agent-tips) in the docs.

ACKs for top commit:
  josecelano:
    ACK 6e0b214

Tree-SHA512: f2117d188b0adfde2e9a7813a0da1db1301b0b071ed2c5f0ef8f0bf5d607e92ea8bbcb49cbe84a9fa548c5ba29c17f217b519c229bbd243379a4bc1d812f6766

Author: josecelano

.github/copilot-instructions.md

@@ -20,7 +20,7 @@ This is a deployment infrastructure proof-of-concept for the Torrust ecosystem.
 ## 📁 Key Directories
 
 - `src/` - Rust source code organized by DDD layers (`domain/`, `application/`, `infrastructure/`, `shared/`)
-- `src/bin/` - Binary executables (linter, E2E tests)
+- `src/bin/` - Binary executables (linter, E2E tests, dependency installer)
 - `data/` - Environment-specific data and source templates
 - `templates/` - Generated template examples and test fixtures
 - `build/` - Generated runtime configurations (git-ignored)
@@ -29,7 +29,9 @@ This is a deployment infrastructure proof-of-concept for the Torrust ecosystem.
 - `docs/decisions/` - Architectural Decision Records (ADRs)
 - `scripts/` - Shell scripts for development tasks
 - `fixtures/` - Test data and keys for development
-- `packages/` - Rust workspace packages (linting tools)
+- `packages/` - Rust workspace packages (see `packages/README.md` for details)
+  - `dependency-installer/` - Dependency detection and installation for development setup
+  - `linting/` - Unified linting framework
 
 ## 📄 Key Configuration Files
 
@@ -103,15 +105,22 @@ These principles should guide all development decisions, code reviews, and featu
 
 ## 🧪 Build & Test
 
+- **Setup Dependencies**: `cargo run --bin dependency-installer install` (sets up required development tools)
+  - **Check dependencies**: `cargo run --bin dependency-installer check` (verifies installation)
+  - **List dependencies**: `cargo run --bin dependency-installer list` (shows all dependencies with status)
+  - Required tools: OpenTofu, Ansible, LXD, cargo-machete
+  - See [`packages/dependency-installer/README.md`](../packages/dependency-installer/README.md) for details
 - **Lint**: `cargo run --bin linter all` (comprehensive - tests stable & nightly toolchains)
   - Individual linters: `cargo run --bin linter {markdown|yaml|toml|cspell|clippy|rustfmt|shellcheck}`
   - Alternative: `./scripts/lint.sh` (wrapper that calls the Rust binary)
 - **Dependencies**: `cargo machete` (mandatory before commits - no unused dependencies)
 - **Build**: `cargo build`
 - **Test**: `cargo test`
 - **Unit Tests**: When writing unit tests, follow conventions described in [`docs/contributing/testing/`](../docs/contributing/testing/)
-- **E2E Tests**: `cargo run --bin e2e-tests-full` (comprehensive - all tests) or individual tests:
+- **E2E Tests**:
+  - `cargo run --bin e2e-tests-full` - Comprehensive tests (⚠️ **LOCAL ONLY** - cannot run on GitHub Actions due to network connectivity issues)
   - `cargo run --bin e2e-provision-tests` - Infrastructure provisioning tests
   - `cargo run --bin e2e-config-tests` - Configuration validation tests
+  - See [`docs/e2e-testing.md`](../docs/e2e-testing.md) for detailed information about CI limitations
 
 Follow the project conventions and ensure all checks pass.

README.md

@@ -64,10 +64,32 @@ This repository uses LXD virtual machines for local virtualization and developme
 
 This is a Rust application that automates deployment infrastructure using OpenTofu and Ansible.
 
-Install the required tools:
+#### Automated Setup (Recommended)
+
+The project provides a dependency installer tool that automatically detects and installs required dependencies:
+
+```bash
+# Install all required dependencies
+cargo run --bin dependency-installer install
+
+# Check which dependencies are installed
+cargo run --bin dependency-installer check
+
+# List all dependencies with status
+cargo run --bin dependency-installer list
+```
+
+The installer supports: **OpenTofu**, **Ansible**, **LXD**, and **cargo-machete**.
+
+For detailed information, see **[📖 Dependency Installer →](packages/dependency-installer/README.md)**.
+
+#### Manual Setup
+
+If you prefer manual installation or need to troubleshoot:
+
+**Check installations:**
 
 ```bash
-# Check installations
 lxd version && tofu version && ansible --version && cargo --version
 ```
 
@@ -76,7 +98,7 @@ lxd version && tofu version && ansible --version && cargo --version
 - **[📖 OpenTofu Setup Guide →](docs/tech-stack/opentofu.md)**
 - **[📖 Ansible Setup Guide →](docs/tech-stack/ansible.md)**
 
-**Quick install:**
+**Quick manual install:**
 
 ```bash
 # Install Rust (if not already installed)

docs/contributing/README.md

@@ -25,7 +25,14 @@ This guide will help you understand our development practices and contribution w
 ## 🚀 Getting Started
 
 1. **Fork and clone** the repository
-2. **Set up your development environment** following the main [README](../../README.md)
+2. **Install dependencies** using the automated installer:
+
+   ```bash
+   cargo run --bin dependency-installer install
+   ```
+
+   See [Dependency Installer](../../packages/dependency-installer/README.md) for details.
+
 3. **Read the branching** guidelines in [branching.md](./branching.md)
 4. **Install and run linters** as described in [linting.md](./linting.md)
 5. **Follow the commit process** outlined in [commit-process.md](./commit-process.md)

docs/e2e-testing.md

@@ -180,7 +180,35 @@ Combines both provision and configuration phases in a single LXD VM for comprehe
 
 ## 🛠️ Prerequisites
 
-### For E2E Provision Tests
+### Automated Setup (Recommended)
+
+The project provides a dependency installer tool that automatically detects and installs required dependencies:
+
+```bash
+# Install all required dependencies
+cargo run --bin dependency-installer install
+
+# Check which dependencies are installed
+cargo run --bin dependency-installer check
+
+# List all dependencies with status
+cargo run --bin dependency-installer list
+```
+
+The installer supports:
+
+- **cargo-machete** - Detects unused Rust dependencies
+- **OpenTofu** - Infrastructure provisioning tool
+- **Ansible** - Configuration management tool
+- **LXD** - VM-based testing infrastructure
+
+For detailed information, see [`packages/dependency-installer/README.md`](../packages/dependency-installer/README.md).
+
+### Manual Setup
+
+If you prefer manual installation or need to troubleshoot:
+
+#### For E2E Provision Tests
 
 1. **LXD installed and configured**
 
@@ -195,7 +223,7 @@ Combines both provision and configuration phases in a single LXD VM for comprehe
    # Installation instructions in docs/tech-stack/opentofu.md
    ```
 
-### For E2E Configuration Tests
+#### For E2E Configuration Tests
 
 1. **Docker installed**
 
@@ -210,10 +238,22 @@ Combines both provision and configuration phases in a single LXD VM for comprehe
    # Installation instructions in docs/tech-stack/ansible.md
    ```
 
-### For Full Local Tests (`e2e-tests-full`)
+#### For Full Local Tests (`e2e-tests-full`)
 
 Requires **all** of the above: LXD, OpenTofu, Docker, and Ansible.
 
+### Verification
+
+After setup (automated or manual), verify all dependencies are available:
+
+```bash
+# Quick check (exit code indicates success/failure)
+cargo run --bin dependency-installer check
+
+# Detailed check with logging
+cargo run --bin dependency-installer check --verbose
+```
+
 ## 🐛 Troubleshooting
 
 ### Test Environment Cleanup

packages/README.md

@@ -0,0 +1,151 @@
+# Torrust Tracker Deployer - Packages
+
+This directory contains reusable Rust workspace packages that support the Torrust Tracker Deployer project. These packages are designed to be modular, maintainable, and potentially reusable across other Torrust projects.
+
+## 📦 Available Packages
+
+### [`dependency-installer/`](./dependency-installer/)
+
+**Purpose**: Dependency detection and installation utilities for development environments
+
+**Key Features**:
+
+- Detects if required development tools are installed (OpenTofu, Ansible, LXD, cargo-machete)
+- Installs missing dependencies automatically
+- Provides CLI for manual and automated use
+- Designed for CI/CD pipelines and automated workflows
+- Uses structured logging (tracing) for observability
+- Exit-code based success/failure indication for automation
+
+**Use Cases**:
+
+- Setting up development environments for humans and AI agents
+- Pre-flight checks in E2E test suites
+- CI/CD pipeline dependency validation
+- Automated development environment provisioning
+
+**Documentation**: See [packages/dependency-installer/README.md](./dependency-installer/README.md)
+
+### [`linting/`](./linting/)
+
+**Purpose**: Unified linting framework for Rust projects
+
+**Key Features**:
+
+- Supports multiple linters: markdown, YAML, TOML, Rust (clippy + rustfmt), shellcheck
+- Pre-built CLI components for easy binary creation
+- Extensible architecture for adding new linters
+- Uses existing configuration files (`.taplo.toml`, `.yamllint.yml`, etc.)
+
+**Use Cases**:
+
+- Enforcing code quality standards
+- Pre-commit validation
+- CI/CD linting pipelines
+- Standardizing linting across multiple projects
+
+**Documentation**: See [packages/linting/README.md](./linting/README.md)
+
+## 🏗️ Package Architecture
+
+All packages in this directory:
+
+- Are part of a Cargo workspace (defined in root `Cargo.toml`)
+- Can be used independently or as library crates
+- Follow the project's development principles (observability, testability, user-friendliness)
+- Provide both CLI binaries and programmatic APIs
+- Use structured logging via the `tracing` crate
+- Follow consistent error handling patterns
+
+## 🚀 Using Packages
+
+### As Library Crates
+
+```rust
+// Add to your Cargo.toml
+[dependencies]
+torrust-linting = { path = "packages/linting" }
+torrust-dependency-installer = { path = "packages/dependency-installer" }
+```
+
+### As CLI Binaries
+
+```bash
+# Run the linter
+cargo run --bin linter all
+
+# Run the dependency installer
+cargo run --bin dependency-installer check
+cargo run --bin dependency-installer install
+```
+
+## 🎯 Package Design Principles
+
+### Automation-First Design
+
+Packages prioritize **automation and CI/CD workflows**:
+
+- **Exit codes** indicate success/failure (0 = success, non-zero = failure)
+- **Structured logging** provides rich context without parsing output
+- **Flags for verbosity** (`--verbose`, `--log-level`) control output detail
+- **Minimal output** by default, detailed only when needed
+
+### Type Safety
+
+- Use strongly-typed enums and structs
+- Leverage Rust's type system for compile-time guarantees
+- Avoid stringly-typed APIs
+
+### Error Handling
+
+- Clear, actionable error messages
+- Preserve error context with source chains
+- Use thiserror for structured error types
+
+### Extensibility
+
+- Easy to add new functionality (linters, dependencies)
+- Plugin-like architecture where appropriate
+- Trait-based abstractions for flexibility
+
+## 📋 Adding New Packages
+
+When creating new packages:
+
+1. **Create package directory** under `packages/`
+2. **Add to workspace** in root `Cargo.toml`:
+
+   ```toml
+   [workspace]
+   members = [
+       "packages/your-new-package",
+       # ...
+   ]
+   ```
+
+3. **Create package README** documenting purpose and usage
+4. **Update this file** to include the new package in the list above
+5. **Follow conventions**:
+   - Use `tracing` for logging
+   - Provide both CLI and library interfaces
+   - Follow project development principles
+   - Add comprehensive tests
+
+## 🔗 Related Documentation
+
+- [Development Principles](../docs/development-principles.md) - Core principles guiding all packages
+- [Error Handling Guide](../docs/contributing/error-handling.md) - Error handling patterns
+- [Testing Conventions](../docs/contributing/testing/) - Testing standards
+- [E2E Testing Guide](../docs/e2e-testing.md) - How packages integrate with E2E tests
+
+## 💡 Future Packages
+
+Potential future packages that could be added:
+
+- **Configuration Management**: Reusable config loading and validation
+- **Template Engine**: Tera template rendering utilities
+- **SSH Client**: SSH operations and connectivity checking
+- **Infrastructure Clients**: OpenTofu, Ansible, LXD client abstractions
+- **Test Utilities**: Common test helpers and fixtures
+
+These packages would further modularize the codebase and improve reusability across the Torrust ecosystem.

packages/dependency-installer/Cargo.toml

@@ -14,15 +14,20 @@ name = "dependency-installer"
 path = "src/bin/dependency-installer.rs"
 
 [dependencies]
+async-trait = "0.1"
 clap = { version = "4.0", features = [ "derive" ] }
 thiserror = "1.0"
+tokio = { version = "1.0", features = [ "full" ] }
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = [ "env-filter" ] }
 
 [dev-dependencies]
 testcontainers = "0.25"
-tokio = { version = "1.0", features = [ "full" ] }
 
 [[test]]
-name = "docker_check_command"
-path = "tests/docker_check_command.rs"
+name = "check_command_docker_integration"
+path = "tests/check_command_docker_integration.rs"
+
+[[test]]
+name = "install_command_docker_integration"
+path = "tests/install_command_docker_integration.rs"