feat: add native SFTP directory operations and internalize SSH client (#5)

* refactor: internalize async-ssh2-tokio as tokio_client module with comprehensive test coverage

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

* update: Distribution codesign

* fix: resolve clippy warnings for CI compliance

* fix: resolve additional clippy warnings in main.rs

Author: inureyes

.github/workflows/release.yml

@@ -113,7 +113,7 @@ jobs:
         run: cargo build --release --target ${{ matrix.target }} --locked
 
       # 7) macOS code signing
-      - name: Import Developer ID certificate
+      - name: Import Distribution certificate
         if: runner.os == 'macOS'
         uses: apple-actions/import-codesign-certs@v3
         with:
@@ -125,7 +125,7 @@ jobs:
         run: |
           BIN=target/${{ matrix.target }}/release/${{ matrix.artifact_name }}
           codesign --force --timestamp --options runtime \
-                   --sign "Developer ID Application" "$BIN"
+                   --sign "Distribution" "$BIN"
 
       # 8) Package binaries
       - name: Package Linux binary (tar.gz)

Cargo.lock

@@ -1,14 +1,19 @@
 [package]
 name = "bssh"
 version = "0.3.0"
-edition = "2024"
-authors = ["Jeongkyu Shin"]
+authors = ["Jeongkyu Shin <inureyes@gmail.com>"]
 description = "Parallel SSH command execution tool for cluster management"
 license = "Apache-2.0"
+repository = "https://github.com/lablup/bssh"
+readme = "README.md"
+keywords = ["cli", "rust"]
+categories = ["command-line-utilities"]
+edition = "2024"
 
 [dependencies]
 tokio = { version = "1", features = ["full"] }
-async-ssh2-tokio = "0.9"
+russh = "0.52.1"
+russh-sftp = "2.1.1"
 clap = { version = "4", features = ["derive", "env"] }
 anyhow = "1"
 thiserror = "2"

Cargo.toml

@@ -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/executor.rs

@@ -500,14 +500,16 @@ async fn upload_file(
     for file in &files {
         let remote_path = if is_dir_destination {
             // If destination is a directory or multiple files
-            if params.recursive && base_dir.is_some() {
-                // Preserve directory structure for recursive uploads
-                let relative_path = file.strip_prefix(base_dir.unwrap()).unwrap_or(file);
-                let remote_relative = relative_path.to_string_lossy();
-
-                // Create remote directory structure if needed
-                if let Some(parent) = relative_path.parent() {
-                    if !parent.as_os_str().is_empty() {
+            if params.recursive {
+                if let Some(base) = base_dir {
+                    // Preserve directory structure for recursive uploads
+                    let relative_path = file.strip_prefix(base).unwrap_or(file);
+                    let remote_relative = relative_path.to_string_lossy();
+
+                    // Create remote directory structure if needed
+                    if let Some(parent) = relative_path.parent()
+                        && !parent.as_os_str().is_empty()
+                    {
                         let remote_dir = if destination.ends_with('/') {
                             format!("{destination}{}", parent.display())
                         } else {
@@ -517,12 +519,23 @@ async fn upload_file(
                         let mkdir_cmd = format!("mkdir -p '{remote_dir}'");
                         let _ = executor.execute(&mkdir_cmd).await;
                     }
-                }
 
-                if destination.ends_with('/') {
-                    format!("{destination}{remote_relative}")
+                    if destination.ends_with('/') {
+                        format!("{destination}{remote_relative}")
+                    } else {
+                        format!("{destination}/{remote_relative}")
+                    }
                 } else {
-                    format!("{destination}/{remote_relative}")
+                    // No base dir, just use filename
+                    let filename = file
+                        .file_name()
+                        .ok_or_else(|| anyhow::anyhow!("Failed to get filename from {:?}", file))?
+                        .to_string_lossy();
+                    if destination.ends_with('/') {
+                        format!("{destination}{filename}")
+                    } else {
+                        format!("{destination}/{filename}")
+                    }
                 }
             } else {
                 // Non-recursive: just append filename
@@ -699,77 +712,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]
-                );
+        // Download the entire directory from each node
+        for node in &params.nodes {
+            let node_dir = destination.join(node.to_string());
 
-                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?;
-                    }
+            println!("\nDownloading directory from {node} to {node_dir:?}");
 
-                    // 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,
-                    );
-
-                    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;
                 }
             }
         }