feat(rooms): private room membership, operators and refusals

Private rooms were unreachable: the client could ask to join one but had
no way to invite, promote, resign or be told what happened, and a room
name already owned by someone else came back as silence rather than a
refusal (code 1003).

Adds the rosters the server pushes after login (133/148), the changes it
narrates to them (134/135, 143/144), our own standing (139/140, 145/146),
and the messages that drive them, with the rosters kept current in client
state. The daemon protocol and the TUI room transcript carry the new
events rather than dropping them.

soulseek-rs-lib/src/client/mod.rs

@@ -440,6 +440,11 @@ pub struct ClientContext {
     /// Per-member statistics for each joined room, from the stat vectors the
     /// server sends alongside the membership list.
     room_member_stats: HashMap<String, Vec<RoomUserStats>>,
+    /// Who may enter each private room we belong to (code 133), kept current
+    /// from the later roster changes.
+    private_room_members: HashMap<String, Vec<String>>,
+    /// Who runs each of those rooms (code 148).
+    private_room_operators: HashMap<String, Vec<String>>,
     /// The ticker board of each joined room, kept current from the board sent
     /// on join (code 113) and the later add/remove events (114/115).
     room_tickers: HashMap<String, Vec<RoomTicker>>,
@@ -490,6 +495,15 @@ pub struct ClientContext {
     upload_events: Vec<crate::types::UploadInfo>,
     actor_system: Arc<ActorSystem>,
 }
+/// A roster sorted and de-duplicated, so membership lookups can binary-search
+/// it and a repeated name cannot appear twice.
+fn sorted_unique(users: &[String]) -> Vec<String> {
+    let mut users = users.to_vec();
+    users.sort();
+    users.dedup();
+    users
+}
+
 impl Default for ClientContext {
     fn default() -> Self {
         Self::new()
@@ -569,6 +583,8 @@ impl ClientContext {
             room_members: HashMap::new(),
             room_member_stats: HashMap::new(),
             room_tickers: HashMap::new(),
+            private_room_members: HashMap::new(),
+            private_room_operators: HashMap::new(),
             recommendations: None,
             global_recommendations: None,
             item_recommendations: HashMap::new(),
@@ -641,11 +657,84 @@ impl ClientContext {
                     board.retain(|t| &t.username != username);
                 }
             }
-            RoomEvent::Message { .. } | RoomEvent::GlobalMessage { .. } => {}
+            RoomEvent::PrivateMembers { room, users } => {
+                self.private_room_members
+                    .insert(room.clone(), sorted_unique(users));
+            }
+            RoomEvent::PrivateOperators { room, users } => {
+                self.private_room_operators
+                    .insert(room.clone(), sorted_unique(users));
+            }
+            RoomEvent::PrivateRosterChanged {
+                room,
+                username,
+                members,
+                added,
+            } => {
+                let roster = if *members {
+                    self.private_room_members.entry(room.clone()).or_default()
+                } else {
+                    self.private_room_operators.entry(room.clone()).or_default()
+                };
+                match (added, roster.binary_search(username)) {
+                    (true, Err(at)) => roster.insert(at, username.clone()),
+                    (false, Ok(at)) => {
+                        roster.remove(at);
+                    }
+                    _ => {}
+                }
+            }
+            RoomEvent::OwnStandingChanged {
+                room,
+                members,
+                granted,
+            } => {
+                // Our own standing is rendered from the same rosters, so a
+                // revocation must drop the room rather than leave a roster
+                // we are no longer part of looking current.
+                if !granted {
+                    // Losing membership takes the operator roster with it:
+                    // a room we cannot enter has no roster worth showing.
+                    if *members {
+                        self.private_room_members.remove(room);
+                    }
+                    self.private_room_operators.remove(room);
+                }
+            }
+            RoomEvent::Message { .. }
+            | RoomEvent::GlobalMessage { .. }
+            | RoomEvent::CantCreate { .. } => {}
         }
         self.room_events.push(event);
     }
 
+    /// Who may enter the private room `room`, as last reported.
+    #[must_use]
+    pub fn private_room_members(&self, room: &str) -> Vec<String> {
+        self.private_room_members
+            .get(room)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    /// Who runs the private room `room`, as last reported.
+    #[must_use]
+    pub fn private_room_operators(&self, room: &str) -> Vec<String> {
+        self.private_room_operators
+            .get(room)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    /// The private rooms we belong to, in a stable order.
+    #[must_use]
+    pub fn private_rooms(&self) -> Vec<String> {
+        let mut rooms: Vec<String> =
+            self.private_room_members.keys().cloned().collect();
+        rooms.sort();
+        rooms
+    }
+
     /// The ticker board of `room` as last reported by the server.
     #[must_use]
     pub fn room_tickers(&self, room: &str) -> Vec<RoomTicker> {

soulseek-rs-lib/src/client/social.rs

@@ -21,6 +21,137 @@ impl Client {
         self.send_server_message(MessageFactory::build_server_ping())
     }
 
+    /// Join a private room, creating it (and owning it) if the name is free.
+    ///
+    /// A name already taken by someone else's private room comes back as a
+    /// [`crate::RoomEvent::CantCreate`] rather than a join.
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn join_private_room(&self, room: &str) -> Result<()> {
+        self.send_server_message(MessageFactory::build_join_room(room, true))
+    }
+
+    /// Invite `username` into the private room we own (code 134).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn add_room_member(&self, room: &str, username: &str) -> Result<()> {
+        self.send_server_message(MessageFactory::build_add_room_member(
+            room, username,
+        ))
+    }
+
+    /// Remove `username` from the private room we own (code 135).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn remove_room_member(&self, room: &str, username: &str) -> Result<()> {
+        self.send_server_message(MessageFactory::build_remove_room_member(
+            room, username,
+        ))
+    }
+
+    /// Give up our own membership of a private room (code 136).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn leave_private_room(&self, room: &str) -> Result<()> {
+        self.send_server_message(MessageFactory::build_cancel_room_membership(
+            room,
+        ))
+    }
+
+    /// Give up ownership of a private room, which deletes it (code 137).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn disband_private_room(&self, room: &str) -> Result<()> {
+        self.send_server_message(MessageFactory::build_cancel_room_ownership(
+            room,
+        ))
+    }
+
+    /// Say whether we accept private-room invitations (code 141).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn set_room_invitations_enabled(&self, enabled: bool) -> Result<()> {
+        self.send_server_message(MessageFactory::build_enable_room_invitations(
+            enabled,
+        ))
+    }
+
+    /// Make `username` an operator of our private room (code 143).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn add_room_operator(&self, room: &str, username: &str) -> Result<()> {
+        self.send_server_message(MessageFactory::build_add_room_operator(
+            room, username,
+        ))
+    }
+
+    /// Take operator status away from `username` (code 144).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn remove_room_operator(
+        &self,
+        room: &str,
+        username: &str,
+    ) -> Result<()> {
+        self.send_server_message(MessageFactory::build_remove_room_operator(
+            room, username,
+        ))
+    }
+
+    /// Give up our own operator status in `room` (code 147).
+    ///
+    /// # Errors
+    /// [`crate::SoulseekRs::NotConnected`] when there is no server connection.
+    pub fn resign_room_operatorship(&self, room: &str) -> Result<()> {
+        self.send_server_message(
+            MessageFactory::build_cancel_room_operatorship(room),
+        )
+    }
+
+    /// Who may enter the private room `room`, as the server last reported.
+    #[must_use]
+    pub fn private_room_members(&self, room: &str) -> Vec<String> {
+        match self.context.read_safe() {
+            Ok(ctx) => ctx.private_room_members(room),
+            Err(e) => {
+                error!("[client] private_room_members: {}", e);
+                Vec::new()
+            }
+        }
+    }
+
+    /// Who runs the private room `room`.
+    #[must_use]
+    pub fn private_room_operators(&self, room: &str) -> Vec<String> {
+        match self.context.read_safe() {
+            Ok(ctx) => ctx.private_room_operators(room),
+            Err(e) => {
+                error!("[client] private_room_operators: {}", e);
+                Vec::new()
+            }
+        }
+    }
+
+    /// The private rooms we belong to.
+    #[must_use]
+    pub fn private_rooms(&self) -> Vec<String> {
+        match self.context.read_safe() {
+            Ok(ctx) => ctx.private_rooms(),
+            Err(e) => {
+                error!("[client] private_rooms: {}", e);
+                Vec::new()
+            }
+        }
+    }
+
     /// Set our online status (server code 28): away, or back to online.
     ///
     /// Other clients see it in their `GetUserStatus` and watch replies, and

soulseek-rs-lib/src/client/tests.rs

@@ -951,3 +951,86 @@ fn asking_again_about_a_users_interests_drops_the_previous_answer() {
         "a stale answer must not be mistaken for the next one"
     );
 }
+
+#[test]
+fn a_private_room_roster_tracks_who_is_added_and_removed() {
+    let mut ctx = ClientContext::new();
+    ctx.apply_room_event(RoomEvent::PrivateMembers {
+        room: "club".into(),
+        users: vec!["bob".into(), "alice".into(), "bob".into()],
+    });
+    assert_eq!(
+        ctx.private_room_members("club"),
+        vec!["alice".to_string(), "bob".to_string()],
+        "a roster is sorted and free of repeats"
+    );
+
+    ctx.apply_room_event(RoomEvent::PrivateRosterChanged {
+        room: "club".into(),
+        username: "carol".into(),
+        members: true,
+        added: true,
+    });
+    ctx.apply_room_event(RoomEvent::PrivateRosterChanged {
+        room: "club".into(),
+        username: "alice".into(),
+        members: true,
+        added: false,
+    });
+    assert_eq!(
+        ctx.private_room_members("club"),
+        vec!["bob".to_string(), "carol".to_string()]
+    );
+
+    // Operators are a separate roster in the same room.
+    ctx.apply_room_event(RoomEvent::PrivateRosterChanged {
+        room: "club".into(),
+        username: "bob".into(),
+        members: false,
+        added: true,
+    });
+    assert_eq!(ctx.private_room_operators("club"), vec!["bob".to_string()]);
+    assert_eq!(ctx.private_rooms(), vec!["club".to_string()]);
+}
+
+#[test]
+fn revoked_membership_drops_the_room_we_can_no_longer_see() {
+    let mut ctx = ClientContext::new();
+    ctx.apply_room_event(RoomEvent::PrivateMembers {
+        room: "club".into(),
+        users: vec!["alice".into()],
+    });
+    ctx.apply_room_event(RoomEvent::PrivateOperators {
+        room: "club".into(),
+        users: vec!["alice".into()],
+    });
+
+    ctx.apply_room_event(RoomEvent::OwnStandingChanged {
+        room: "club".into(),
+        members: true,
+        granted: false,
+    });
+    assert!(ctx.private_rooms().is_empty());
+    assert!(ctx.private_room_operators("club").is_empty());
+}
+
+#[test]
+fn losing_operatorship_keeps_the_membership_it_does_not_touch() {
+    let mut ctx = ClientContext::new();
+    ctx.apply_room_event(RoomEvent::PrivateMembers {
+        room: "club".into(),
+        users: vec!["alice".into()],
+    });
+    ctx.apply_room_event(RoomEvent::PrivateOperators {
+        room: "club".into(),
+        users: vec!["alice".into()],
+    });
+
+    ctx.apply_room_event(RoomEvent::OwnStandingChanged {
+        room: "club".into(),
+        members: false,
+        granted: false,
+    });
+    assert_eq!(ctx.private_room_members("club"), vec!["alice".to_string()]);
+    assert!(ctx.private_room_operators("club").is_empty());
+}