Merge #108: refactor: [#107] centralize UserOutput via dependency injection

75af108 refactor: [#107] extract DestroyCommandController with private step methods (Jose Celano)
9730bd0 refactor: [#107] apply GitHub Copilot PR review suggestions (Jose Celano)
b49bcc0 refactor: [#107] simplify error handling with From trait for ProgressReporterError (Jose Celano)
cb10deb refactor: [#107] replace mutex panics with proper error handling (Jose Celano)
f0704ec refactor: [#107] extract test setup helper in factory module (Jose Celano)
b9212ac refactor: [#107] extract test setup helper to reduce duplication (Jose Celano)
38878bb refactor: [#107] remove unnecessary report_error wrapper function (Jose Celano)
d06f3ed refactor: [#107] eliminate duplicate CommandContext creation (Jose Celano)
c5de285 refactor: [#107] centralize UserOutput via dependency injection (Jose Celano)

Pull request description:

  ## Summary

  This PR centralizes `UserOutput` management via dependency injection, providing better control over output formatting and reducing duplication throughout the codebase.

  ## Changes

  ### Core Changes
  - ✅ Add `AppContainer` for centralized dependency management (`src/bootstrap/container.rs`)
  - ✅ Update all command handlers to accept `&Arc<Mutex<UserOutput>>`
  - ✅ Remove `UserOutput` cloning throughout command execution
  - ✅ Ensure thread-safe shared ownership of output stream

  ### Documentation
  - ✅ Update all documentation examples to use `Arc<Mutex<UserOutput>>`
  - ✅ Fix all doc tests to compile with new API (234 passing)

  ### Testing
  - ✅ Update all tests to use the new pattern
  - ✅ All pre-commit checks passing

  ## Benefits

  1. **Centralized Control**: Single point of creation for UserOutput
  2. **Thread Safety**: Proper Arc<Mutex<>> wrapper ensures safe concurrent access
  3. **Reduced Duplication**: Eliminates cloning throughout the codebase
  4. **Better Testing**: Easier to inject mock outputs for testing

  ## Files Changed (20 files)

  - `src/bootstrap/app.rs` - Updated to use AppContainer
  - `src/bootstrap/container.rs` - **NEW** - Dependency injection container
  - `src/bootstrap/mod.rs` - Module updates
  - `src/presentation/commands/context.rs` - Updated API and docs
  - `src/presentation/commands/create/*` - Updated create command handlers
  - `src/presentation/commands/destroy/*` - Updated destroy command handlers
  - `src/presentation/commands/factory.rs` - Updated factory methods
  - `src/presentation/commands/mod.rs` - Updated command execution
  - `src/presentation/progress.rs` - Updated progress reporting
  - Tests updated across all command modules

  ## Status

  - [x] All tests passing
  - [x] Documentation updated
  - [x] Pre-commit checks passing
  - [x] Additional refactors planned (keeping as draft)

  ## Related

  Closes #107

ACKs for top commit:
  josecelano:
    ACK 75af108

Tree-SHA512: eeeb255bbf2f30fae9f0f1b68a94ba9cae326c74a47476a747831500b1e918ef234a30a3bf0545a891cb3d8ee1579e371628f418175559c85acd35ed73e71c73

Author: josecelano

src/bootstrap/app.rs

@@ -27,8 +27,9 @@ use crate::{bootstrap, presentation};
 /// This function serves as the application bootstrap, handling:
 /// 1. CLI argument parsing (delegated to presentation layer)
 /// 2. Logging initialization using `LoggingConfig`
-/// 3. Command execution (delegated to presentation layer)
-/// 4. Error handling and exit code management
+/// 3. Service container creation for dependency injection
+/// 4. Command execution (delegated to presentation layer)
+/// 5. Error handling and exit code management
 ///
 /// # Panics
 ///
@@ -54,10 +55,15 @@ pub fn run() {
         "Application started"
     );
 
+    // Initialize service container for dependency injection
+    let container = bootstrap::Container::new();
+
     match cli.command {
         Some(command) => {
-            if let Err(e) = presentation::execute(command, &cli.global.working_dir) {
-                presentation::handle_error(&e);
+            if let Err(e) =
+                presentation::execute(command, &cli.global.working_dir, &container.user_output())
+            {
+                presentation::handle_error(&e, &container.user_output());
                 std::process::exit(1);
             }
         }

src/bootstrap/container.rs

@@ -0,0 +1,103 @@
+//! Application Service Container
+//!
+//! This module provides centralized initialization of application-wide services
+//! that need consistent configuration across the entire application.
+
+use std::sync::{Arc, Mutex};
+
+use crate::presentation::commands::constants::DEFAULT_VERBOSITY;
+use crate::presentation::user_output::UserOutput;
+
+/// Application service container
+///
+/// Holds shared services initialized during application bootstrap.
+/// Services are wrapped in `Arc<Mutex<T>>` for thread-safe shared ownership
+/// with interior mutability across the application.
+///
+/// # Example
+///
+/// ```rust
+/// use torrust_tracker_deployer_lib::bootstrap::container::Container;
+///
+/// let container = Container::new();
+/// let user_output = container.user_output();
+/// user_output.lock().unwrap().success("Operation completed");
+/// ```
+#[derive(Clone)]
+pub struct Container {
+    user_output: Arc<Mutex<UserOutput>>,
+}
+
+impl Container {
+    /// Create a new container with initialized services
+    ///
+    /// Uses `DEFAULT_VERBOSITY` for user output. In the future, this may
+    /// accept a verbosity parameter from CLI flags.
+    #[must_use]
+    pub fn new() -> Self {
+        let user_output = Arc::new(Mutex::new(UserOutput::new(DEFAULT_VERBOSITY)));
+
+        Self { user_output }
+    }
+
+    /// Get shared reference to user output service
+    ///
+    /// Returns an `Arc<Mutex<UserOutput>>` that can be cheaply cloned and shared
+    /// across threads and function calls. Lock the mutex to access the user output.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use torrust_tracker_deployer_lib::bootstrap::container::Container;
+    ///
+    /// let container = Container::new();
+    /// let user_output = container.user_output();
+    /// user_output.lock().unwrap().success("Operation completed");
+    /// ```
+    #[must_use]
+    pub fn user_output(&self) -> Arc<Mutex<UserOutput>> {
+        Arc::clone(&self.user_output)
+    }
+}
+
+impl Default for Container {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_should_create_container_with_user_output() {
+        let container = Container::new();
+        let user_output = container.user_output();
+
+        // Verify we can get the user_output service
+        assert!(Arc::strong_count(&user_output) >= 1);
+    }
+
+    #[test]
+    fn it_should_return_cloned_arc_on_user_output_access() {
+        let container = Container::new();
+        let user_output1 = container.user_output();
+        let user_output2 = container.user_output();
+
+        // Both should point to the same UserOutput instance
+        assert!(Arc::ptr_eq(&user_output1, &user_output2));
+    }
+
+    #[test]
+    fn it_should_be_clonable() {
+        let container1 = Container::new();
+        let container2 = container1.clone();
+
+        let user_output1 = container1.user_output();
+        let user_output2 = container2.user_output();
+
+        // Cloned containers should share the same UserOutput
+        assert!(Arc::ptr_eq(&user_output1, &user_output2));
+    }
+}

src/bootstrap/mod.rs

@@ -1,17 +1,20 @@
 //! Bootstrap Module
 //!
 //! This module contains application initialization and bootstrap concerns.
-//! It handles application lifecycle, logging setup, and help display.
+//! It handles application lifecycle, logging setup, help display, and service container.
 //!
 //! ## Modules
 //!
 //! - `app` - Main application bootstrap and entry point logic
+//! - `container` - Application service container for dependency injection
 //! - `help` - Help and usage information display
 //! - `logging` - Logging configuration and initialization
 
 pub mod app;
+pub mod container;
 pub mod help;
 pub mod logging;
 
 // Re-export commonly used types for convenience
+pub use container::Container;
 pub use logging::{LogFormat, LogOutput, LoggingBuilder, LoggingConfig};