feat: add confirmed profile deletion

Author: floscodes

src/app.rs

@@ -32,6 +32,7 @@ pub enum InputMode {
     #[default]
     None,
     CreateProfile,
+    ConfirmDeleteProfile,
 }
 
 /// All state owned by the user interface.
@@ -70,6 +71,8 @@ pub struct App {
     pub(crate) send_area: Cell<Rect>,
     pub(crate) jump_to_latest_area: Cell<Rect>,
     pub(crate) max_chat_scroll: Cell<usize>,
+    pub(crate) delete_cancel_area: Cell<Rect>,
+    pub(crate) delete_ok_area: Cell<Rect>,
     pub events: EventHandler,
     message_cache: HashMap<ChatRef, Vec<Message>>,
     simplex_events: mpsc::Receiver<SimplexEvent>,
@@ -113,6 +116,8 @@ impl Default for App {
             send_area: Cell::new(Rect::default()),
             jump_to_latest_area: Cell::new(Rect::default()),
             max_chat_scroll: Cell::new(0),
+            delete_cancel_area: Cell::new(Rect::default()),
+            delete_ok_area: Cell::new(Rect::default()),
             events: EventHandler::new(),
             message_cache: HashMap::new(),
             simplex_events,
@@ -170,6 +175,14 @@ impl App {
             self.events.send(AppEvent::Quit);
             return Ok(());
         }
+        if self.input_mode == InputMode::ConfirmDeleteProfile {
+            match key.code {
+                KeyCode::Char('y') => self.confirm_delete_profile(),
+                KeyCode::Enter | KeyCode::Esc => self.input_mode = InputMode::None,
+                _ => {}
+            }
+            return Ok(());
+        }
         if self.input_mode == InputMode::CreateProfile {
             match key.code {
                 KeyCode::Esc => {
@@ -245,6 +258,12 @@ impl App {
                 self.input_mode = InputMode::CreateProfile;
                 self.input.clear();
             }
+            KeyCode::Char('d')
+                if self.section == Section::Profiles
+                    && self.selected_profile < self.profiles.len() =>
+            {
+                self.input_mode = InputMode::ConfirmDeleteProfile;
+            }
             KeyCode::Enter | KeyCode::Char(' ') if self.section == Section::Settings => {
                 self.activate_setting()
             }
@@ -314,6 +333,16 @@ impl App {
     }
 
     fn handle_mouse_event(&mut self, kind: MouseEventKind, column: u16, row: u16) {
+        if self.input_mode == InputMode::ConfirmDeleteProfile
+            && matches!(kind, MouseEventKind::Down(MouseButton::Left))
+        {
+            if self.delete_ok_area.get().contains((column, row).into()) {
+                self.confirm_delete_profile();
+            } else if self.delete_cancel_area.get().contains((column, row).into()) {
+                self.input_mode = InputMode::None;
+            }
+            return;
+        }
         if matches!(kind, MouseEventKind::Down(MouseButton::Left)) {
             if self
                 .jump_to_latest_area
@@ -482,6 +511,26 @@ impl App {
                     self.notice = Some("Profile created".into());
                     self.sync_selected_profile();
                 }
+                SimplexEvent::ProfileDeleted {
+                    profiles,
+                    active_user,
+                    chats,
+                } => {
+                    self.profiles = profiles;
+                    self.chats = chats;
+                    self.messages.clear();
+                    self.message_cache.clear();
+                    self.loaded_chat = None;
+                    self.selected_chat = 0;
+                    self.startup = active_user
+                        .map(StartupState::Ready)
+                        .unwrap_or(StartupState::NoActiveUser);
+                    self.notice = Some("Profile deleted".into());
+                    self.sync_selected_profile();
+                }
+                SimplexEvent::ProfileDeleteFailed(error) => {
+                    self.notice = Some(format!("Could not delete profile: {error}"));
+                }
                 SimplexEvent::SettingChanged(message) => self.notice = Some(message),
                 SimplexEvent::AutoDeleteLoaded(seconds) => self.auto_delete_seconds = seconds,
                 SimplexEvent::ServersLoaded(servers) => self.smp_servers = servers,
@@ -734,6 +783,19 @@ impl App {
             .send(SimplexCommand::ActivateProfile(profile.id));
     }
 
+    fn confirm_delete_profile(&mut self) {
+        let Some(profile) = self.profiles.get(self.selected_profile) else {
+            self.input_mode = InputMode::None;
+            return;
+        };
+        let user_id = profile.id;
+        self.input_mode = InputMode::None;
+        self.notice = Some(format!("Deleting profile {}…", profile.display_name));
+        let _ = self
+            .simplex_commands
+            .send(SimplexCommand::DeleteProfile(user_id));
+    }
+
     fn activate_setting(&mut self) {
         match self.selected_setting {
             1 => {
@@ -1059,4 +1121,37 @@ mod tests {
         app.tick();
         assert_eq!(app.messages[0].text, "from background");
     }
+
+    #[tokio::test]
+    async fn profile_delete_requires_explicit_confirmation() {
+        let (commands, receiver) = mpsc::channel();
+        let mut app = App {
+            section: Section::Profiles,
+            profiles: vec![Profile {
+                id: 9,
+                display_name: "work".into(),
+                notifications: true,
+                active: true,
+            }],
+            simplex_commands: commands,
+            ..App::default()
+        };
+
+        app.handle_key_events(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE))
+            .unwrap();
+        assert_eq!(app.input_mode, InputMode::ConfirmDeleteProfile);
+        app.handle_key_events(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .unwrap();
+        assert_eq!(app.input_mode, InputMode::None);
+        assert!(receiver.try_recv().is_err());
+
+        app.handle_key_events(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE))
+            .unwrap();
+        app.handle_key_events(KeyEvent::new(KeyCode::Char('y'), KeyModifiers::NONE))
+            .unwrap();
+        let SimplexCommand::DeleteProfile(user_id) = receiver.try_recv().unwrap() else {
+            panic!("expected delete-profile command")
+        };
+        assert_eq!(user_id, 9);
+    }
 }

src/chat.rs

@@ -53,6 +53,12 @@ pub enum SimplexEvent {
         profiles: Vec<Profile>,
         chats: Vec<ChatSummary>,
     },
+    ProfileDeleted {
+        profiles: Vec<Profile>,
+        active_user: Option<User>,
+        chats: Vec<ChatSummary>,
+    },
+    ProfileDeleteFailed(String),
     SettingChanged(String),
     AutoDeleteLoaded(i64),
     ServersLoaded(Vec<String>),

src/simplex_worker.rs

@@ -22,6 +22,7 @@ pub enum SimplexCommand {
     },
     ActivateProfile(i64),
     CreateProfile(String),
+    DeleteProfile(i64),
     SetNotifications {
         user_id: i64,
         enabled: bool,
@@ -49,6 +50,12 @@ pub enum ChatFeature {
     FilesAndMedia,
 }
 
+struct DeletedProfileState {
+    profiles: Vec<chat::Profile>,
+    active_user: Option<chat::User>,
+    chats: Vec<chat::ChatSummary>,
+}
+
 pub fn spawn(api: Arc<SimplexApi>, sender: Sender<SimplexEvent>) -> Sender<SimplexCommand> {
     let (command_sender, commands) = mpsc::channel();
     thread::Builder::new()
@@ -224,6 +231,19 @@ fn command_loop(
                         .send(result.unwrap_or_else(SimplexEvent::Failed))
                         .map_err(|e| e.to_string())?;
                 }
+                SimplexCommand::DeleteProfile(user_id) => {
+                    let result = delete_profile(&controller, user_id);
+                    sender
+                        .send(match result {
+                            Ok(state) => SimplexEvent::ProfileDeleted {
+                                profiles: state.profiles,
+                                active_user: state.active_user,
+                                chats: state.chats,
+                            },
+                            Err(error) => SimplexEvent::ProfileDeleteFailed(error),
+                        })
+                        .map_err(|e| e.to_string())?;
+                }
                 SimplexCommand::SetNotifications { user_id, enabled } => {
                     let action = if enabled { "unmute" } else { "mute" };
                     let response = controller
@@ -300,6 +320,39 @@ fn command_loop(
     }
 }
 
+fn delete_profile(
+    controller: &crate::simplex::SimplexController,
+    user_id: i64,
+) -> Result<DeletedProfileState, String> {
+    let profiles = load_profiles(controller)?;
+    if profiles
+        .iter()
+        .any(|profile| profile.id == user_id && profile.active)
+        && let Some(other) = profiles.iter().find(|profile| profile.id != user_id)
+    {
+        let response = controller
+            .command(&format!("/_user {}", other.id))
+            .map_err(|e| e.to_string())?;
+        chat::active_user(&response)?.ok_or("SimpleX did not activate the replacement profile")?;
+    }
+    let response = controller
+        .command(&format!("/_delete user {user_id} del_smp=on"))
+        .map_err(|e| e.to_string())?;
+    ensure_ok(&response, "profile deletion")?;
+    let profiles = load_profiles(controller)?;
+    let active_user = chat::active_user(&controller.command("/u").map_err(|e| e.to_string())?)?;
+    let chats = if let Some(user) = &active_user {
+        load_chats(controller, user.id)?
+    } else {
+        Vec::new()
+    };
+    Ok(DeletedProfileState {
+        profiles,
+        active_user,
+        chats,
+    })
+}
+
 fn mark_chat_read(
     controller: &crate::simplex::SimplexController,
     sender: &Sender<SimplexEvent>,

src/ui.rs

@@ -4,7 +4,9 @@ use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::{Color, Modifier, Style, Stylize},
     text::{Line, Span},
-    widgets::{Block, BorderType, Borders, List, ListItem, Padding, Paragraph, Tabs, Widget, Wrap},
+    widgets::{
+        Block, BorderType, Borders, Clear, List, ListItem, Padding, Paragraph, Tabs, Widget, Wrap,
+    },
 };
 use tui_qrcode::{Colors, QrCodeWidget, Scaling};
 
@@ -32,6 +34,8 @@ impl Widget for &App {
         self.composer_area.set(Rect::default());
         self.send_area.set(Rect::default());
         self.jump_to_latest_area.set(Rect::default());
+        self.delete_cancel_area.set(Rect::default());
+        self.delete_ok_area.set(Rect::default());
         let columns = Layout::default()
             .direction(Direction::Horizontal)
             .constraints([Constraint::Percentage(32), Constraint::Percentage(68)])
@@ -44,6 +48,9 @@ impl Widget for &App {
         render_tabs(self, sidebar[0], buf);
         render_sidebar(self, sidebar[1], buf);
         render_detail(self, columns[1], buf);
+        if self.input_mode == InputMode::ConfirmDeleteProfile {
+            render_delete_profile_confirmation(self, area, buf);
+        }
     }
 }
 
@@ -173,7 +180,7 @@ fn render_profile(app: &App, area: Rect, buf: &mut Buffer) {
     }
     let profile = &app.profiles[app.selected_profile];
     Paragraph::new(format!(
-        "Display name\n{}\n\nNotifications\n{}\n\nStatus\n{}\n\nEnter: activate · n: new profile",
+        "Display name\n{}\n\nNotifications\n{}\n\nStatus\n{}\n\nEnter: activate · n: new profile · d: delete",
         profile.display_name,
         enabled(profile.notifications),
         if profile.active { "Active" } else { "Inactive" },
@@ -183,6 +190,55 @@ fn render_profile(app: &App, area: Rect, buf: &mut Buffer) {
     .render(area, buf);
 }
 
+fn render_delete_profile_confirmation(app: &App, area: Rect, buf: &mut Buffer) {
+    let Some(profile) = app.profiles.get(app.selected_profile) else {
+        return;
+    };
+    let width = area.width.min(68);
+    let height = area.height.min(9);
+    let popup = Rect::new(
+        area.x + area.width.saturating_sub(width) / 2,
+        area.y + area.height.saturating_sub(height) / 2,
+        width,
+        height,
+    );
+    Clear.render(popup, buf);
+    let block = Block::bordered()
+        .border_type(BorderType::Rounded)
+        .border_style(Style::default().fg(Color::Red))
+        .title(" Delete profile ");
+    let inner = block.inner(popup);
+    block.render(popup, buf);
+    let rows = Layout::vertical([Constraint::Min(2), Constraint::Length(3)]).split(inner);
+    Paragraph::new(format!(
+        "Are you sure that you want to delete profile {}?",
+        profile.display_name
+    ))
+    .alignment(Alignment::Center)
+    .wrap(Wrap { trim: false })
+    .render(rows[0], buf);
+    let buttons =
+        Layout::horizontal([Constraint::Percentage(50), Constraint::Percentage(50)]).split(rows[1]);
+    app.delete_cancel_area.set(buttons[0]);
+    app.delete_ok_area.set(buttons[1]);
+    Paragraph::new("Cancel (Enter)")
+        .alignment(Alignment::Center)
+        .block(
+            Block::bordered()
+                .border_type(BorderType::Rounded)
+                .border_style(Style::default().fg(Color::Cyan)),
+        )
+        .render(buttons[0], buf);
+    Paragraph::new("OK (y)")
+        .alignment(Alignment::Center)
+        .block(
+            Block::bordered()
+                .border_type(BorderType::Rounded)
+                .border_style(Style::default().fg(Color::Red)),
+        )
+        .render(buttons[1], buf);
+}
+
 fn render_chat(app: &App, area: Rect, buf: &mut Buffer) {
     if app.active_user().is_some() && app.selected_chat == app.chats.len() {
         render_invitation(app, area, buf);