Apply feedback

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

@@ -1062,13 +1062,16 @@ pub mod sshagent_v2 {
         bindgen_prelude::Promise,
         threadsafe_function::{ErrorStrategy::CalleeHandled, ThreadsafeFunction},
     };
-    use ssh_agent::agent::{ui_requester, PlatformListener};
     use ssh_agent::{
         self,
         agent::{ui_requester::UiRequestMessage, BitwardenDesktopAgent},
         memory::UnlockedSshItem,
         protocol::types::KeyPair,
     };
+    use ssh_agent::{
+        agent::{ui_requester, PlatformListener},
+        transport::peer_info::ProcessInfo,
+    };
     use tokio::{self, sync::Mutex};
     use tracing::{error, info};
 
@@ -1142,14 +1145,23 @@ pub mod sshagent_v2 {
         callback: ThreadsafeFunction<SshUIRequest, CalleeHandled>,
     ) {
         tokio::spawn(async move {
+            let process_name = match request_message
+                .connection_info()
+                .peer_info()
+                .process_info
+                .clone()
+            {
+                ProcessInfo::Known {
+                    pid: _,
+                    process_name,
+                } => process_name,
+                ProcessInfo::Unknown => "unknown".to_string(),
+            };
+
             let mut ui_request = SshUIRequest {
                 cipher_id: None,
                 is_list: false,
-                process_name: request_message
-                    .connection_info()
-                    .peer_info()
-                    .process_name()
-                    .to_string(),
+                process_name: process_name,
                 is_forwarding: request_message.connection_info().is_forwarding(),
                 namespace: None,
             };
@@ -1177,7 +1189,7 @@ pub mod sshagent_v2 {
                     namespace,
                 } => {
                     ui_request.cipher_id = Some(cipher_id);
-                    ui_request.namespace = Some(namespace);
+                    ui_request.namespace = namespace;
                     ui_request
                 }
             };

apps/desktop/desktop_native/ssh_agent/src/agent/desktop_agent.rs

@@ -7,10 +7,7 @@ use crate::{
     agent::ui_requester::UiRequester,
     memory::{KeyStore, UnlockedSshItem},
     protocol::{
-        self,
-        agent_listener::serve_listener,
-        key_store::Agent,
-        requests::{ParsedSignRequest, SshSignRequest},
+        self, agent_listener::serve_listener, key_store::Agent, requests::ParsedSignRequest,
         types::PublicKeyWithName,
     },
     transport::peer_info::PeerInfo,

apps/desktop/desktop_native/ssh_agent/src/transport/peer_info.rs

@@ -6,9 +6,14 @@ use sysinfo::{Pid, System};
 /// This can be later extended to include more information (icon, app name) for the corresponding application.
 #[derive(Clone)]
 pub struct PeerInfo {
-    pid: u32,
-    process_name: String,
-    peer_type: PeerType,
+    pub process_info: ProcessInfo,
+    pub peer_type: PeerType,
+}
+
+#[derive(Clone, Debug)]
+pub enum ProcessInfo {
+    Known { pid: u32, process_name: String },
+    Unknown,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -20,48 +25,42 @@ pub enum PeerType {
 
 impl PeerInfo {
     pub fn new(pid: u32, peer_type: PeerType) -> Self {
-        Self::from_pid(pid, peer_type).unwrap_or_else(|_| PeerInfo::unknown())
+        Self::from_pid(pid, peer_type)
     }
 
-    fn from_pid(peer_pid: u32, peer_type: PeerType) -> Result<Self, ()> {
+    pub fn unknown(peer_type: PeerType) -> Self {
+        Self {
+            process_info: ProcessInfo::Unknown,
+            peer_type,
+        }
+    }
+
+    fn from_pid(peer_pid: u32, peer_type: PeerType) -> Self {
         let mut system = System::new();
         system.refresh_processes(
             sysinfo::ProcessesToUpdate::Some(&[Pid::from_u32(peer_pid)]),
             true,
         );
-        if let Some(process) = system.process(Pid::from_u32(peer_pid)) {
-            Ok(Self {
+        let process_info = if let Some(process) = system.process(Pid::from_u32(peer_pid)) {
+            ProcessInfo::Known {
                 pid: peer_pid,
-                process_name: process.name().to_str().ok_or(())?.to_string(),
-                peer_type,
-            })
+                process_name: process.name().to_os_string().to_string_lossy().into_owned(),
+            }
         } else {
-            Err(())
-        }
-    }
+            ProcessInfo::Unknown
+        };
 
-    pub fn unknown() -> Self {
         Self {
-            pid: 0,
-            process_name: "Unknown application".to_string(),
-            peer_type: PeerType::UnixSocket,
+            process_info,
+            peer_type,
         }
     }
-
-    pub fn pid(&self) -> u32 {
-        self.pid
-    }
-
-    pub fn process_name(&self) -> &str {
-        &self.process_name
-    }
 }
 
 impl Debug for PeerInfo {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("PeerInfo")
-            .field("pid", &self.pid)
-            .field("process_name", &self.process_name)
+            .field("process_info", &self.process_info)
             .field("peer_type", &self.peer_type)
             .finish()
     }

apps/desktop/desktop_native/ssh_agent/src/transport/unix_listener_stream.rs

@@ -72,10 +72,18 @@ impl Stream for UnixListenerStream {
                     Ok(peer) => match peer.pid() {
                         Some(pid) => pid,
                         None => {
-                            return Poll::Ready(Some(Ok((stream, PeerInfo::unknown()))));
+                            return Poll::Ready(Some(Ok((
+                                stream,
+                                PeerInfo::unknown(PeerType::UnixSocket),
+                            ))));
                         }
                     },
-                    Err(_) => return Poll::Ready(Some(Ok((stream, PeerInfo::unknown())))),
+                    Err(_) => {
+                        return Poll::Ready(Some(Ok((
+                            stream,
+                            PeerInfo::unknown(PeerType::UnixSocket),
+                        ))))
+                    }
                 };
                 Poll::Ready(Some(Ok((
                     stream,