feat: add configurable command timeout with unlimited option support

Author: inureyes

src/cli.rs

@@ -96,6 +96,13 @@ pub struct Cli {
     )]
     pub strict_host_key_checking: String,
 
+    #[arg(
+        long,
+        default_value = "300",
+        help = "Command timeout in seconds (0 for unlimited)"
+    )]
+    pub timeout: u64,
+
     #[arg(trailing_var_arg = true, help = "Command to execute on remote hosts")]
     pub command_args: Vec<String>,
 }

src/commands/download.rs

@@ -165,6 +165,7 @@ pub async fn download_file(
                 Some(params.strict_mode),
                 params.use_agent,
                 params.use_password,
+                None, // Use default timeout for ls command
             )
             .await?;
 

src/commands/exec.rs

@@ -31,6 +31,7 @@ pub struct ExecuteCommandParams<'a> {
     pub use_agent: bool,
     pub use_password: bool,
     pub output_dir: Option<&'a Path>,
+    pub timeout: Option<u64>,
 }
 
 pub async fn execute_command(params: ExecuteCommandParams<'_>) -> Result<()> {
@@ -47,7 +48,8 @@ pub async fn execute_command(params: ExecuteCommandParams<'_>) -> Result<()> {
         params.strict_mode,
         params.use_agent,
         params.use_password,
-    );
+    )
+    .with_timeout(params.timeout);
 
     let results = executor.execute(params.command).await?;
 

src/config.rs

@@ -40,6 +40,7 @@ pub struct Defaults {
     pub port: Option<u16>,
     pub ssh_key: Option<String>,
     pub parallel: Option<usize>,
+    pub timeout: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Default, Clone)]
@@ -132,6 +133,7 @@ pub struct ClusterDefaults {
     pub user: Option<String>,
     pub port: Option<u16>,
     pub ssh_key: Option<String>,
+    pub timeout: Option<u64>,
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
@@ -362,6 +364,18 @@ impl Config {
         self.defaults.ssh_key.clone()
     }
 
+    pub fn get_timeout(&self, cluster_name: Option<&str>) -> Option<u64> {
+        if let Some(cluster_name) = cluster_name {
+            if let Some(cluster) = self.get_cluster(cluster_name) {
+                if let Some(timeout) = cluster.defaults.timeout {
+                    return Some(timeout);
+                }
+            }
+        }
+
+        self.defaults.timeout
+    }
+
     /// Get interactive configuration for a cluster (with fallback to global)
     pub fn get_interactive_config(&self, cluster_name: Option<&str>) -> InteractiveConfig {
         let mut config = self.interactive.clone();

src/executor.rs

@@ -31,6 +31,7 @@ pub struct ParallelExecutor {
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
     use_password: bool,
+    timeout: Option<u64>,
 }
 
 impl ParallelExecutor {
@@ -56,6 +57,7 @@ impl ParallelExecutor {
             strict_mode,
             use_agent: false,
             use_password: false,
+            timeout: None,
         }
     }
 
@@ -73,6 +75,7 @@ impl ParallelExecutor {
             strict_mode,
             use_agent,
             use_password: false,
+            timeout: None,
         }
     }
 
@@ -91,9 +94,15 @@ impl ParallelExecutor {
             strict_mode,
             use_agent,
             use_password,
+            timeout: None,
         }
     }
 
+    pub fn with_timeout(mut self, timeout: Option<u64>) -> Self {
+        self.timeout = timeout;
+        self
+    }
+
     pub async fn execute(&self, command: &str) -> Result<Vec<ExecutionResult>> {
         let semaphore = Arc::new(Semaphore::new(self.max_parallel));
         let multi_progress = MultiProgress::new();
@@ -113,6 +122,7 @@ impl ParallelExecutor {
                 let strict_mode = self.strict_mode;
                 let use_agent = self.use_agent;
                 let use_password = self.use_password;
+                let timeout = self.timeout;
                 let semaphore = Arc::clone(&semaphore);
                 let pb = multi_progress.add(ProgressBar::new_spinner());
                 pb.set_style(style.clone());
@@ -137,6 +147,7 @@ impl ParallelExecutor {
                         strict_mode,
                         use_agent,
                         use_password,
+                        timeout,
                     )
                     .await;
 
@@ -479,6 +490,7 @@ async fn execute_on_node(
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
     use_password: bool,
+    timeout: Option<u64>,
 ) -> Result<CommandResult> {
     let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
 
@@ -491,6 +503,7 @@ async fn execute_on_node(
             Some(strict_mode),
             use_agent,
             use_password,
+            timeout,
         )
         .await
 }

src/main.rs

@@ -212,6 +212,13 @@ async fn main() -> Result<()> {
         }
         _ => {
             // Execute command (default or Exec subcommand)
+            // Determine timeout: CLI argument takes precedence over config
+            let timeout = if cli.timeout > 0 {
+                Some(cli.timeout)
+            } else {
+                config.get_timeout(cli.cluster.as_deref())
+            };
+
             let params = ExecuteCommandParams {
                 nodes,
                 command: &command,
@@ -222,6 +229,7 @@ async fn main() -> Result<()> {
                 use_agent: cli.use_agent,
                 use_password: cli.password,
                 output_dir: cli.output_dir.as_deref(),
+                timeout,
             };
             execute_command(params).await
         }

src/ssh/client.rs

@@ -40,7 +40,7 @@ impl SshClient {
         key_path: Option<&Path>,
         use_agent: bool,
     ) -> Result<CommandResult> {
-        self.connect_and_execute_with_host_check(command, key_path, None, use_agent, false)
+        self.connect_and_execute_with_host_check(command, key_path, None, use_agent, false, None)
             .await
     }
 
@@ -51,6 +51,7 @@ impl SshClient {
         strict_mode: Option<StrictHostKeyChecking>,
         use_agent: bool,
         use_password: bool,
+        timeout_seconds: Option<u64>,
     ) -> Result<CommandResult> {
         let addr = (self.host.as_str(), self.port);
         tracing::debug!("Connecting to {}:{}", self.host, self.port);
@@ -79,14 +80,37 @@ impl SshClient {
         tracing::debug!("Executing command: {}", command);
 
         // Execute command with timeout
-        let command_timeout = Duration::from_secs(300); // 5 minutes default
-        let result = tokio::time::timeout(
-            command_timeout,
-            client.execute(command)
-        )
-        .await
-        .with_context(|| format!("Command execution timeout: The command '{}' did not complete within 5 minutes on {}:{}", command, self.host, self.port))?
-        .with_context(|| format!("Failed to execute command '{}' on {}:{}. The SSH connection was successful but the command could not be executed.", command, self.host, self.port))?;
+        let result = if let Some(timeout_secs) = timeout_seconds {
+            if timeout_secs == 0 {
+                // No timeout (unlimited)
+                tracing::debug!("Executing command with no timeout (unlimited)");
+                client.execute(command)
+                    .await
+                    .with_context(|| format!("Failed to execute command '{}' on {}:{}. The SSH connection was successful but the command could not be executed.", command, self.host, self.port))?
+            } else {
+                // With timeout
+                let command_timeout = Duration::from_secs(timeout_secs);
+                tracing::debug!("Executing command with timeout of {} seconds", timeout_secs);
+                tokio::time::timeout(
+                    command_timeout,
+                    client.execute(command)
+                )
+                .await
+                .with_context(|| format!("Command execution timeout: The command '{}' did not complete within {} seconds on {}:{}", command, timeout_secs, self.host, self.port))?
+                .with_context(|| format!("Failed to execute command '{}' on {}:{}. The SSH connection was successful but the command could not be executed.", command, self.host, self.port))?
+            }
+        } else {
+            // Default timeout of 300 seconds if not specified
+            let command_timeout = Duration::from_secs(300);
+            tracing::debug!("Executing command with default timeout of 300 seconds");
+            tokio::time::timeout(
+                command_timeout,
+                client.execute(command)
+            )
+            .await
+            .with_context(|| format!("Command execution timeout: The command '{}' did not complete within 5 minutes on {}:{}", command, self.host, self.port))?
+            .with_context(|| format!("Failed to execute command '{}' on {}:{}. The SSH connection was successful but the command could not be executed.", command, self.host, self.port))?
+        };
 
         tracing::debug!(
             "Command execution completed with status: {}",

tests/timeout_test.rs

@@ -0,0 +1,71 @@
+use bssh::config::Config;
+
+#[tokio::test]
+async fn test_config_timeout_parsing() {
+    let yaml = r#"
+defaults:
+  timeout: 120
+
+clusters:
+  production:
+    nodes:
+      - host1.example.com
+    timeout: 60
+  
+  staging:
+    nodes:
+      - host2.example.com
+"#;
+
+    let config: Config = serde_yaml::from_str(yaml).unwrap();
+
+    // Test default timeout
+    assert_eq!(config.defaults.timeout, Some(120));
+
+    // Test cluster-specific timeout
+    assert_eq!(config.get_timeout(Some("production")), Some(60));
+
+    // Test cluster without timeout (falls back to default)
+    assert_eq!(config.get_timeout(Some("staging")), Some(120));
+
+    // Test unknown cluster (falls back to default)
+    assert_eq!(config.get_timeout(Some("unknown")), Some(120));
+
+    // Test no cluster specified (uses default)
+    assert_eq!(config.get_timeout(None), Some(120));
+}
+
+#[tokio::test]
+async fn test_config_no_timeout() {
+    let yaml = r#"
+clusters:
+  production:
+    nodes:
+      - host1.example.com
+"#;
+
+    let config: Config = serde_yaml::from_str(yaml).unwrap();
+
+    // Test no timeout configured anywhere
+    assert_eq!(config.defaults.timeout, None);
+    assert_eq!(config.get_timeout(Some("production")), None);
+}
+
+#[tokio::test]
+async fn test_config_zero_timeout() {
+    let yaml = r#"
+defaults:
+  timeout: 0
+
+clusters:
+  production:
+    nodes:
+      - host1.example.com
+"#;
+
+    let config: Config = serde_yaml::from_str(yaml).unwrap();
+
+    // Test timeout 0 (unlimited)
+    assert_eq!(config.defaults.timeout, Some(0));
+    assert_eq!(config.get_timeout(Some("production")), Some(0));
+}