feat: add SSH agent authentication support with auto-detection

Author: inureyes

README.md

@@ -8,6 +8,7 @@ A high-performance parallel SSH command execution tool for cluster management, b
 - **Cluster Management**: Define and manage node clusters via configuration files
 - **Progress Tracking**: Real-time progress indicators for each node
 - **Flexible Authentication**: Support for SSH keys and SSH agent
+- **Host Key Verification**: Secure host key checking with known_hosts support
 - **Cross-Platform**: Works on Linux and macOS
 
 ## Installation
@@ -30,6 +31,9 @@ bssh -c production "df -h"
 # With custom SSH key
 bssh -c staging -i ~/.ssh/custom_key "systemctl status nginx"
 
+# Use SSH agent for authentication
+bssh --use-agent -c production "systemctl status nginx"
+
 # Limit parallel connections
 bssh -c production --parallel 5 "apt update"
 ```
@@ -110,16 +114,18 @@ clusters:
 
 ```
 Options:
-  -H, --hosts <HOSTS>           Comma-separated list of hosts
-  -c, --cluster <CLUSTER>       Cluster name from configuration
-  --config <CONFIG>             Config file path [default: ~/.bssh/config.yaml]
-  -u, --user <USER>             Default username for SSH
-  -i, --identity <IDENTITY>     SSH private key file
-  -p, --parallel <PARALLEL>     Max parallel connections [default: 10]
-  --output-dir <OUTPUT_DIR>     Output directory for results
-  -v, --verbose                 Increase verbosity (-v, -vv, -vvv)
-  -h, --help                    Print help
-  -V, --version                 Print version
+  -H, --hosts <HOSTS>                     Comma-separated list of hosts
+  -c, --cluster <CLUSTER>                 Cluster name from configuration
+  --config <CONFIG>                       Config file path [default: ~/.bssh/config.yaml]
+  -u, --user <USER>                       Default username for SSH
+  -i, --identity <IDENTITY>               SSH private key file
+  -A, --use-agent                         Use SSH agent for authentication
+  --strict-host-key-checking <MODE>       Host key checking mode [yes|no|accept-new] [default: accept-new]
+  -p, --parallel <PARALLEL>               Max parallel connections [default: 10]
+  --output-dir <OUTPUT_DIR>               Output directory for results
+  -v, --verbose                           Increase verbosity (-v, -vv, -vvv)
+  -h, --help                              Print help
+  -V, --version                           Print version
 ```
 
 ## Examples
@@ -178,5 +184,12 @@ Licensed under the Apache License, Version 2.0
 ## Changelog
 
 ### Recent Updates
-- **v0.2.0 (2025/08/21):** Backend.AI multi-node session support with automatic cluster detection and SSH port 2200
+- **v0.2.0 (2025/08/21):** 
+  - Backend.AI multi-node session support with automatic cluster detection
+  - SSH agent authentication support with auto-detection
+  - Host key verification with StrictHostKeyChecking modes
+  - Environment variable expansion in configuration (${VAR})
+  - Connection and execution timeouts
+  - Fixed list command to work without host specification
+  - Basic SCP file copy support
 - **v0.1.0 (2025/08/21):** Initial release with parallel SSH execution using async-ssh2-tokio 

src/cli.rs

@@ -50,6 +50,13 @@ pub struct Cli {
     #[arg(short = 'i', long, help = "SSH private key file path")]
     pub identity: Option<PathBuf>,
 
+    #[arg(
+        short = 'A',
+        long,
+        help = "Use SSH agent for authentication (Unix/Linux/macOS only)"
+    )]
+    pub use_agent: bool,
+
     #[arg(
         short = 'p',
         long,

src/executor.rs

@@ -27,6 +27,7 @@ pub struct ParallelExecutor {
     max_parallel: usize,
     key_path: Option<String>,
     strict_mode: StrictHostKeyChecking,
+    use_agent: bool,
 }
 
 impl ParallelExecutor {
@@ -50,6 +51,23 @@ impl ParallelExecutor {
             max_parallel,
             key_path,
             strict_mode,
+            use_agent: false,
+        }
+    }
+
+    pub fn new_with_strict_mode_and_agent(
+        nodes: Vec<Node>,
+        max_parallel: usize,
+        key_path: Option<String>,
+        strict_mode: StrictHostKeyChecking,
+        use_agent: bool,
+    ) -> Self {
+        Self {
+            nodes,
+            max_parallel,
+            key_path,
+            strict_mode,
+            use_agent,
         }
     }
 
@@ -70,6 +88,7 @@ impl ParallelExecutor {
                 let command = command.to_string();
                 let key_path = self.key_path.clone();
                 let strict_mode = self.strict_mode;
+                let use_agent = self.use_agent;
                 let semaphore = Arc::clone(&semaphore);
                 let pb = multi_progress.add(ProgressBar::new_spinner());
                 pb.set_style(style.clone());
@@ -82,9 +101,14 @@ impl ParallelExecutor {
 
                     pb.set_message("Executing command...");
 
-                    let result =
-                        execute_on_node(node.clone(), &command, key_path.as_deref(), strict_mode)
-                            .await;
+                    let result = execute_on_node(
+                        node.clone(),
+                        &command,
+                        key_path.as_deref(),
+                        strict_mode,
+                        use_agent,
+                    )
+                    .await;
 
                     match &result {
                         Ok(cmd_result) => {
@@ -141,6 +165,7 @@ impl ParallelExecutor {
                 let remote_path = remote_path.to_string();
                 let key_path = self.key_path.clone();
                 let strict_mode = self.strict_mode;
+                let use_agent = self.use_agent;
                 let semaphore = Arc::clone(&semaphore);
                 let pb = multi_progress.add(ProgressBar::new_spinner());
                 pb.set_style(style.clone());
@@ -159,6 +184,7 @@ impl ParallelExecutor {
                         &remote_path,
                         key_path.as_deref(),
                         strict_mode,
+                        use_agent,
                     )
                     .await;
 
@@ -198,13 +224,14 @@ async fn execute_on_node(
     command: &str,
     key_path: Option<&str>,
     strict_mode: StrictHostKeyChecking,
+    use_agent: bool,
 ) -> Result<CommandResult> {
     let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
 
     let key_path = key_path.map(Path::new);
 
     client
-        .connect_and_execute_with_host_check(command, key_path, Some(strict_mode))
+        .connect_and_execute_with_host_check(command, key_path, Some(strict_mode), use_agent)
         .await
 }
 
@@ -214,13 +241,20 @@ async fn copy_to_node(
     remote_path: &str,
     key_path: Option<&str>,
     strict_mode: StrictHostKeyChecking,
+    use_agent: bool,
 ) -> Result<()> {
     let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
 
     let key_path = key_path.map(Path::new);
 
     client
-        .copy_file(local_path, remote_path, key_path, Some(strict_mode))
+        .copy_file(
+            local_path,
+            remote_path,
+            key_path,
+            Some(strict_mode),
+            use_agent,
+        )
         .await
 }
 

src/main.rs

@@ -63,7 +63,14 @@ async fn main() -> Result<()> {
     // Handle remaining commands
     match cli.command {
         Some(Commands::Ping) => {
-            ping_nodes(nodes, cli.parallel, cli.identity.as_deref(), strict_mode).await?;
+            ping_nodes(
+                nodes,
+                cli.parallel,
+                cli.identity.as_deref(),
+                strict_mode,
+                cli.use_agent,
+            )
+            .await?;
         }
         Some(Commands::Copy {
             source,
@@ -76,6 +83,7 @@ async fn main() -> Result<()> {
                 cli.parallel,
                 cli.identity.as_deref(),
                 strict_mode,
+                cli.use_agent,
             )
             .await?;
         }
@@ -88,6 +96,7 @@ async fn main() -> Result<()> {
                 cli.identity.as_deref(),
                 cli.verbose > 0,
                 strict_mode,
+                cli.use_agent,
             )
             .await?;
         }
@@ -154,12 +163,18 @@ async fn ping_nodes(
     max_parallel: usize,
     key_path: Option<&Path>,
     strict_mode: StrictHostKeyChecking,
+    use_agent: bool,
 ) -> Result<()> {
     println!("Pinging {} nodes...\n", nodes.len());
 
     let key_path = key_path.map(|p| p.to_string_lossy().to_string());
-    let executor =
-        ParallelExecutor::new_with_strict_mode(nodes.clone(), max_parallel, key_path, strict_mode);
+    let executor = ParallelExecutor::new_with_strict_mode_and_agent(
+        nodes.clone(),
+        max_parallel,
+        key_path,
+        strict_mode,
+        use_agent,
+    );
 
     let results = executor.execute("echo 'pong'").await?;
 
@@ -191,12 +206,18 @@ async fn execute_command(
     key_path: Option<&Path>,
     verbose: bool,
     strict_mode: StrictHostKeyChecking,
+    use_agent: bool,
 ) -> Result<()> {
     println!("Executing command on {} nodes: {}\n", nodes.len(), command);
 
     let key_path = key_path.map(|p| p.to_string_lossy().to_string());
-    let executor =
-        ParallelExecutor::new_with_strict_mode(nodes, max_parallel, key_path, strict_mode);
+    let executor = ParallelExecutor::new_with_strict_mode_and_agent(
+        nodes,
+        max_parallel,
+        key_path,
+        strict_mode,
+        use_agent,
+    );
 
     let results = executor.execute(command).await?;
 
@@ -225,6 +246,7 @@ async fn copy_file(
     max_parallel: usize,
     key_path: Option<&Path>,
     strict_mode: StrictHostKeyChecking,
+    use_agent: bool,
 ) -> Result<()> {
     // Check if source file exists
     if !source.exists() {
@@ -244,8 +266,13 @@ async fn copy_file(
     );
 
     let key_path = key_path.map(|p| p.to_string_lossy().to_string());
-    let executor =
-        ParallelExecutor::new_with_strict_mode(nodes, max_parallel, key_path, strict_mode);
+    let executor = ParallelExecutor::new_with_strict_mode_and_agent(
+        nodes,
+        max_parallel,
+        key_path,
+        strict_mode,
+        use_agent,
+    );
 
     let results = executor.copy_file(source, destination).await?;