@wlfi-agent/cli 1.4.14 → 1.4.16

package/crates/vault-cli-admin/src/tui.rs

@@ -9,7 +9,7 @@ use crossterm::execute;
 use crossterm::terminal::{
     disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
 };
-use ratatui::backend::CrosstermBackend;
+use ratatui::backend::{Backend, CrosstermBackend};
 use ratatui::layout::{Constraint, Direction, Layout};
 use ratatui::style::{Color, Modifier, Style};
 use ratatui::text::{Line, Span};
@@ -123,6 +123,42 @@ impl View {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum PendingDiscardAction {
+    NextView,
+    PreviousView,
+    ReloadCurrentView,
+    NewTokenDraft,
+    NewNetworkDraft,
+    CycleSavedToken(i8),
+    CycleSavedNetwork(i8),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum PendingDeleteAction {
+    DeleteDestinationOverride,
+    DeleteManualApproval,
+    DeleteToken,
+    DeleteNetwork,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum MessageLevel {
+    Info,
+    Success,
+    Error,
+}
+
+impl MessageLevel {
+    fn style(self) -> Style {
+        match self {
+            Self::Info => Style::default().fg(Color::Cyan),
+            Self::Success => Style::default().fg(Color::Green),
+            Self::Error => Style::default().fg(Color::Red),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Field {
     SelectedToken,
@@ -726,7 +762,12 @@ struct AppState {
     network_draft: NetworkDraft,
     show_advanced: bool,
     print_agent_auth_token: bool,
+    token_dirty: bool,
+    network_dirty: bool,
+    pending_discard_action: Option<PendingDiscardAction>,
+    pending_delete_action: Option<PendingDeleteAction>,
     message: Option<String>,
+    message_level: MessageLevel,
 }
 
 impl AppState {
@@ -760,7 +801,12 @@ impl AppState {
             network_draft,
             show_advanced: false,
             print_agent_auth_token,
+            token_dirty: false,
+            network_dirty: false,
+            pending_discard_action: None,
+            pending_delete_action: None,
             message: None,
+            message_level: MessageLevel::Info,
         }
     }
 
@@ -860,17 +906,109 @@ impl AppState {
         self.visible_fields()[self.selected]
     }
 
+    fn active_draft_dirty(&self) -> bool {
+        match self.view {
+            View::Tokens => self.token_dirty,
+            View::Networks => self.network_dirty,
+            View::Bootstrap => false,
+        }
+    }
+
+    fn active_draft_label(&self) -> &'static str {
+        match self.view {
+            View::Tokens => "token draft",
+            View::Networks => "network draft",
+            View::Bootstrap => "current view",
+        }
+    }
+
+    fn clear_pending_discard(&mut self) {
+        self.pending_discard_action = None;
+    }
+
+    fn clear_pending_delete(&mut self) {
+        self.pending_delete_action = None;
+    }
+
+    fn clear_message(&mut self) {
+        self.message = None;
+        self.message_level = MessageLevel::Info;
+    }
+
+    fn set_info_message(&mut self, message: impl Into<String>) {
+        self.message = Some(message.into());
+        self.message_level = MessageLevel::Info;
+    }
+
+    fn set_success_message(&mut self, message: impl Into<String>) {
+        self.message = Some(message.into());
+        self.message_level = MessageLevel::Success;
+    }
+
+    fn set_error_message(&mut self, message: impl Into<String>) {
+        self.message = Some(message.into());
+        self.message_level = MessageLevel::Error;
+    }
+
+    fn mark_token_dirty(&mut self) {
+        self.token_dirty = true;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
+    }
+
+    fn mark_network_dirty(&mut self) {
+        self.network_dirty = true;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
+    }
+
+    fn confirm_discard(&mut self, action: PendingDiscardAction) -> bool {
+        if !self.active_draft_dirty() {
+            self.clear_pending_discard();
+            return true;
+        }
+
+        if self.pending_discard_action == Some(action) {
+            self.clear_pending_discard();
+            return true;
+        }
+
+        self.clear_pending_delete();
+        self.pending_discard_action = Some(action);
+        self.set_info_message(format!(
+            "unsaved changes in the {}; repeat the action to discard them or save first",
+            self.active_draft_label()
+        ));
+        false
+    }
+
+    fn confirm_delete(&mut self, action: PendingDeleteAction, label: &str) -> bool {
+        if self.pending_delete_action == Some(action) {
+            self.clear_pending_delete();
+            return true;
+        }
+
+        self.clear_pending_discard();
+        self.pending_delete_action = Some(action);
+        self.set_info_message(format!("repeat the action to confirm deleting {label}"));
+        false
+    }
+
     fn next_view(&mut self) {
         self.view = self.view.next();
         self.selected = 0;
-        self.message = None;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
+        self.clear_message();
         self.normalize_selection();
     }
 
     fn previous_view(&mut self) {
         self.view = self.view.previous();
         self.selected = 0;
-        self.message = None;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
+        self.clear_message();
         self.normalize_selection();
     }
 
@@ -906,6 +1044,42 @@ impl AppState {
         }
     }
 
+    fn request_next_view(&mut self) {
+        if self.confirm_discard(PendingDiscardAction::NextView) {
+            self.next_view();
+        }
+    }
+
+    fn request_previous_view(&mut self) {
+        if self.confirm_discard(PendingDiscardAction::PreviousView) {
+            self.previous_view();
+        }
+    }
+
+    fn request_reload_current_view(&mut self) -> bool {
+        if !self.confirm_discard(PendingDiscardAction::ReloadCurrentView) {
+            return false;
+        }
+        self.reload_current_view();
+        true
+    }
+
+    fn request_new_current_draft(&mut self) {
+        match self.view {
+            View::Tokens => {
+                if self.confirm_discard(PendingDiscardAction::NewTokenDraft) {
+                    self.new_token_draft();
+                }
+            }
+            View::Networks => {
+                if self.confirm_discard(PendingDiscardAction::NewNetworkDraft) {
+                    self.new_network_draft();
+                }
+            }
+            View::Bootstrap => {}
+        }
+    }
+
     fn load_token_draft(&mut self, token_key: Option<&str>) {
         self.token_draft = token_key
             .and_then(|token_key| {
@@ -933,6 +1107,9 @@ impl AppState {
                     })
             })
             .unwrap_or_else(|| TokenDraft::blank(&self.shared_config_draft));
+        self.token_dirty = false;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
         self.normalize_selection();
     }
 
@@ -963,22 +1140,81 @@ impl AppState {
                     })
             })
             .unwrap_or_else(NetworkDraft::blank);
+        self.network_dirty = false;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
         self.normalize_selection();
     }
 
     fn new_token_draft(&mut self) {
         self.token_draft = TokenDraft::blank(&self.shared_config_draft);
-        self.message = Some("new token draft ready".to_string());
+        self.token_dirty = false;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
+        self.set_success_message("new token draft ready");
     }
 
     fn new_network_draft(&mut self) {
         self.network_draft = NetworkDraft::blank();
-        self.message = Some("new network draft ready".to_string());
+        self.network_dirty = false;
+        self.clear_pending_discard();
+        self.clear_pending_delete();
+        self.set_success_message("new network draft ready");
+    }
+
+    fn request_delete_destination_override(&mut self) {
+        if self.token_draft.destination_overrides.is_empty() {
+            self.delete_destination_override();
+            return;
+        }
+        if self.confirm_delete(
+            PendingDeleteAction::DeleteDestinationOverride,
+            "the selected destination override",
+        ) {
+            self.delete_destination_override();
+        }
+    }
+
+    fn request_delete_manual_approval(&mut self) {
+        if self.token_draft.manual_approvals.is_empty() {
+            self.delete_manual_approval();
+            return;
+        }
+        if self.confirm_delete(
+            PendingDeleteAction::DeleteManualApproval,
+            "the selected manual approval policy",
+        ) {
+            self.delete_manual_approval();
+        }
+    }
+
+    fn request_delete_token(&mut self) -> Result<()> {
+        let has_candidate = self.token_draft.source_key.is_some()
+            || !self.token_draft.key.trim().is_empty();
+        if !has_candidate {
+            return self.delete_token_config();
+        }
+        if self.confirm_delete(PendingDeleteAction::DeleteToken, "the selected token") {
+            return self.delete_token_config();
+        }
+        Ok(())
+    }
+
+    fn request_delete_network(&mut self) -> Result<()> {
+        let has_candidate = self.network_draft.source_key.is_some()
+            || !self.network_draft.key.trim().is_empty();
+        if !has_candidate {
+            return self.delete_network_config();
+        }
+        if self.confirm_delete(PendingDeleteAction::DeleteNetwork, "the selected network") {
+            return self.delete_network_config();
+        }
+        Ok(())
     }
 
     fn step_selected(&mut self, direction: i8) {
         match self.selected_field() {
-            Field::SelectedToken => self.cycle_saved_token(direction),
+            Field::SelectedToken => self.request_cycle_saved_token(direction),
             Field::NetworkMembership => self.cycle_available_network(direction),
             Field::EditingNetwork => self.cycle_selected_network_mapping(direction),
             Field::NetworkIsNative => {
@@ -987,6 +1223,7 @@ impl AppState {
                     if network.is_native {
                         network.address.clear();
                     }
+                    self.mark_token_dirty();
                 }
             }
             Field::SelectedDestinationOverride => {
@@ -1003,17 +1240,24 @@ impl AppState {
                     direction,
                 );
             }
-            Field::SelectedNetwork => self.cycle_saved_network(direction),
+            Field::SelectedNetwork => self.request_cycle_saved_network(direction),
             Field::ShowAdvanced => {
                 self.show_advanced = !self.show_advanced;
             }
             Field::ChainConfigUseAsActive => {
                 self.network_draft.use_as_active = !self.network_draft.use_as_active;
+                self.mark_network_dirty();
             }
             _ => {}
         }
     }
 
+    fn request_cycle_saved_token(&mut self, direction: i8) {
+        if self.confirm_discard(PendingDiscardAction::CycleSavedToken(direction)) {
+            self.cycle_saved_token(direction);
+        }
+    }
+
     fn cycle_saved_token(&mut self, direction: i8) {
         let saved = sorted_token_keys(&self.shared_config_draft);
         if saved.is_empty() {
@@ -1037,7 +1281,13 @@ impl AppState {
         } else {
             let key = entries[index].clone();
             self.load_token_draft(Some(&key));
-            self.message = None;
+            self.clear_message();
+        }
+    }
+
+    fn request_cycle_saved_network(&mut self, direction: i8) {
+        if self.confirm_discard(PendingDiscardAction::CycleSavedNetwork(direction)) {
+            self.cycle_saved_network(direction);
         }
     }
 
@@ -1064,7 +1314,7 @@ impl AppState {
         } else {
             let key = entries[index].clone();
             self.load_network_draft(Some(&key));
-            self.message = None;
+            self.clear_message();
         }
     }
 
@@ -1186,7 +1436,12 @@ impl AppState {
         match key.code {
             KeyCode::Backspace => {
                 target.pop();
-                self.message = None;
+                if field_uses_network_draft(selected_field) {
+                    self.mark_network_dirty();
+                } else {
+                    self.mark_token_dirty();
+                }
+                self.clear_message();
             }
             KeyCode::Char(ch)
                 if !key.modifiers.contains(KeyModifiers::CONTROL)
@@ -1194,9 +1449,16 @@ impl AppState {
             {
                 if is_allowed_input_char(selected_field, ch) {
                     target.push(ch);
-                    self.message = None;
+                    if field_uses_network_draft(selected_field) {
+                        self.mark_network_dirty();
+                    } else {
+                        self.mark_token_dirty();
+                    }
+                    self.clear_message();
                 } else {
-                    self.message = Some(format!("invalid character '{ch}' for the selected field"));
+                    self.set_error_message(format!(
+                        "invalid character '{ch}' for the selected field"
+                    ));
                 }
             }
             _ => {}
@@ -1215,19 +1477,21 @@ impl AppState {
             .destination_overrides
             .len()
             .saturating_sub(1);
-        self.message = Some("destination override added".to_string());
+        self.mark_token_dirty();
+        self.set_success_message("destination override added");
     }
 
     fn delete_destination_override(&mut self) {
         if self.token_draft.destination_overrides.is_empty() {
-            self.message = Some("no destination override is selected".to_string());
+            self.set_info_message("no destination override is selected");
             return;
         }
         self.token_draft
             .destination_overrides
             .remove(self.token_draft.selected_override);
         self.token_draft.normalize();
-        self.message = Some("destination override removed".to_string());
+        self.mark_token_dirty();
+        self.set_success_message("destination override removed");
     }
 
     fn add_manual_approval(&mut self) {
@@ -1239,19 +1503,21 @@ impl AppState {
         });
         self.token_draft.selected_manual_approval =
             self.token_draft.manual_approvals.len().saturating_sub(1);
-        self.message = Some("manual approval policy added".to_string());
+        self.mark_token_dirty();
+        self.set_success_message("manual approval policy added");
     }
 
     fn delete_manual_approval(&mut self) {
         if self.token_draft.manual_approvals.is_empty() {
-            self.message = Some("no manual approval policy is selected".to_string());
+            self.set_info_message("no manual approval policy is selected");
             return;
         }
         self.token_draft
             .manual_approvals
             .remove(self.token_draft.selected_manual_approval);
         self.token_draft.normalize();
-        self.message = Some("manual approval policy removed".to_string());
+        self.mark_token_dirty();
+        self.set_success_message("manual approval policy removed");
     }
 
     fn refresh_token_metadata(&mut self) -> Result<()> {
@@ -1292,7 +1558,8 @@ impl AppState {
             network.chain_id = metadata.chain_id.to_string();
             network.decimals = metadata.decimals.to_string();
         }
-        self.message = Some("token metadata refreshed from rpc".to_string());
+        self.mark_token_dirty();
+        self.set_success_message("token metadata refreshed from rpc");
         Ok(())
     }
 
@@ -1335,7 +1602,7 @@ impl AppState {
         self.shared_config_draft = candidate;
         self.persist_shared_config()?;
         self.load_token_draft(Some(&token_key));
-        self.message = Some(format!("saved token '{}'", token_key));
+        self.set_success_message(format!("saved token '{}'", token_key));
         Ok(())
     }
 
@@ -1354,7 +1621,7 @@ impl AppState {
         }
         self.persist_shared_config()?;
         self.load_token_draft(None);
-        self.message = Some(format!("deleted token '{}'", key));
+        self.set_success_message(format!("deleted token '{}'", key));
         Ok(())
     }
 
@@ -1389,7 +1656,7 @@ impl AppState {
         self.load_network_draft(Some(&chain_key));
         let token_source_key = self.token_draft.source_key.clone();
         self.load_token_draft(token_source_key.as_deref());
-        self.message = Some(format!("saved network '{}'", chain_key));
+        self.set_success_message(format!("saved network '{}'", chain_key));
         Ok(())
     }
 
@@ -1425,7 +1692,7 @@ impl AppState {
         }
         self.persist_shared_config()?;
         self.load_network_draft(None);
-        self.message = Some(format!("deleted network '{}'", key));
+        self.set_success_message(format!("deleted network '{}'", key));
         Ok(())
     }
 
@@ -1539,10 +1806,8 @@ impl ResolvedLimitFields {
 
 enum LoopAction {
     Continue,
-    ApplyAndContinue {
-        params: Box<BootstrapParams>,
-        success_message: String,
-    },
+    RefreshTokenMetadata,
+    SaveTokenAndApply,
     ApplyAndExit(Box<BootstrapParams>),
     Cancel,
 }
@@ -1550,7 +1815,7 @@ enum LoopAction {
 pub(crate) fn run_bootstrap_tui<T>(
     shared_config: &WlfiConfig,
     print_agent_auth_token: bool,
-    on_apply: impl FnMut(BootstrapParams) -> Result<T>,
+    on_apply: impl FnMut(BootstrapParams, &mut dyn FnMut(&str) -> Result<()>) -> Result<T>,
 ) -> Result<Option<T>> {
     enable_raw_mode().context("failed to enable raw mode")?;
     let mut stdout = io::stdout();
@@ -1580,17 +1845,70 @@ fn cleanup_terminal(terminal: &mut Terminal<CrosstermBackend<io::Stdout>>) -> Re
     Ok(())
 }
 
-fn run_event_loop<T>(
-    terminal: &mut Terminal<CrosstermBackend<io::Stdout>>,
+fn render_frame<B: Backend>(terminal: &mut Terminal<B>, app: &AppState) -> Result<()> {
+    terminal
+        .draw(|frame| draw_ui(frame, app))
+        .context("failed to render tui frame")?;
+    Ok(())
+}
+
+fn refresh_metadata_with_progress<B: Backend>(
+    terminal: &mut Terminal<B>,
+    app: &mut AppState,
+) -> Result<()> {
+    app.set_info_message("refreshing token metadata from rpc");
+    render_frame(terminal, app)?;
+    app.refresh_token_metadata()
+}
+
+fn apply_with_progress<T, B: Backend>(
+    terminal: &mut Terminal<B>,
+    app: &mut AppState,
+    params: BootstrapParams,
+    on_apply: &mut impl FnMut(BootstrapParams, &mut dyn FnMut(&str) -> Result<()>) -> Result<T>,
+) -> Result<T> {
+    app.set_info_message("applying wallet changes");
+    render_frame(terminal, app)?;
+
+    let mut on_status = |message: &str| -> Result<()> {
+        app.set_info_message(message);
+        render_frame(terminal, app)
+    };
+
+    on_apply(params, &mut on_status)
+}
+
+fn run_save_token_and_apply<T, B: Backend>(
+    terminal: &mut Terminal<B>,
+    app: &mut AppState,
+    on_apply: &mut impl FnMut(BootstrapParams, &mut dyn FnMut(&str) -> Result<()>) -> Result<T>,
+) -> Result<(T, String)> {
+    if app.selected_token_requires_metadata_refresh() {
+        refresh_metadata_with_progress(terminal, app)?;
+    }
+
+    app.save_token_config()?;
+    let success_message = app
+        .message
+        .clone()
+        .unwrap_or_else(|| "saved token".to_string());
+
+    let params = app.build_params().map_err(|err| {
+        anyhow!("{success_message} but failed to apply to wallet: {err}")
+    })?;
+    let output = apply_with_progress(terminal, app, params, on_apply)?;
+    Ok((output, format!("{success_message} and applied to wallet")))
+}
+
+fn run_event_loop<T, B: Backend>(
+    terminal: &mut Terminal<B>,
     mut app: AppState,
-    mut on_apply: impl FnMut(BootstrapParams) -> Result<T>,
+    mut on_apply: impl FnMut(BootstrapParams, &mut dyn FnMut(&str) -> Result<()>) -> Result<T>,
 ) -> Result<Option<T>> {
     let mut last_output = None;
     loop {
         app.normalize_selection();
-        terminal
-            .draw(|frame| draw_ui(frame, &app))
-            .context("failed to render tui frame")?;
+        render_frame(terminal, &app)?;
 
         if !event::poll(Duration::from_millis(250)).context("failed to poll terminal events")? {
             continue;
@@ -1605,22 +1923,33 @@ fn run_event_loop<T>(
 
         match handle_key_event(&mut app, key)? {
             LoopAction::Continue => {}
-            LoopAction::ApplyAndContinue {
-                params,
-                success_message,
-            } => match on_apply(*params) {
-                Ok(output) => {
+            LoopAction::RefreshTokenMetadata => {
+                if let Err(err) = refresh_metadata_with_progress(terminal, &mut app) {
+                    app.set_error_message(err.to_string());
+                }
+            }
+            LoopAction::SaveTokenAndApply => match run_save_token_and_apply(
+                terminal,
+                &mut app,
+                &mut on_apply,
+            ) {
+                Ok((output, success_message)) => {
                     last_output = Some(output);
-                    app.message = Some(success_message);
+                    app.set_success_message(success_message);
                 }
                 Err(err) => {
-                    app.message = Some(err.to_string());
+                    app.set_error_message(err.to_string());
                 }
             },
-            LoopAction::ApplyAndExit(params) => match on_apply(*params) {
+            LoopAction::ApplyAndExit(params) => match apply_with_progress(
+                terminal,
+                &mut app,
+                *params,
+                &mut on_apply,
+            ) {
                 Ok(output) => return Ok(Some(output)),
                 Err(err) => {
-                    app.message = Some(err.to_string());
+                    app.set_error_message(err.to_string());
                 }
             },
             LoopAction::Cancel => return Ok(last_output),
@@ -1633,24 +1962,21 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
         match app.build_params() {
             Ok(params) => return Ok(LoopAction::ApplyAndExit(Box::new(params))),
             Err(err) => {
-                app.message = Some(err.to_string());
+                app.set_error_message(err.to_string());
                 return Ok(LoopAction::Continue);
             }
         }
     }
 
     if key.code == KeyCode::Char('r') && key.modifiers.contains(KeyModifiers::CONTROL) {
-        app.reload_current_view();
-        app.message = Some("reloaded saved data into the current draft".to_string());
+        if app.request_reload_current_view() {
+            app.set_success_message("reloaded saved data into the current draft");
+        }
         return Ok(LoopAction::Continue);
     }
 
     if key.code == KeyCode::Char('n') && key.modifiers.contains(KeyModifiers::CONTROL) {
-        match app.view {
-            View::Tokens => app.new_token_draft(),
-            View::Networks => app.new_network_draft(),
-            View::Bootstrap => {}
-        }
+        app.request_new_current_draft();
         return Ok(LoopAction::Continue);
     }
 
@@ -1676,20 +2002,20 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
         KeyCode::Char('q') if key.modifiers.is_empty() => return Ok(LoopAction::Cancel),
         KeyCode::Down | KeyCode::Char('j') => {
             app.select_next();
-            app.message = None;
+            app.clear_message();
             return Ok(LoopAction::Continue);
         }
         KeyCode::Up | KeyCode::Char('k') => {
             app.select_prev();
-            app.message = None;
+            app.clear_message();
             return Ok(LoopAction::Continue);
         }
         KeyCode::BackTab => {
-            app.previous_view();
+            app.request_previous_view();
             return Ok(LoopAction::Continue);
         }
         KeyCode::Tab => {
-            app.next_view();
+            app.request_next_view();
             return Ok(LoopAction::Continue);
         }
         KeyCode::Home => {
@@ -1701,13 +2027,13 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
             return Ok(LoopAction::Continue);
         }
         KeyCode::Left | KeyCode::Char('h') => {
+            app.clear_message();
             app.step_selected(-1);
-            app.message = None;
             return Ok(LoopAction::Continue);
         }
         KeyCode::Right | KeyCode::Char('l') => {
+            app.clear_message();
             app.step_selected(1);
-            app.message = None;
             return Ok(LoopAction::Continue);
         }
         KeyCode::Char(' ') => match app.selected_field() {
@@ -1716,9 +2042,10 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
                     .token_draft
                     .toggle_network_membership(&app.shared_config_draft)
                 {
-                    app.message = Some(err.to_string());
+                    app.set_error_message(err.to_string());
                 } else {
-                    app.message = Some("updated token network selection".to_string());
+                    app.mark_token_dirty();
+                    app.set_success_message("updated token network selection");
                 }
                 return Ok(LoopAction::Continue);
             }
@@ -1736,18 +2063,18 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
             _ => {}
         },
         KeyCode::Char('[') if key.modifiers.is_empty() => {
-            app.previous_view();
+            app.request_previous_view();
             return Ok(LoopAction::Continue);
         }
         KeyCode::Char(']') if key.modifiers.is_empty() => {
-            app.next_view();
+            app.request_next_view();
             return Ok(LoopAction::Continue);
         }
         KeyCode::Enter => match app.selected_field() {
             Field::Execute => match app.build_params() {
                 Ok(params) => return Ok(LoopAction::ApplyAndExit(Box::new(params))),
                 Err(err) => {
-                    app.message = Some(err.to_string());
+                    app.set_error_message(err.to_string());
                     return Ok(LoopAction::Continue);
                 }
             },
@@ -1756,24 +2083,22 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
                     .token_draft
                     .toggle_network_membership(&app.shared_config_draft)
                 {
-                    app.message = Some(err.to_string());
+                    app.set_error_message(err.to_string());
                 } else {
-                    app.message = Some("updated token network selection".to_string());
+                    app.mark_token_dirty();
+                    app.set_success_message("updated token network selection");
                 }
                 return Ok(LoopAction::Continue);
             }
             Field::RefreshTokenMetadata => {
-                if let Err(err) = app.refresh_token_metadata() {
-                    app.message = Some(err.to_string());
-                }
-                return Ok(LoopAction::Continue);
+                return Ok(LoopAction::RefreshTokenMetadata);
             }
             Field::DestinationOverrides => {
                 app.add_destination_override();
                 return Ok(LoopAction::Continue);
             }
             Field::DeleteDestinationOverride => {
-                app.delete_destination_override();
+                app.request_delete_destination_override();
                 return Ok(LoopAction::Continue);
             }
             Field::ManualApprovals => {
@@ -1781,54 +2106,27 @@ fn handle_key_event(app: &mut AppState, key: KeyEvent) -> Result<LoopAction> {
                 return Ok(LoopAction::Continue);
             }
             Field::DeleteManualApproval => {
-                app.delete_manual_approval();
+                app.request_delete_manual_approval();
                 return Ok(LoopAction::Continue);
             }
             Field::SaveToken => {
-                if app.selected_token_requires_metadata_refresh() {
-                    if let Err(err) = app.refresh_token_metadata() {
-                        app.message = Some(err.to_string());
-                        return Ok(LoopAction::Continue);
-                    }
-                }
-                if let Err(err) = app.save_token_config() {
-                    app.message = Some(err.to_string());
-                    return Ok(LoopAction::Continue);
-                }
-                let success_message = app
-                    .message
-                    .clone()
-                    .unwrap_or_else(|| "saved token".to_string());
-                match app.build_params() {
-                    Ok(params) => {
-                        return Ok(LoopAction::ApplyAndContinue {
-                            params: Box::new(params),
-                            success_message: format!("{success_message} and applied to wallet"),
-                        });
-                    }
-                    Err(err) => {
-                        app.message = Some(format!(
-                            "{success_message} but failed to apply to wallet: {err}"
-                        ));
-                        return Ok(LoopAction::Continue);
-                    }
-                }
+                return Ok(LoopAction::SaveTokenAndApply);
             }
             Field::DeleteToken => {
-                if let Err(err) = app.delete_token_config() {
-                    app.message = Some(err.to_string());
+                if let Err(err) = app.request_delete_token() {
+                    app.set_error_message(err.to_string());
                 }
                 return Ok(LoopAction::Continue);
             }
             Field::SaveNetwork => {
                 if let Err(err) = app.save_network_config() {
-                    app.message = Some(err.to_string());
+                    app.set_error_message(err.to_string());
                 }
                 return Ok(LoopAction::Continue);
             }
             Field::DeleteNetwork => {
-                if let Err(err) = app.delete_network_config() {
-                    app.message = Some(err.to_string());
+                if let Err(err) = app.request_delete_network() {
+                    app.set_error_message(err.to_string());
                 }
                 return Ok(LoopAction::Continue);
             }
@@ -1942,11 +2240,7 @@ fn draw_ui(frame: &mut ratatui::Frame<'_>, app: &AppState) {
     let default_message =
         "Ready. Start with tokens; saved tokens expand across all selected networks at bootstrap.";
     let message = app.message.as_deref().unwrap_or(default_message);
-    let style = if app.message.is_some() {
-        Style::default().fg(Color::Red)
-    } else {
-        Style::default().fg(Color::Green)
-    };
+    let style = status_message_style(app);
     frame.render_widget(
         Paragraph::new(Line::from(Span::styled(message, style)))
             .block(Block::default().borders(Borders::ALL).title("Status")),
@@ -1954,6 +2248,14 @@ fn draw_ui(frame: &mut ratatui::Frame<'_>, app: &AppState) {
     );
 }
 
+fn status_message_style(app: &AppState) -> Style {
+    if app.message.is_some() {
+        app.message_level.style()
+    } else {
+        Style::default().fg(Color::Green)
+    }
+}
+
 fn build_help_lines(view: View) -> Vec<Line<'static>> {
     let mut lines = vec![
         Line::from("Views: Tab/Shift+Tab or ]/["),
@@ -2311,7 +2613,7 @@ fn field_value(app: &AppState, field: Field) -> String {
             .get(app.token_draft.selected_override)
             .map(|item| display_unlimited_if_empty(&item.limits.per_tx_max_calldata_bytes))
             .unwrap_or_else(|| "n/a".to_string()),
-        Field::DeleteDestinationOverride => "press Enter".to_string(),
+        Field::DeleteDestinationOverride => "press Enter; repeat to confirm".to_string(),
         Field::ManualApprovals => format!(
             "{} saved draft(s) — press Enter",
             app.token_draft.manual_approvals.len()
@@ -2346,9 +2648,9 @@ fn field_value(app: &AppState, field: Field) -> String {
             .get(app.token_draft.selected_manual_approval)
             .map(|item| blank_if_empty(&item.priority))
             .unwrap_or_else(|| "n/a".to_string()),
-        Field::DeleteManualApproval => "press Enter".to_string(),
+        Field::DeleteManualApproval => "press Enter; repeat to confirm".to_string(),
         Field::SaveToken => "press Enter".to_string(),
-        Field::DeleteToken => "press Enter".to_string(),
+        Field::DeleteToken => "press Enter; repeat to confirm".to_string(),
         Field::SelectedNetwork => app
             .network_draft
             .source_key
@@ -2360,7 +2662,7 @@ fn field_value(app: &AppState, field: Field) -> String {
         Field::ChainConfigRpcUrl => blank_if_empty(&app.network_draft.rpc_url),
         Field::ChainConfigUseAsActive => bool_label(app.network_draft.use_as_active).to_string(),
         Field::SaveNetwork => "press Enter".to_string(),
-        Field::DeleteNetwork => "press Enter".to_string(),
+        Field::DeleteNetwork => "press Enter; repeat to confirm".to_string(),
         Field::Execute => "press Enter".to_string(),
     }
 }
@@ -2381,6 +2683,16 @@ fn display_unlimited_if_empty(value: &str) -> String {
     }
 }
 
+fn field_uses_network_draft(field: Field) -> bool {
+    matches!(
+        field,
+        Field::ChainConfigKey
+            | Field::ChainConfigId
+            | Field::ChainConfigName
+            | Field::ChainConfigRpcUrl
+    )
+}
+
 fn render_network_membership_value(token_draft: &TokenDraft, config: &WlfiConfig) -> String {
     let available = sorted_chain_keys(config);
     if available.is_empty() {
@@ -3089,13 +3401,14 @@ fn validate_optional_overlay_limit(
 #[cfg(test)]
 mod tests {
     use super::{
-        build_bootstrap_panel_lines, build_token_panel_lines, handle_key_event,
-        resolve_all_token_manual_approval_policies, resolve_all_token_policies, AppState,
-        ChainProfile, Field, KeyCode, KeyEvent, KeyModifiers, LoopAction, TokenChainProfile,
-        TokenDestinationOverrideProfile, TokenManualApprovalProfile, TokenPolicyProfile,
-        TokenProfile, View, WlfiConfig,
+        apply_with_progress, build_bootstrap_panel_lines, build_token_panel_lines,
+        handle_key_event, resolve_all_token_manual_approval_policies, resolve_all_token_policies,
+        status_message_style, AppState, ChainProfile, Field, KeyCode, KeyEvent, KeyModifiers,
+        LoopAction, MessageLevel, TokenChainProfile, TokenDestinationOverrideProfile,
+        TokenManualApprovalProfile, TokenPolicyProfile, TokenProfile, View, WlfiConfig,
     };
     use crate::shared_config::WalletProfile;
+    use ratatui::{backend::TestBackend, style::Color, Terminal};
     use std::collections::BTreeMap;
     use std::fs;
     use uuid::Uuid;
@@ -3334,7 +3647,7 @@ mod tests {
     }
 
     #[test]
-    fn save_token_returns_live_apply_action_when_metadata_is_complete() {
+    fn save_token_defers_apply_to_event_loop_when_metadata_is_complete() {
         let config = sample_config();
         let mut app = AppState::from_shared_config(&config, false);
         let config_root =
@@ -3350,21 +3663,65 @@ mod tests {
         let action = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
             .expect("handle");
 
-        match action {
-            LoopAction::ApplyAndContinue {
-                params,
-                success_message,
-            } => {
-                assert_eq!(params.token_policies.len(), 2);
-                assert!(success_message.contains("saved token 'usdc'"));
-                assert!(success_message.contains("applied to wallet"));
-            }
-            _ => panic!("expected save token to apply and continue"),
-        }
+        assert!(matches!(action, LoopAction::SaveTokenAndApply));
 
         fs::remove_dir_all(config_root).expect("cleanup temp config root");
     }
 
+    #[test]
+    fn refresh_metadata_action_is_deferred_to_event_loop_for_progress_rendering() {
+        let config = sample_config();
+        let mut app = AppState::from_shared_config(&config, false);
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::RefreshTokenMetadata)
+            .expect("refresh metadata field");
+
+        let action = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("handle");
+
+        assert!(matches!(action, LoopAction::RefreshTokenMetadata));
+    }
+
+    #[test]
+    fn apply_with_progress_surfaces_bootstrap_status_messages() {
+        let mut terminal = Terminal::new(TestBackend::new(120, 40)).expect("terminal");
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        let params = app.build_params().expect("params");
+
+        let output = apply_with_progress(&mut terminal, &mut app, params, &mut |params, on_status| {
+            assert_eq!(params.token_policies.len(), 2);
+            on_status("initializing daemon")?;
+            on_status("registering spending policies")?;
+            Ok("ok".to_string())
+        })
+        .expect("apply succeeds");
+
+        assert_eq!(output, "ok");
+        assert_eq!(
+            app.message.as_deref(),
+            Some("registering spending policies")
+        );
+    }
+
+    #[test]
+    fn status_message_style_uses_message_severity() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+
+        app.set_info_message("loading");
+        assert_eq!(app.message_level, MessageLevel::Info);
+        assert_eq!(status_message_style(&app).fg, Some(Color::Cyan));
+
+        app.set_success_message("saved");
+        assert_eq!(app.message_level, MessageLevel::Success);
+        assert_eq!(status_message_style(&app).fg, Some(Color::Green));
+
+        app.set_error_message("failed");
+        assert_eq!(app.message_level, MessageLevel::Error);
+        assert_eq!(status_message_style(&app).fg, Some(Color::Red));
+    }
+
     #[test]
     fn advanced_fields_are_hidden_by_default() {
         let app = AppState::from_shared_config(&sample_config(), false);
@@ -3407,4 +3764,152 @@ mod tests {
         let app = AppState::from_shared_config(&WlfiConfig::default(), false);
         assert_eq!(super::field_value(&app, Field::NetworkAddress), "native");
     }
+
+    #[test]
+    fn tab_requires_confirmation_before_discarding_dirty_token_draft() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::TokenKey)
+            .expect("token key field");
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE))
+            .expect("edit token key");
+        assert!(app.token_dirty);
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE))
+            .expect("first tab");
+        assert_eq!(app.view, View::Tokens);
+        assert!(app
+            .message
+            .as_deref()
+            .expect("discard warning")
+            .contains("unsaved changes in the token draft"));
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE))
+            .expect("second tab");
+        assert_eq!(app.view, View::Networks);
+    }
+
+    #[test]
+    fn reload_requires_confirmation_before_discarding_dirty_network_draft() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.view = View::Networks;
+        let original_name = app.network_draft.name.clone();
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::ChainConfigName)
+            .expect("chain config name field");
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE))
+            .expect("edit network name");
+        assert!(app.network_dirty);
+        assert!(app.network_draft.name.ends_with('x'));
+
+        let _ = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL),
+        )
+        .expect("first reload");
+        assert!(app.network_draft.name.ends_with('x'));
+        assert!(app
+            .message
+            .as_deref()
+            .expect("discard warning")
+            .contains("unsaved changes in the network draft"));
+
+        let _ = handle_key_event(
+            &mut app,
+            KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL),
+        )
+        .expect("second reload");
+        assert_eq!(app.network_draft.name, original_name);
+        assert!(!app.network_dirty);
+    }
+
+    #[test]
+    fn cycling_saved_token_requires_confirmation_when_current_draft_is_dirty() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::TokenKey)
+            .expect("token key field");
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE))
+            .expect("edit token key");
+
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::SelectedToken)
+            .expect("selected token field");
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Right, KeyModifiers::NONE))
+            .expect("first cycle");
+        assert_eq!(app.token_draft.source_key.as_deref(), Some("usdc"));
+        assert!(app
+            .message
+            .as_deref()
+            .expect("discard warning")
+            .contains("unsaved changes in the token draft"));
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Right, KeyModifiers::NONE))
+            .expect("second cycle");
+        assert!(app.token_draft.source_key.is_none());
+        assert!(!app.token_dirty);
+    }
+
+    #[test]
+    fn delete_manual_approval_requires_confirmation() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::DeleteManualApproval)
+            .expect("delete manual approval field");
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("first delete");
+        assert_eq!(app.token_draft.manual_approvals.len(), 1);
+        assert!(app
+            .message
+            .as_deref()
+            .expect("confirmation")
+            .contains("repeat the action to confirm deleting the selected manual approval policy"));
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("second delete");
+        assert!(app.token_draft.manual_approvals.is_empty());
+    }
+
+    #[test]
+    fn delete_token_requires_confirmation() {
+        let mut app = AppState::from_shared_config(&sample_config(), false);
+        let config_root =
+            std::env::temp_dir().join(format!("wlfi-agent-admin-delete-token-{}", Uuid::new_v4()));
+        fs::create_dir_all(&config_root).expect("create temp config root");
+        app.config_path = config_root.join("config.json");
+        app.selected = app
+            .visible_fields()
+            .iter()
+            .position(|field| *field == Field::DeleteToken)
+            .expect("delete token field");
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("first delete");
+        assert!(app.shared_config_draft.tokens.contains_key("usdc"));
+        assert!(app
+            .message
+            .as_deref()
+            .expect("confirmation")
+            .contains("repeat the action to confirm deleting the selected token"));
+
+        let _ = handle_key_event(&mut app, KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE))
+            .expect("second delete");
+        assert!(!app.shared_config_draft.tokens.contains_key("usdc"));
+
+        fs::remove_dir_all(config_root).expect("cleanup temp config root");
+    }
 }