you guessed it

src/main.rs

···
-use std::{env, fs};
 use std::path::PathBuf;
+use std::{env, fs};
 
+use anyhow;
+use async_compression::futures::bufread::{ZstdDecoder, ZstdEncoder};
 use clap::{Parser, Subcommand};
 use dotenvy::dotenv;
+use futures::io::BufReader;
 use log::{error, info};
 use reqwest::header::{ACCEPT, ACCEPT_ENCODING};
-use anyhow;
+use s3::creds::Credentials;
+use s3::{Bucket, Region};
+use std::future::Future;
+use tokio::io::AsyncWriteExt;
+use tokio_stream::wrappers::LinesStream;
 use tokio_util::compat::{FuturesAsyncReadCompatExt, TokioAsyncReadCompatExt};
 use tokio_util::io::StreamReader;
-use tokio_stream::wrappers::LinesStream;
-use tokio::io::AsyncWriteExt;
-use std::future::Future;
-use async_compression::futures::bufread::{ZstdEncoder, ZstdDecoder};
-use s3::{Bucket, Region};
-use s3::creds::Credentials;
-use futures::io::BufReader;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about = "PDS Whatsit Compress Test CLI", long_about = None)]
···
             fs::create_dir_all(parent)?;
         }
     }
-    if !path.exists() {
-        fs::create_dir_all(path)?;
-    }
     Ok(())
 }
 
 #[tokio::main]
-async fn main() {
+async fn main() -> anyhow::Result<()> {
     init_logging();
 
     let cli = Cli::parse();
+    // Custom region requires valid region name and endpoint
+    let region_name = env::var("S3_REGION")?;
+    let endpoint = env::var("S3_ENDPOINT")?;
+    let region = Region::Custom {
+        region: region_name,
+        endpoint,
+    };
 
-    match cli.command {
-        Commands::Export {  did, pds_url } => {
+    let bucket = Bucket::new(
+        env::var("S3_BUCKET_NAME")?.as_str(),
+        region,
+        // Credentials are collected from environment, config, profile or instance metadata
+        Credentials::new(
+            Some(env::var("S3_ACCESS_KEY")?.as_str()),
+            Some(env::var("S3_SECRET_KEY")?.as_str()),
+            None,
+            None,
+            None,
+        )?,
+    )?;
 
-            info!(
-                "Export requested: did={}, pds_url={}",
-                did,
-                pds_url,
-            );
+    match cli.command {
+        Commands::Export { did, pds_url } => {
+            info!("Export requested: did={}, pds_url={}", did, pds_url,);
 
-            match do_work(pds_url, did).await{
+            match do_work(pds_url, did, bucket).await {
                 Ok(_) => {
                     info!("Export completed");
+                    Ok(())
                 }
                 Err(err) => {
                     error!("Export failed: {}", err);
+                    Err(err)
                 }
             }
         }
         Commands::Import { did } => {
             info!("Import requested: did={}", did);
-            match do_import(did).await {
-                Ok(path) => info!("Import completed, wrote {}", path.display()),
-                Err(err) => error!("Import failed: {}", err),
+            match do_import(did, bucket).await {
+                Ok(path) => {
+                    info!("Import completed, wrote {}", path.display());
+                    Ok(())
+                }
+                Err(err) => {
+                    error!("Import failed: {}", err);
+                    Err(err)
+                }
             }
         }
     }
 }
 
-async fn do_work(pds_url: String, did: String) -> anyhow::Result<()>{
+async fn do_work(pds_url: String, did: String, bucket: Box<Bucket>) -> anyhow::Result<()> {
     use futures::TryStreamExt;
     let atproto_client = reqwest::Client::new();
     let back_up_path = format!("users/{did}");
 
-    // Custom region requires valid region name and endpoint
-    let region_name = env::var("S3_REGION")?;
-    let endpoint = env::var("S3_ENDPOINT")?;
-    let region = Region::Custom { region: region_name, endpoint };
-
-    let bucket = Bucket::new(
-        env::var("S3_BUCKET_NAME")?.as_str(),
-        region,
-        // Credentials are collected from environment, config, profile or instance metadata
-        Credentials::new(Some(env::var("S3_ACCESS_KEY")?.as_str()), Some(env::var("S3_SECRET_KEY")?.as_str()), None, None, None)?,
-    )?;
-
     let response_reader = atproto_client
         .get(format!("{pds_url}/xrpc/com.atproto.sync.getRepo?did={did}"))
         .header(ACCEPT, "application/vnd.ipld.car")
···
     Ok(())
 }
 
-async fn do_import(did: String) -> anyhow::Result<PathBuf> {
+async fn do_import(did: String, bucket: Box<Bucket>) -> anyhow::Result<PathBuf> {
     use futures::StreamExt;
 
     let back_up_path = format!("users/{did}");
 
-    // S3 setup from env
-    let region_name = env::var("S3_REGION")?;
-    let endpoint = env::var("S3_ENDPOINT")?;
-    let region = Region::Custom { region: region_name, endpoint };
-
-    let bucket = Bucket::new(
-        env::var("S3_BUCKET_NAME")?.as_str(),
-        region,
-        Credentials::new(Some(env::var("S3_ACCESS_KEY")?.as_str()), Some(env::var("S3_SECRET_KEY")?.as_str()), None, None, None)?,
-    )?;
-
     // Stream download from S3
     let mut s3_stream = bucket
         .get_object_stream(format!("/{back_up_path}/{did}.car.zst"))
···
     let mut decoded_tokio_reader = decoder.compat();
 
     // Prepare local output path, labeled as decompressed
-    let out_path: PathBuf = ["export", "users", did.as_str(), &format!("{}-decompressed.car", did)].iter().collect();
+    let out_path: PathBuf = [
+        "export",
+        "users",
+        did.as_str(),
+        &format!("{}-decompressed.car", did),
+    ]
+    .iter()
+    .collect();
     ensure_dir(&out_path)?;
 
     let mut out_file = tokio::fs::File::create(&out_path).await?;