feat: add native SFTP directory upload/download operations and remove unused code

Author: inureyes

src/executor.rs

@@ -433,18 +433,58 @@ async fn upload_to_node(
 
     let key_path = key_path.map(Path::new);
 
+    // Check if the local path is a directory
+    if local_path.is_dir() {
+        client
+            .upload_dir(
+                local_path,
+                remote_path,
+                key_path,
+                Some(strict_mode),
+                use_agent,
+            )
+            .await
+    } else {
+        client
+            .upload_file(
+                local_path,
+                remote_path,
+                key_path,
+                Some(strict_mode),
+                use_agent,
+            )
+            .await
+    }
+}
+
+async fn download_from_node(
+    node: Node,
+    remote_path: &str,
+    local_path: &Path,
+    key_path: Option<&str>,
+    strict_mode: StrictHostKeyChecking,
+    use_agent: bool,
+) -> Result<std::path::PathBuf> {
+    let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
+
+    let key_path = key_path.map(Path::new);
+
+    // This function handles both files and directories
+    // The caller should check if it's a directory and use the appropriate method
     client
-        .upload_file(
-            local_path,
+        .download_file(
             remote_path,
+            local_path,
             key_path,
             Some(strict_mode),
             use_agent,
         )
-        .await
+        .await?;
+
+    Ok(local_path.to_path_buf())
 }
 
-async fn download_from_node(
+pub async fn download_dir_from_node(
     node: Node,
     remote_path: &str,
     local_path: &Path,
@@ -457,7 +497,7 @@ async fn download_from_node(
     let key_path = key_path.map(Path::new);
 
     client
-        .download_file(
+        .download_dir(
             remote_path,
             local_path,
             key_path,

src/main.rs

@@ -699,77 +699,40 @@ async fn download_file(
     };
 
     if is_directory {
-        // Recursive directory download
+        // Recursive directory download using SFTP
         println!(
-            "Recursively downloading directory {source} from {} nodes",
+            "Recursively downloading directory {source} from {} nodes using SFTP",
             params.nodes.len()
         );
 
-        // Find all files in the directory recursively
-        let find_cmd = format!("find '{source}' -type f 2>/dev/null || find '{source}' -type f");
-        let find_results = executor.execute(&find_cmd).await?;
-
         let mut total_success = 0;
         let mut total_failed = 0;
 
-        for (node_idx, result) in find_results.iter().enumerate() {
-            if let Ok(cmd_result) = &result.result {
-                let stdout = String::from_utf8_lossy(&cmd_result.output);
-                let files: Vec<String> = stdout
-                    .lines()
-                    .filter(|line| !line.is_empty())
-                    .map(|s| s.to_string())
-                    .collect();
-
-                if files.is_empty() {
-                    println!("No files found in directory on {}", params.nodes[node_idx]);
-                    continue;
-                }
-
-                println!(
-                    "\nDownloading {} files from {}",
-                    files.len(),
-                    params.nodes[node_idx]
-                );
-
-                for remote_file in files {
-                    // Calculate relative path from source directory
-                    let relative_path = remote_file
-                        .strip_prefix(source)
-                        .unwrap_or(&remote_file)
-                        .trim_start_matches('/');
-
-                    // Create local file path preserving directory structure
-                    let local_file = destination
-                        .join(params.nodes[node_idx].to_string())
-                        .join(relative_path);
-
-                    // Create parent directory if needed
-                    if let Some(parent) = local_file.parent() {
-                        fs::create_dir_all(parent).await?;
-                    }
+        // Download the entire directory from each node
+        for node in &params.nodes {
+            let node_dir = destination.join(node.to_string());
 
-                    // Download the file using the executor's download method
-                    let single_node = vec![params.nodes[node_idx].clone()];
-                    let single_executor = ParallelExecutor::new_with_strict_mode_and_agent(
-                        single_node,
-                        1,
-                        key_path_str.clone(),
-                        params.strict_mode,
-                        params.use_agent,
-                    );
+            println!("\nDownloading directory from {node} to {node_dir:?}");
 
-                    let download_results = single_executor
-                        .download_file(&remote_file, &local_file)
-                        .await?;
+            // Use the download_dir_from_node function directly
+            let result = bssh::executor::download_dir_from_node(
+                node.clone(),
+                source,
+                &node_dir,
+                key_path_str.as_deref(),
+                params.strict_mode,
+                params.use_agent,
+            )
+            .await;
 
-                    if download_results.iter().any(|r| r.is_success()) {
-                        println!("  ✓ Downloaded: {remote_file} -> {local_file:?}");
-                        total_success += 1;
-                    } else {
-                        println!("  ✗ Failed: {remote_file}");
-                        total_failed += 1;
-                    }
+            match result {
+                Ok(_) => {
+                    println!("  ✓ Successfully downloaded directory");
+                    total_success += 1;
+                }
+                Err(e) => {
+                    println!("  ✗ Failed to download directory: {e}");
+                    total_failed += 1;
                 }
             }
         }