Merge pull request #18 from bitwarden/pair

Better CLI experience, /pair

Author: abergs

crates/bw-rat-client/src/clients/user_client.rs

@@ -172,6 +172,8 @@ pub struct UserClient {
     incoming_rx: Option<mpsc::UnboundedReceiver<IncomingMessage>>,
     /// Pending handshake awaiting fingerprint verification
     pending_verification: Option<PendingHandshakeVerification>,
+    /// Name to assign to the next newly-paired session
+    pending_session_name: Option<String>,
 }
 
 impl UserClient {
@@ -197,6 +199,7 @@ impl UserClient {
             psk: None,
             incoming_rx: Some(incoming_rx),
             pending_verification: None,
+            pending_session_name: None,
         })
     }
 
@@ -410,6 +413,11 @@ impl UserClient {
             // and save the new transport state from the fresh handshake.
             self.transports.insert(source, transport.clone());
             self.session_store.cache_session(source)?;
+            // Apply pending name if user explicitly re-paired (e.g. `/pair MyName`).
+            // During passive reconnections, pending_session_name is None so this is a no-op.
+            if let Some(name) = self.pending_session_name.take() {
+                self.session_store.set_session_name(&source, name)?;
+            }
             self.session_store
                 .save_transport_state(&source, transport)?;
 
@@ -423,6 +431,9 @@ impl UserClient {
             // PSK connection: trust established via pre-shared key, no verification needed
             self.transports.insert(source, transport.clone());
             self.session_store.cache_session(source)?;
+            if let Some(name) = self.pending_session_name.take() {
+                self.session_store.set_session_name(&source, name)?;
+            }
             self.session_store
                 .save_transport_state(&source, transport)?;
 
@@ -456,6 +467,9 @@ impl UserClient {
             self.transports
                 .insert(pending.source, pending.transport.clone());
             self.session_store.cache_session(pending.source)?;
+            if let Some(name) = self.pending_session_name.take() {
+                self.session_store.set_session_name(&pending.source, name)?;
+            }
             self.session_store
                 .save_transport_state(&pending.source, pending.transport)?;
 
@@ -683,4 +697,9 @@ impl UserClient {
     pub fn rendezvous_code(&self) -> Option<&RendevouzCode> {
         self.rendezvous_code.as_ref()
     }
+
+    /// Set a friendly name to assign to the next newly-paired session
+    pub fn set_pending_session_name(&mut self, name: String) {
+        self.pending_session_name = Some(name);
+    }
 }

crates/bw-rat-client/src/traits.rs

@@ -30,6 +30,13 @@ pub trait SessionStore: Send + Sync {
     /// Returns tuples of (fingerprint, optional_name, created_timestamp, last_connected_timestamp)
     fn list_sessions(&self) -> Vec<(IdentityFingerprint, Option<String>, u64, u64)>;
 
+    /// Set a friendly name for a cached session
+    fn set_session_name(
+        &mut self,
+        fingerprint: &IdentityFingerprint,
+        name: String,
+    ) -> Result<(), RemoteClientError>;
+
     /// Update the last_connected_at timestamp for a session
     fn update_last_connected(
         &mut self,

crates/bw-rat-client/tests/pairing.rs

@@ -129,6 +129,14 @@ impl SessionStore for MockSessionStore {
             .collect()
     }
 
+    fn set_session_name(
+        &mut self,
+        _fingerprint: &IdentityFingerprint,
+        _name: String,
+    ) -> Result<(), bw_rat_client::RemoteClientError> {
+        Ok(())
+    }
+
     fn update_last_connected(
         &mut self,
         fingerprint: &IdentityFingerprint,

crates/bw-rat-client/tests/websocket_proxy.rs

@@ -135,6 +135,14 @@ impl SessionStore for MockSessionStore {
             .collect()
     }
 
+    fn set_session_name(
+        &mut self,
+        _fingerprint: &IdentityFingerprint,
+        _name: String,
+    ) -> Result<(), bw_rat_client::RemoteClientError> {
+        Ok(())
+    }
+
     fn update_last_connected(
         &mut self,
         fingerprint: &IdentityFingerprint,
@@ -216,6 +224,17 @@ impl SessionStore for SharedSessionStore {
             .list_sessions()
     }
 
+    fn set_session_name(
+        &mut self,
+        fingerprint: &IdentityFingerprint,
+        name: String,
+    ) -> Result<(), bw_rat_client::RemoteClientError> {
+        self.0
+            .lock()
+            .expect("Lock should not be poisoned")
+            .set_session_name(fingerprint, name)
+    }
+
     fn update_last_connected(
         &mut self,
         fingerprint: &IdentityFingerprint,
@@ -1042,6 +1061,17 @@ async fn test_e2e_transport_state_persistence() {
                         .list_sessions()
                 }
 
+                fn set_session_name(
+                    &mut self,
+                    fingerprint: &IdentityFingerprint,
+                    name: String,
+                ) -> Result<(), bw_rat_client::RemoteClientError> {
+                    self.0
+                        .lock()
+                        .expect("Lock should not be poisoned")
+                        .set_session_name(fingerprint, name)
+                }
+
                 fn update_last_connected(
                     &mut self,
                     fingerprint: &IdentityFingerprint,

crates/bw-remote/src/command/cache.rs

@@ -43,10 +43,14 @@ impl ListCacheArgs {
         // Sort by last_connected descending (most recent first)
         sessions.sort_by(|a, b| b.3.cmp(&a.3));
 
-        for (fingerprint, _name, _cached_at, last_connected) in &sessions {
+        for (fingerprint, name, _cached_at, last_connected) in &sessions {
             let hex = hex::encode(fingerprint.0);
             let relative = format_relative_time(*last_connected);
-            println!("{hex}  (last used: {relative})");
+            if let Some(name) = name {
+                println!("{name}  {hex}  (last used: {relative})");
+            } else {
+                println!("{hex}  (last used: {relative})");
+            }
         }
 
         Ok(())

crates/bw-remote/src/command/listen.rs

@@ -60,10 +60,10 @@ enum Phase {
     },
 }
 
-/// Whether the event loop exited normally or because `/new` was requested.
+/// Whether the event loop exited normally or because `/pair` was requested.
 enum EventLoopExit {
     Quit,
-    NewSession,
+    NewSession { name: Option<String> },
 }
 
 /// Bitwarden CLI login item structure
@@ -219,6 +219,13 @@ fn check_bw_status() -> BwStatus {
 
 type SessionInfo = (IdentityFingerprint, Option<String>, u64, u64);
 
+/// Reload the session list from disk (the client may have updated it).
+fn reload_sessions() -> Vec<SessionInfo> {
+    FileSessionCache::load_or_create("user_client")
+        .map(|cache| cache.list_sessions())
+        .unwrap_or_default()
+}
+
 /// Build session info messages for display in the TUI.
 fn session_info_messages(sessions: &[SessionInfo], pending_label: Option<&str>) -> Vec<Message> {
     let mut sorted = sessions.to_vec();
@@ -233,29 +240,38 @@ fn session_info_messages(sessions: &[SessionInfo], pending_label: Option<&str>)
                 .add_modifier(Modifier::BOLD),
         )],
     )];
-    for (fingerprint, _, cached_at, last_connected_at) in &sorted {
+    for (fingerprint, name, cached_at, last_connected_at) in &sorted {
         let short_hex = hex::encode(fingerprint.0)
             .chars()
             .take(12)
             .collect::<String>();
         let created = format_relative_time(*cached_at);
         let last_used = format_relative_time(*last_connected_at);
-        msgs.push(Message::rich(
-            MessageKind::Info,
-            vec![
-                Span::raw("  "),
-                Span::styled(
-                    short_hex,
-                    Style::default()
-                        .fg(Color::Cyan)
-                        .add_modifier(Modifier::BOLD),
-                ),
-                Span::styled(
-                    format!("  created {created}, last used {last_used}"),
-                    Style::default().fg(Color::DarkGray),
-                ),
-            ],
+        let mut spans = vec![Span::raw("  ")];
+        if let Some(name) = name {
+            spans.push(Span::styled(
+                name.clone(),
+                Style::default()
+                    .fg(Color::Yellow)
+                    .add_modifier(Modifier::BOLD),
+            ));
+            spans.push(Span::styled(
+                format!(" ({short_hex})"),
+                Style::default().fg(Color::DarkGray),
+            ));
+        } else {
+            spans.push(Span::styled(
+                short_hex,
+                Style::default()
+                    .fg(Color::Cyan)
+                    .add_modifier(Modifier::BOLD),
+            ));
+        }
+        spans.push(Span::styled(
+            format!("  created {created}, last used {last_used}"),
+            Style::default().fg(Color::DarkGray),
         ));
+        msgs.push(Message::rich(MessageKind::Info, spans));
     }
     if let Some(label) = pending_label {
         msgs.push(Message::new(MessageKind::Info, format!("  {label}")));
@@ -266,7 +282,8 @@ fn session_info_messages(sessions: &[SessionInfo], pending_label: Option<&str>)
 /// Set up the idle-mode footer for the TUI.
 fn idle_footer() -> Line<'static> {
     Line::from(vec![
-        Span::styled(" /new", Style::default().fg(Color::Cyan)),
+        Span::styled(" /pair", Style::default().fg(Color::Cyan)),
+        Span::styled(" [name]", Style::default().fg(Color::DarkGray)),
         Span::raw(" create session  "),
         Span::styled("/exit", Style::default().fg(Color::Cyan)),
         Span::raw(" quit  "),
@@ -280,7 +297,7 @@ fn idle_footer() -> Line<'static> {
 /// in a single `select!` loop. The `client_handle` is aborted on exit.
 ///
 /// The TUI state (`app`, `term`, `reader`) is owned by the caller so that
-/// it survives across `/new` session restarts without flickering.
+/// it survives across `/pair` session restarts without flickering.
 async fn run_event_loop(
     app: &mut App,
     term: &mut ratatui::DefaultTerminal,
@@ -296,7 +313,7 @@ async fn run_event_loop(
     app.set_mode(Mode::TextInput);
     app.set_session_panel(session_info_messages(sessions, None));
     app.footer = idle_footer();
-    app.commands = &["/new", "/exit"];
+    app.commands = &["/pair [name]", "/exit"];
 
     let mut tick_interval = tokio::time::interval(std::time::Duration::from_millis(150));
 
@@ -315,8 +332,11 @@ async fn run_event_loop(
                         if let Some(action) = app.handle_key(key) {
                             match (&phase, &action) {
                                 // Idle commands
-                                (Phase::Idle, AppAction::Submit(s)) if s == "/new" => {
-                                    break EventLoopExit::NewSession;
+                                (Phase::Idle, AppAction::Submit(s)) if s.starts_with("/pair") => {
+                                    let name = s.strip_prefix("/pair ")
+                                        .map(|n| n.trim().to_string())
+                                        .filter(|n| !n.is_empty());
+                                    break EventLoopExit::NewSession { name };
                                 }
                                 (Phase::Idle, AppAction::Submit(s)) if s == "/exit" => {
                                     break EventLoopExit::Quit;
@@ -337,7 +357,7 @@ async fn run_event_loop(
                                     phase = Phase::Idle;
                                     app.set_mode(Mode::TextInput);
                                     app.footer = idle_footer();
-                                    app.commands = &["/new", "/exit"];
+                                    app.commands = &["/pair [name]", "/exit"];
                                 }
 
                                 // Credential approval
@@ -371,7 +391,7 @@ async fn run_event_loop(
                                     }
                                     app.set_mode(Mode::TextInput);
                                     app.footer = idle_footer();
-                                    app.commands = &["/new", "/exit"];
+                                    app.commands = &["/pair [name]", "/exit"];
                                 }
 
                                 (_, AppAction::Quit) => break EventLoopExit::Quit,
@@ -462,9 +482,11 @@ async fn run_event_loop(
                                 // Update session panel with pending label
                                 app.set_session_panel(session_info_messages(sessions, Some("New session  (awaiting connection)")));
                             }
-                            UserClientEvent::SessionRefreshed { .. } => {
-                                // Known device reconnected — clear pending label
-                                app.set_session_panel(session_info_messages(sessions, None));
+                            UserClientEvent::SessionRefreshed { .. }
+                            | UserClientEvent::FingerprintVerified { .. } => {
+                                // Session store was updated — reload from disk
+                                let fresh = reload_sessions();
+                                app.set_session_panel(session_info_messages(&fresh, None));
                             }
                             _ => {}
                         }
@@ -491,10 +513,11 @@ async fn run_user_client_session(proxy_url: String, psk_mode: bool) -> Result<()
     local
         .run_until(async move {
             // First iteration: if cached sessions exist, listen on those immediately.
-            // On `/new`, we loop back and start a fresh rendezvous/psk session.
+            // On `/pair`, we loop back and start a fresh rendezvous/psk session.
             let mut force_new_session = false;
+            let mut pending_session_name: Option<String> = None;
 
-            // Create TUI state once — it survives across `/new` restarts.
+            // Create TUI state once — it survives across `/pair` restarts.
             let mut app = App::new();
             app.client_label = "User client";
             let bw_status = check_bw_status();
@@ -506,7 +529,8 @@ async fn run_user_client_session(proxy_url: String, psk_mode: bool) -> Result<()
             loop {
                 let identity_provider =
                     Box::new(FileIdentityStorage::load_or_generate("user_client")?);
-                let session_store = Box::new(FileSessionCache::load_or_create("user_client")?);
+                let session_cache = FileSessionCache::load_or_create("user_client")?;
+                let session_store = Box::new(session_cache);
                 let cached_sessions = session_store.list_sessions();
 
                 let has_cached = !cached_sessions.is_empty() && !force_new_session;
@@ -521,6 +545,7 @@ async fn run_user_client_session(proxy_url: String, psk_mode: bool) -> Result<()
 
                 let sessions = session_store.list_sessions();
 
+                let session_name = pending_session_name.take();
                 let client_handle = tokio::task::spawn_local(async move {
                     let mut client = UserClient::listen(
                         identity_provider as Box<dyn IdentityProvider>,
@@ -529,6 +554,10 @@ async fn run_user_client_session(proxy_url: String, psk_mode: bool) -> Result<()
                     )
                     .await?;
 
+                    if let Some(name) = session_name {
+                        client.set_pending_session_name(name);
+                    }
+
                     if has_cached {
                         client.listen_cached_only(event_tx, response_rx).await
                     } else if psk_mode {
@@ -549,8 +578,9 @@ async fn run_user_client_session(proxy_url: String, psk_mode: bool) -> Result<()
                 )
                 .await?
                 {
-                    EventLoopExit::NewSession => {
+                    EventLoopExit::NewSession { name } => {
                         force_new_session = true;
+                        pending_session_name = name;
                         continue;
                     }
                     EventLoopExit::Quit => break,