style: apply cargo fmt to all source files

Author: abdoufermat5

src/cli/commands/alias.rs

@@ -1,16 +1,13 @@
 //! Alias command implementation - manage connection aliases
 
+use crate::cli::utils::fuzzy_select_connection;
 use crate::config::AppConfig;
 use crate::database::Database;
-use crate::cli::utils::fuzzy_select_connection;
 use crate::services::SshService;
 use anyhow::{bail, Result};
 
 /// Execute the alias command
-pub async fn execute(
-    action: AliasAction,
-    config: AppConfig,
-) -> Result<()> {
+pub async fn execute(action: AliasAction, config: AppConfig) -> Result<()> {
     let db = Database::new(&config)?;
 
     match action {
@@ -92,7 +89,9 @@ async fn list_aliases(db: &Database, target: Option<&str>, config: &AppConfig) -
         let connection = if let Some(conn) = db.get_connection(target_name)? {
             conn
         } else {
-            match fuzzy_select_connection(&ssh_service, target_name, "show aliases for", true).await? {
+            match fuzzy_select_connection(&ssh_service, target_name, "show aliases for", true)
+                .await?
+            {
                 Some(conn) => conn,
                 None => {
                     bail!("No connection found matching '{}'", target_name);
@@ -104,7 +103,10 @@ async fn list_aliases(db: &Database, target: Option<&str>, config: &AppConfig) -
 
         if aliases.is_empty() {
             println!("📝 No aliases for connection '{}'", connection.name);
-            println!("   Use 'bssh alias add <alias> {}' to create one", connection.name);
+            println!(
+                "   Use 'bssh alias add <alias> {}' to create one",
+                connection.name
+            );
         } else {
             println!("📝 Aliases for '{}':", connection.name);
             for alias in &aliases {

src/cli/commands/backup.rs

@@ -6,7 +6,7 @@ use tracing::info;
 
 pub async fn execute(output: Option<String>, config: AppConfig) -> Result<()> {
     let db_path = &config.database_path;
-    
+
     if !db_path.exists() {
         anyhow::bail!("Database file does not exist at {:?}", db_path);
     }
@@ -17,16 +17,22 @@ pub async fn execute(output: Option<String>, config: AppConfig) -> Result<()> {
         let parent = db_path.parent().unwrap_or_else(|| std::path::Path::new(""));
         let backups_dir = parent.join("backups");
         fs::create_dir_all(&backups_dir).context("Failed to create backups directory")?;
-        
+
         let timestamp = chrono::Local::now().format("%Y-%m-%d-%H%M%S");
         backups_dir.join(format!("backup-{}.db", timestamp))
     };
 
-    info!("Backing up database from {:?} to {:?}", db_path, backup_path);
-    
+    info!(
+        "Backing up database from {:?} to {:?}",
+        db_path, backup_path
+    );
+
     fs::copy(db_path, &backup_path).context("Failed to copy database file")?;
-    
-    println!("✅ Database successfully backed up to: {}", backup_path.display());
-    
+
+    println!(
+        "✅ Database successfully backed up to: {}",
+        backup_path.display()
+    );
+
     Ok(())
 }

src/cli/commands/close.rs

@@ -1,8 +1,8 @@
 //! Close command implementation - manage active sessions
 
+use crate::cli::utils::confirm;
 use crate::config::AppConfig;
 use crate::database::Database;
-use crate::cli::utils::confirm;
 use anyhow::Result;
 use nix::sys::signal::{kill, Signal};
 use nix::unistd::Pid;
@@ -43,17 +43,26 @@ fn list_active_sessions(db: &Database) -> Result<()> {
     }
 
     println!("📋 Active Sessions\n");
-    println!("{:<20} {:<10} {:<25} DURATION", "CONNECTION", "PID", "STARTED");
+    println!(
+        "{:<20} {:<10} {:<25} DURATION",
+        "CONNECTION", "PID", "STARTED"
+    );
     println!("{}", "─".repeat(70));
 
     for (conn_name, pid, started_at) in &sessions {
         let duration = chrono::Utc::now().signed_duration_since(*started_at);
         let duration_str = format_duration(duration);
-        let pid_str = pid.map(|p| p.to_string()).unwrap_or_else(|| "-".to_string());
-        
+        let pid_str = pid
+            .map(|p| p.to_string())
+            .unwrap_or_else(|| "-".to_string());
+
         // Check if process is actually running
         let status = if let Some(p) = pid {
-            if is_process_running(*p) { "🟢" } else { "⚠️ stale" }
+            if is_process_running(*p) {
+                "🟢"
+            } else {
+                "⚠️ stale"
+            }
         } else {
             "❓"
         };
@@ -86,7 +95,12 @@ fn close_session(db: &Database, target: &str, force: bool) -> Result<()> {
     for (session_id, conn_name, pid, _) in sessions {
         if let Some(p) = pid {
             if is_process_running(p) {
-                if !force && !confirm(&format!("Close session for '{}' (PID {})?", conn_name, p), true)? {
+                if !force
+                    && !confirm(
+                        &format!("Close session for '{}' (PID {})?", conn_name, p),
+                        true,
+                    )?
+                {
                     println!("Skipped.");
                     continue;
                 }
@@ -102,7 +116,10 @@ fn close_session(db: &Database, target: &str, force: bool) -> Result<()> {
                 }
             } else {
                 // Process not running, just update the record
-                println!("⚠️  Session '{}' (PID {}) is stale, cleaning up...", conn_name, p);
+                println!(
+                    "⚠️  Session '{}' (PID {}) is stale, cleaning up...",
+                    conn_name, p
+                );
                 db.mark_session_terminated(&session_id, -1)?;
             }
         } else {
@@ -123,7 +140,12 @@ fn close_all_sessions(db: &Database, force: bool) -> Result<()> {
         return Ok(());
     }
 
-    if !force && !confirm(&format!("Close all {} active sessions?", sessions.len()), false)? {
+    if !force
+        && !confirm(
+            &format!("Close all {} active sessions?", sessions.len()),
+            false,
+        )?
+    {
         println!("Cancelled.");
         return Ok(());
     }
@@ -146,7 +168,10 @@ fn close_all_sessions(db: &Database, force: bool) -> Result<()> {
     // Mark all as terminated in DB
     db.mark_all_sessions_terminated()?;
 
-    println!("✅ Closed {} sessions, cleaned {} stale records", closed, cleaned);
+    println!(
+        "✅ Closed {} sessions, cleaned {} stale records",
+        closed, cleaned
+    );
 
     Ok(())
 }

src/cli/commands/config.rs

@@ -16,7 +16,7 @@ pub async fn execute(
 ) -> Result<()> {
     info!("Updating application configuration");
 
-    // Handle bastion settings: 
+    // Handle bastion settings:
     // - If --clear-bastion is passed, set to Some(None) to clear
     // - If a value is provided, set to Some(Some(value))
     // - Otherwise, set to None (don't change)

src/cli/commands/duplicate.rs

@@ -8,7 +8,10 @@ pub async fn execute(source: String, new_name: String, config: AppConfig) -> Res
     let ssh_service = SshService::new(config)?;
 
     // Try to find the exact connection by name or alias first
-    let mut target_conn = ssh_service.get_connection(&source).await.unwrap_or_default();
+    let mut target_conn = ssh_service
+        .get_connection(&source)
+        .await
+        .unwrap_or_default();
 
     // Fall back to fuzzy search if not found
     if target_conn.is_none() {
@@ -25,26 +28,36 @@ pub async fn execute(source: String, new_name: String, config: AppConfig) -> Res
     };
 
     // Check if new name already exists
-    if ssh_service.get_connection(&new_name).await.unwrap_or_default().is_some() {
+    if ssh_service
+        .get_connection(&new_name)
+        .await
+        .unwrap_or_default()
+        .is_some()
+    {
         anyhow::bail!("A connection with the name '{}' already exists", new_name);
     }
 
     info!("Duplicating connection {} to {}", original.name, new_name);
-    
-    ssh_service.add_connection(
-        new_name.clone(),
-        original.host.clone(),
-        Some(original.user.clone()),
-        Some(original.port),
-        Some(original.use_kerberos),
-        original.bastion.clone(),
-        original.bastion.is_none(),
-        original.bastion_user.clone(),
-        original.key_path.clone(),
-        original.tags.clone(),
-    ).await?;
-    
-    println!("✅ Successfully duplicated '{}' to '{}'", original.name, new_name);
-    
+
+    ssh_service
+        .add_connection(
+            new_name.clone(),
+            original.host.clone(),
+            Some(original.user.clone()),
+            Some(original.port),
+            Some(original.use_kerberos),
+            original.bastion.clone(),
+            original.bastion.is_none(),
+            original.bastion_user.clone(),
+            original.key_path.clone(),
+            original.tags.clone(),
+        )
+        .await?;
+
+    println!(
+        "✅ Successfully duplicated '{}' to '{}'",
+        original.name, new_name
+    );
+
     Ok(())
 }

src/cli/commands/env.rs

@@ -58,7 +58,11 @@ fn list_environments() -> Result<()> {
 fn use_environment(name: &str) -> Result<()> {
     let env_dir = get_environments_dir().join(name);
     if !env_dir.exists() {
-        anyhow::bail!("Environment '{}' does not exist. Use `bayesian-ssh env create {}` to create it.", name, name);
+        anyhow::bail!(
+            "Environment '{}' does not exist. Use `bayesian-ssh env create {}` to create it.",
+            name,
+            name
+        );
     }
 
     AppConfig::set_active_env(name)?;
@@ -73,7 +77,7 @@ fn create_environment(name: &str) -> Result<()> {
     }
 
     std::fs::create_dir_all(&env_dir)?;
-    
+
     // Create default config for this environment
     let config = AppConfig::default_for_env(name);
     config.save()?;
@@ -86,7 +90,10 @@ fn create_environment(name: &str) -> Result<()> {
 fn remove_environment(name: &str) -> Result<()> {
     let active_env = AppConfig::get_active_env();
     if name == active_env {
-        anyhow::bail!("Cannot remove the currently active environment '{}'. Change environment first.", name);
+        anyhow::bail!(
+            "Cannot remove the currently active environment '{}'. Change environment first.",
+            name
+        );
     }
 
     if name == "default" {
@@ -99,7 +106,7 @@ fn remove_environment(name: &str) -> Result<()> {
     }
 
     std::fs::remove_dir_all(&env_dir).context("Failed to securely delete environment directory")?;
-    
+
     println!("🗑️ Removed environment '{}'", name);
     info!("Removed environment {}", name);
     Ok(())

src/cli/commands/export.rs

@@ -45,24 +45,34 @@ pub async fn execute(
 
     let exported_content = match format {
         ExportFormat::Json => serde_json::to_string_pretty(&connections)?,
-        ExportFormat::Toml => toml::to_string_pretty(&ConnectionsWrapper { connections: connections.clone() })?,
+        ExportFormat::Toml => toml::to_string_pretty(&ConnectionsWrapper {
+            connections: connections.clone(),
+        })?,
         ExportFormat::SshConfig => generate_ssh_config(&connections),
     };
 
     if let Some(output_path) = output {
         let expanded_path = expand_tilde(&output_path);
         let path = std::path::Path::new(&expanded_path);
-        
+
         if let Some(parent) = path.parent() {
             if !parent.exists() {
                 std::fs::create_dir_all(parent).context("Failed to create parent directories")?;
             }
         }
-        
+
         let mut file = File::create(&expanded_path).context("Failed to create output file")?;
         file.write_all(exported_content.as_bytes())?;
-        info!("Exported {} connections to {}", connections.len(), expanded_path);
-        println!("✅ Exported {} connections to {}", connections.len(), expanded_path);
+        info!(
+            "Exported {} connections to {}",
+            connections.len(),
+            expanded_path
+        );
+        println!(
+            "✅ Exported {} connections to {}",
+            connections.len(),
+            expanded_path
+        );
     } else {
         println!("{}", exported_content);
     }
@@ -84,21 +94,24 @@ fn generate_ssh_config(connections: &[Connection]) -> String {
         config.push_str(&format!("    HostName {}\n", conn.host));
         config.push_str(&format!("    User {}\n", conn.user));
         config.push_str(&format!("    Port {}\n", conn.port));
-        
+
         if let Some(key) = &conn.key_path {
             config.push_str(&format!("    IdentityFile {}\n", key));
         }
 
         if let Some(bastion) = &conn.bastion {
             let bastion_user = conn.bastion_user.as_deref().unwrap_or(&conn.user);
-            config.push_str(&format!("    ProxyCommand ssh -W %h:%p {}@{}\n", bastion_user, bastion));
+            config.push_str(&format!(
+                "    ProxyCommand ssh -W %h:%p {}@{}\n",
+                bastion_user, bastion
+            ));
         }
-        
+
         if conn.use_kerberos {
             config.push_str("    GSSAPIAuthentication yes\n");
             config.push_str("    GSSAPIDelegateCredentials yes\n");
         }
-        
+
         config.push('\n');
     }
 

src/cli/commands/groups.rs

@@ -9,8 +9,11 @@ pub async fn execute(group_name: Option<String>, config: AppConfig) -> Result<()
 
     if let Some(tag) = group_name {
         // List connections in the specific group
-        let filtered: Vec<_> = connections.into_iter().filter(|c| c.tags.contains(&tag)).collect();
-        
+        let filtered: Vec<_> = connections
+            .into_iter()
+            .filter(|c| c.tags.contains(&tag))
+            .collect();
+
         if filtered.is_empty() {
             println!("No connections found in group '{}'", tag);
         } else {
@@ -22,7 +25,7 @@ pub async fn execute(group_name: Option<String>, config: AppConfig) -> Result<()
     } else {
         // List all groups and their connection counts
         let mut group_counts: HashMap<String, usize> = HashMap::new();
-        
+
         for conn in connections {
             for tag in conn.tags {
                 *group_counts.entry(tag).or_insert(0) += 1;
@@ -35,9 +38,13 @@ pub async fn execute(group_name: Option<String>, config: AppConfig) -> Result<()
             println!("Available groups:");
             let mut groups: Vec<_> = group_counts.into_iter().collect();
             groups.sort_by(|a, b| a.0.cmp(&b.0)); // Sort alphabetically
-            
+
             for (tag, count) in groups {
-                let suffix = if count == 1 { "connection" } else { "connections" };
+                let suffix = if count == 1 {
+                    "connection"
+                } else {
+                    "connections"
+                };
                 println!("  - {} ({} {})", tag, count, suffix);
             }
             println!("\nUse `bssh groups <name>` to see connections in a group.");