added a progress layer when the UI is loading. this enhances the UX

Author: rp-bg

src/main.rs

@@ -232,30 +232,57 @@ async fn main() -> Result<()> {
         None => {
             // Launch TUI
             let password = prompt_password("Enter master password")?;
+            
+            let mut terminal = match tui::init_terminal() {
+                Ok(t) => t,
+                Err(e) => {
+                    eprintln!("Failed to initialize terminal: {}", e);
+                    std::process::exit(1);
+                }
+            };
+            
+            let _ = tui::draw_loading(&mut terminal, "Authenticating with GitHub...");
+
             let repo_name = match config::Config::get_repo_name_with_profile(
                 effective_profile.as_deref(),
                 &password,
             ) {
                 Ok(name) => name,
                 Err(e) => {
+                    let _ = tui::restore_terminal(terminal);
                     eprintln!("Configuration missing or master password incorrect: {}", e);
                     std::process::exit(1);
                 }
             };
+            
             let storage = match storage::Storage::new_with_profile(
                 effective_profile.as_deref(),
                 &repo_name,
                 &password,
             ).await {
                 Ok(s) => s,
                 Err(e) => {
+                    let _ = tui::restore_terminal(terminal);
                     eprintln!("Failed to initialize storage: {}", e);
                     std::process::exit(1);
                 }
             };
-            let master_key = get_or_init_master_key(&storage, &password).await?;
+            
+            let _ = tui::draw_loading(&mut terminal, "Fetching and verifying master key...");
+            let master_key = match get_or_init_master_key(&storage, &password).await {
+                Ok(k) => k,
+                Err(e) => {
+                    let _ = tui::restore_terminal(terminal);
+                    eprintln!("Failed to get master key: {}", e);
+                    std::process::exit(1);
+                }
+            };
 
-            tui::run(storage, master_key).await?;
+            let _ = tui::draw_loading(&mut terminal, "Downloading keys from GitHub...");
+            if let Err(e) = tui::run(terminal, storage, master_key).await {
+                eprintln!("TUI error: {}", e);
+                std::process::exit(1);
+            }
             return Ok(());
         }
     };

src/tui/mod.rs

@@ -16,26 +16,49 @@ pub mod ui;
 use app::App;
 use crate::storage::Storage;
 
-pub async fn run(storage: Storage, master_key: String) -> Result<()> {
-    // setup terminal
+pub type TuiTerminal = Terminal<CrosstermBackend<std::io::Stdout>>;
+
+pub fn init_terminal() -> Result<TuiTerminal> {
     enable_raw_mode()?;
     let mut stdout = io::stdout();
     execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
     let backend = CrosstermBackend::new(stdout);
-    let mut terminal = Terminal::new(backend)?;
-
-    // create app and run it
-    let mut app = App::new(storage, master_key).await?;
-    let res = run_app(&mut terminal, &mut app).await;
+    Terminal::new(backend).map_err(Into::into)
+}
 
-    // restore terminal
+pub fn restore_terminal(mut terminal: TuiTerminal) -> Result<()> {
     disable_raw_mode()?;
     execute!(
         terminal.backend_mut(),
         LeaveAlternateScreen,
         DisableMouseCapture
     )?;
     terminal.show_cursor()?;
+    Ok(())
+}
+
+pub fn draw_loading(terminal: &mut TuiTerminal, msg: &str) -> Result<()> {
+    terminal.draw(|f| {
+        use ratatui::{
+            style::{Color, Style},
+            widgets::{Block, Borders, Paragraph, Clear},
+        };
+        let area = ui::centered_rect(50, 20, f.area());
+        f.render_widget(Clear, area);
+        let block = Block::default().title("Loading").borders(Borders::ALL);
+        let paragraph = Paragraph::new(msg).block(block).style(Style::default().fg(Color::Cyan));
+        f.render_widget(paragraph, area);
+    })?;
+    Ok(())
+}
+
+pub async fn run(mut terminal: TuiTerminal, storage: Storage, master_key: String) -> Result<()> {
+    // create app and run it
+    let mut app = App::new(storage, master_key).await?;
+    let res = run_app(&mut terminal, &mut app).await;
+
+    // restore terminal
+    restore_terminal(terminal)?;
 
     if let Err(err) = res {
         println!("{:?}", err);

src/tui/ui.rs

@@ -158,7 +158,7 @@ pub fn draw(f: &mut Frame, app: &mut App) {
     }
 }
 
-fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
+pub fn centered_rect(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
     let popup_layout = Layout::default()
         .direction(Direction::Vertical)
         .constraints(