Use struct instead of tuple

apps/desktop/desktop_native/core/src/ssh_agent/mod.rs

@@ -20,12 +20,18 @@ pub mod peerinfo;
 pub struct BitwardenDesktopAgent {
     keystore: ssh_agent::KeyStore,
     cancellation_token: CancellationToken,
-    show_ui_request_tx: tokio::sync::mpsc::Sender<(u32, (String, String))>,
+    show_ui_request_tx: tokio::sync::mpsc::Sender<SshAgentUIRequest>,
     get_ui_response_rx: Arc<Mutex<tokio::sync::broadcast::Receiver<(u32, bool)>>>,
     request_id: Arc<Mutex<u32>>,
     is_running: Arc<tokio::sync::Mutex<bool>>,
 }
 
+pub struct SshAgentUIRequest {
+    pub request_id: u32,
+    pub cipher_id: String,
+    pub process_name: String,
+}
+
 impl ssh_agent::Agent<peerinfo::models::PeerInfo> for BitwardenDesktopAgent {
     async fn confirm(&self, ssh_key: Key, info: &peerinfo::models::PeerInfo) -> bool {
         if !*self.is_running.lock().await {
@@ -38,7 +44,11 @@ impl ssh_agent::Agent<peerinfo::models::PeerInfo> for BitwardenDesktopAgent {
 
         let mut rx_channel = self.get_ui_response_rx.lock().await.resubscribe();
         self.show_ui_request_tx
-            .send((request_id, (ssh_key.cipher_uuid.clone(), info.process_name().to_string())))
+            .send(SshAgentUIRequest {
+                request_id,
+                cipher_id: ssh_key.cipher_uuid.clone(),
+                process_name: info.process_name().to_string(),
+            })
             .await
             .expect("Should send request to ui");
         while let Ok((id, response)) = rx_channel.recv().await {

apps/desktop/desktop_native/core/src/ssh_agent/unix.rs

@@ -12,11 +12,11 @@ use tokio_util::sync::CancellationToken;
 
 use crate::ssh_agent::peercred_unix_listener_stream::PeercredUnixListenerStream;
 
-use super::BitwardenDesktopAgent;
+use super::{BitwardenDesktopAgent, SshAgentUIRequest};
 
 impl BitwardenDesktopAgent{
     pub async fn start_server(
-        auth_request_tx: tokio::sync::mpsc::Sender<(u32, (String, String))>,
+        auth_request_tx: tokio::sync::mpsc::Sender<SshAgentUIRequest>,
         auth_response_rx: Arc<Mutex<tokio::sync::broadcast::Receiver<(u32, bool)>>>,
     ) -> Result<Self, anyhow::Error> {
         let agent = BitwardenDesktopAgent {

apps/desktop/desktop_native/core/src/ssh_agent/windows.rs

@@ -12,7 +12,7 @@ use super::BitwardenDesktopAgent;
 
 impl BitwardenDesktopAgent {
     pub async fn start_server(
-        auth_request_tx: tokio::sync::mpsc::Sender<(u32, (String, String))>,
+        auth_request_tx: tokio::sync::mpsc::Sender<SshAgentUIRequest>,
         auth_response_rx: Arc<Mutex<tokio::sync::broadcast::Receiver<(u32, bool)>>>,
     ) -> Result<Self, anyhow::Error> {
         let agent_state = BitwardenDesktopAgent {

apps/desktop/desktop_native/napi/src/lib.rs

@@ -249,39 +249,35 @@ pub mod sshagent {
     pub async fn serve(
         callback: ThreadsafeFunction<(String, String), CalleeHandled>,
     ) -> napi::Result<SshAgentState> {
-        let (auth_request_tx, mut auth_request_rx) = tokio::sync::mpsc::channel::<(u32, (String, String))>(32);
+        let (auth_request_tx, mut auth_request_rx) = tokio::sync::mpsc::channel::<desktop_core::ssh_agent::SshAgentUIRequest>(32);
         let (auth_response_tx, auth_response_rx) = tokio::sync::broadcast::channel::<(u32, bool)>(32);
         let auth_response_tx_arc = Arc::new(Mutex::new(auth_response_tx));
         tokio::spawn(async move {
             let _ = auth_response_rx;
 
-            while let Some((request_id, (cipher_uuid, process_name))) = auth_request_rx.recv().await {
-                let cloned_request_id = request_id.clone();
-                let cloned_cipher_uuid = cipher_uuid.clone();
+            while let Some(request) = auth_request_rx.recv().await {
                 let cloned_response_tx_arc = auth_response_tx_arc.clone();
                 let cloned_callback = callback.clone();
                 tokio::spawn(async move {
-                    let request_id = cloned_request_id;
-                    let cipher_uuid = cloned_cipher_uuid;
                     let auth_response_tx_arc = cloned_response_tx_arc;
                     let callback = cloned_callback;
                     let promise_result: Result<Promise<bool>, napi::Error> =
-                        callback.call_async(Ok((cipher_uuid, process_name))).await;
+                        callback.call_async(Ok((request.cipher_id, request.process_name))).await;
                     match promise_result {
                         Ok(promise_result) => match promise_result.await {
                             Ok(result) => {
-                                let _ = auth_response_tx_arc.lock().await.send((request_id, result))
+                                let _ = auth_response_tx_arc.lock().await.send((request.request_id, result))
                                     .expect("should be able to send auth response to agent");
                             }
                             Err(e) => {
                                 println!("[SSH Agent Native Module] calling UI callback promise was rejected: {}", e);
-                                let _ = auth_response_tx_arc.lock().await.send((request_id, false))
+                                let _ = auth_response_tx_arc.lock().await.send((request.request_id, false))
                                     .expect("should be able to send auth response to agent");
                             }
                         },
                         Err(e) => {
                             println!("[SSH Agent Native Module] calling UI callback could not create promise: {}", e);
-                            let _ = auth_response_tx_arc.lock().await.send((request_id, false))
+                            let _ = auth_response_tx_arc.lock().await.send((request.request_id, false))
                                 .expect("should be able to send auth response to agent");
                         }
                     }