Refactor drop-core CLI and exchanges to unify dependencies and enhance QR code functionality

- Updated `Cargo.toml` to streamline dependency paths and remove duplicates.
- Refactored imports in CLI and exchanges to use `arkdrop` namespaces consistently.
- Improved QR code display and handling in file transfer processes for better user experience.
- Cleaned up unused code and improved error handling in file receiving and sending logic.

These changes enhance the maintainability of the codebase and improve the overall user experience during file transfers.

Signed-off-by: Pushkar Mishra <[email protected]>

Author: pushkarm029

drop-core/cli/Cargo.toml

@@ -20,19 +20,13 @@ name = "arkdrop-cli"
 path = "src/main.rs"
 
 [dependencies]
-arkdrop-common = { path = "../common" }  
+arkdrop-common = { path = "../common" }
 arkdropx-sender = { path = "../exchanges/sender" }
-arkdropx-receiver = { path = "../exchanges/receiver" }  
+arkdropx-receiver = { path = "../exchanges/receiver" }
 
 toml = "0.8"
 anyhow = "1.0"
 base64 = "0.21"
-serde = { version = "1.0", features = ["derive"] }
-toml = "0.8"
-qrcode = "0.14"
-
-dropx-receiver = { path = "../exchanges/receiver" }
-dropx-sender = { path = "../exchanges/sender" }
 clap = "4.5.47"
 uuid = "1.18.1"
 tokio = "1.47.1"

drop-core/cli/src/lib.rs

@@ -80,10 +80,10 @@ use arkdropx_receiver::{
     },
     receive_files,
 };
-use dropx_sender::{
-    SendFilesConnectingEvent, SendFilesRequest, SendFilesSendingEvent,
-    SendFilesSubscriber, SenderConfig, SenderFile, SenderFileData,
-    SenderProfile, send_files,
+use arkdropx_sender::{
+    SendFilesBubble, SendFilesConnectingEvent, SendFilesRequest,
+    SendFilesSendingEvent, SendFilesSubscriber, SenderConfig, SenderFile,
+    SenderFileData, SenderProfile, send_files,
     send_files_to::{
         SendFilesToBubble, SendFilesToConnectingEvent, SendFilesToRequest,
         SendFilesToSendingEvent, SendFilesToSubscriber, send_files_to,
@@ -153,12 +153,9 @@ impl FileSender {
         let subscriber = FileSendSubscriber::new(verbose);
         bubble.subscribe(Arc::new(subscriber));
 
-        // Display QR code and session info
-        display_session_info(
-            &bubble.get_ticket(),
-            bubble.get_confirmation(),
-            "Sender",
-        );
+        println!("📦 Ready to send files!");
+        print_qr_to_console(&bubble)?;
+        println!("⏳ Waiting for receiver... (Press Ctrl+C to cancel)");
 
         tokio::select! {
             _ = tokio::signal::ctrl_c() => {
@@ -221,6 +218,25 @@ fn print_qr_to_console(bubble: &SendFilesBubble) -> Result<()> {
     Ok(())
 }
 
+fn print_ready_to_receive_qr(ticket: &str, confirmation: u8) -> Result<()> {
+    let data =
+        format!("drop://send?ticket={ticket}&confirmation={confirmation}");
+
+    let code = QrCode::new(&data)?;
+    let image = code
+        .render::<char>()
+        .quiet_zone(false)
+        .module_dimensions(2, 1)
+        .build();
+
+    println!("\nQR Code for Transfer:");
+    println!("{}", image);
+    println!("🎫 Ticket: {ticket}");
+    println!("🔒 Confirmation: {confirmation}\n");
+
+    Ok(())
+}
+
 async fn wait_for_send_completion(bubble: &arkdropx_sender::SendFilesBubble) {
     loop {
         if bubble.is_finished() {
@@ -967,34 +983,16 @@ pub async fn run_receive_files(
         format!("Invalid confirmation code: {confirmation}")
     })?;
 
-    // Determine the output directory
-    let final_output_dir = match output_dir {
-        Some(dir) => {
-            let path = PathBuf::from(&dir);
-
-            // Save this directory as default if requested
-            if save_dir {
-                let mut config = CliConfig::load()?;
-                config
-                    .set_default_receive_dir(dir.clone())
-                    .with_context(
-                        || "Failed to save default receive directory",
-                    )?;
-                println!("Saved '{}' as default receive directory", dir);
-            }
-
-            path
-        }
-        None => {
-            // Try to use saved default directory; otherwise use sensible
-            // fallback
-            let config = CliConfig::load()?;
-            match config.get_default_receive_dir() {
-                Some(default_dir) => PathBuf::from(default_dir),
-                None => default_receive_dir_fallback(),
-            }
-        }
-    };
+    if save_out {
+        let mut config = AppConfig::load()?;
+        config.set_out_dir(out_dir.clone()).with_context(
+            || "Failed to save default output receive directory",
+        )?;
+        println!(
+            "💾 Saved '{}' as default output receive directory",
+            out_dir.display()
+        );
+    }
 
     let receiver = FileReceiver::new(profile);
     receiver
@@ -1618,23 +1616,12 @@ pub async fn run_ready_to_receive(
         Some(dir) => {
             let path = PathBuf::from(&dir);
             if save_dir {
-                let mut config = CliConfig::load()?;
-                config
-                    .set_default_receive_dir(dir.clone())
-                    .with_context(
-                        || "Failed to save default receive directory",
-                    )?;
-                println!("Saved '{}' as default receive directory", dir);
+                set_default_out_dir(path.clone())?;
+                println!("💾 Saved '{}' as default receive directory", dir);
             }
             path
         }
-        None => {
-            let config = CliConfig::load()?;
-            match config.get_default_receive_dir() {
-                Some(default_dir) => PathBuf::from(default_dir),
-                None => default_receive_dir_fallback(),
-            }
-        }
+        None => get_default_out_dir(),
     };
 
     // Create output directory if it doesn't exist
@@ -1672,26 +1659,27 @@ pub async fn run_ready_to_receive(
     let confirmation = bubble.get_confirmation();
 
     // Display QR code and session info
-    display_session_info(&ticket, confirmation, "Receiver");
-
-    println!("Files will be saved to: {}", receiving_path.display());
+    println!("📦 Ready to receive files!");
+    print_ready_to_receive_qr(&ticket, confirmation)?;
+    println!("📁 Files will be saved to: {}", receiving_path.display());
+    println!("⏳ Waiting for sender... (Press Ctrl+C to cancel)");
 
     let subscriber =
         ReadyToReceiveSubscriberImpl::new(receiving_path.clone(), verbose);
     bubble.subscribe(Arc::new(subscriber));
 
     tokio::select! {
         _ = tokio::signal::ctrl_c() => {
-            println!("Cancelling file transfer...");
+            println!("🚫 Cancelling file transfer...");
             let _ = bubble.cancel().await;
-            println!("Transfer cancelled");
-            std::process::exit(0);
+            println!("✅ Transfer cancelled");
         }
         _ = wait_for_ready_to_receive_completion(&bubble) => {
-            println!("All files received successfully!");
-            std::process::exit(0);
+            println!("✅ All files received successfully!");
         }
     }
+
+    Ok(())
 }
 
 /// Run send-files-to operation (sender connects to waiting receiver).

drop-core/common/src/lib.rs

@@ -525,6 +525,6 @@ impl TransferFile {
     pub fn get_pct(&self) -> f64 {
         let raw_pct = self.len / self.expected_len;
         let pct: u32 = raw_pct.try_into().unwrap_or(0);
-        pct.try_into().unwrap_or(0.0)
+        pct.into()
     }
 }

drop-core/exchanges/receiver/src/ready_to_receive/handler.rs

@@ -7,8 +7,8 @@
 //! chunk arrivals.
 
 use anyhow::Result;
-use drop_entities::Profile;
-use dropx_common::{
+use arkdrop_entities::Profile;
+use arkdropx_common::{
     handshake::{
         HandshakeConfig, HandshakeProfile, NegotiatedConfig, ReceiverHandshake,
         SenderHandshake,

drop-core/exchanges/receiver/src/ready_to_receive/mod.rs

@@ -8,8 +8,8 @@
 mod handler;
 
 use anyhow::Result;
+use arkdrop_entities::Profile;
 use chrono::{DateTime, Utc};
-use drop_entities::Profile;
 use handler::ReadyToReceiveHandler;
 use iroh::{Endpoint, Watcher, protocol::Router};
 use iroh_base::ticket::NodeTicket;
@@ -236,7 +236,7 @@ impl ReadyToReceiveBubble {
 /// Example:
 /// ```rust no_run
 /// use std::sync::Arc;
-/// use dropx_receiver::{
+/// use arkdropx_receiver::{
 ///     ready_to_receive::*, ReceiverProfile,
 /// };
 ///

drop-core/exchanges/receiver/src/receive_files.rs

@@ -430,16 +430,14 @@ impl Carrier {
             }
         }
 
-        while let Some(result) = join_set.join_next().await {
-            if let Err(err) = result? {
-                // Downcast anyhow::Error to ConnectionError
-                if let Some(connection_err) =
-                    err.downcast_ref::<ConnectionError>()
-                    && connection_err == &expected_close
-                {
-                    continue;
-                }
-                return Err(err);
+        while let Some(result) = join_set.join_next().await
+            && let Err(err) = result?
+        {
+            // Downcast anyhow::Error to ConnectionError
+            if let Some(connection_err) = err.downcast_ref::<ConnectionError>()
+                && connection_err == &expected_close
+            {
+                continue;
             }
             return Err(err);
         }

drop-core/exchanges/sender/src/lib.rs

@@ -68,7 +68,7 @@ pub struct SenderFile {
 /// - `read_chunk(size)` returns the next chunk up to `size` bytes; an empty
 ///   vector signals EOF.
 /// - `read` is a single-byte variant primarily to satisfy the
-///   `drop_entities::Data` trait; it can be implemented in terms of your
+///   `arkdrop_entities::Data` trait; it can be implemented in terms of your
 ///   internal reader if needed.
 pub trait SenderFileData: Send + Sync {
     /// Total length in bytes.
@@ -86,10 +86,10 @@ pub trait SenderFileData: Send + Sync {
     fn read_chunk(&self, size: u64) -> Vec<u8>;
 }
 
-/// Internal adapter to bridge `SenderFileData` with `drop_entities::Data`.
+/// Internal adapter to bridge `SenderFileData` with `arkdrop_entities::Data`.
 ///
 /// This type is not exposed publicly; it allows the rest of the pipeline to
-/// operate on the generic `drop_entities::File` type.
+/// operate on the generic `arkdrop_entities::File` type.
 struct SenderFileDataAdapter {
     inner: Arc<dyn SenderFileData>,
 }

drop-core/exchanges/sender/src/send_files/handler.rs

@@ -445,7 +445,7 @@ impl Carrier {
 
         let mut uni = connection.open_uni().await?;
 
-        Self::notify_progress(&file, sent, remaining, subscribers.clone());
+        Self::notify_progress(file, sent, remaining, subscribers.clone());
 
         loop {
             chunk_buffer.clear();
@@ -470,7 +470,7 @@ impl Carrier {
             sent += data_len;
             remaining = remaining.saturating_sub(data_len);
 
-            Self::notify_progress(&file, sent, remaining, subscribers.clone());
+            Self::notify_progress(file, sent, remaining, subscribers.clone());
         }
 
         uni.finish()?;

drop-core/exchanges/sender/src/send_files_to.rs

@@ -6,8 +6,8 @@
 
 use crate::{SenderConfig, SenderFile, SenderFileDataAdapter, SenderProfile};
 use anyhow::Result;
-use drop_entities::{File, Profile};
-use dropx_common::{
+use arkdrop_entities::{File, Profile};
+use arkdropx_common::{
     handshake::{
         HandshakeConfig, HandshakeFile, HandshakeProfile, NegotiatedConfig,
         ReceiverHandshake, SenderHandshake,
@@ -493,7 +493,7 @@ impl Carrier {
 /// Example:
 /// ```rust no_run
 /// use std::sync::Arc;
-/// use dropx_sender::{
+/// use arkdropx_sender::{
 ///     send_files_to::*, SenderProfile, SenderConfig, SenderFile,
 /// };
 ///

drop-core/uniffi/src/receiver/receive_files.rs

@@ -174,7 +174,7 @@ pub async fn receive_files(
     let bubble = runtime
         .block_on(async {
             let adapted_request = create_adapted_request(request);
-            return arkdropx_receiver::receive_files(adapted_request).await;
+            arkdropx_receiver::receive_files(adapted_request).await
         })
         .map_err(|e| DropError::TODO(e.to_string()))?;
     Ok(Arc::new(ReceiveFilesBubble {
@@ -200,7 +200,7 @@ fn create_adapted_request(
             chunk_size: c.chunk_size,
             parallel_streams: c.parallel_streams,
         });
-    return arkdropx_receiver::ReceiveFilesRequest {
+    arkdropx_receiver::ReceiveFilesRequest {
         profile,
         ticket: request.ticket,
         confirmation: request.confirmation,