feat: improve OAuth flow with browser failure handling and UI cleanup

   - Refactor OAuth URL sending into perform_oauth_flow for cleaner architecture
   - Add browser failure detection and TUI notifications
   - Remove emojis from auth popup, improve URL display alignment
   - Add detailed logging for Drive folder operations
   - Update demo screenshot in README

Author: adolfousier

.gitignore

@@ -17,6 +17,7 @@ IMPLEMENTATION_PLAN.md
 /client/dist
 /src/data/logs/
 commands.md
+src/plans
 
 init.sql/
 

CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.23] - 2025-12-18
+
+### Changed
+- **OAuth Flow Refactoring**: Consolidated auth URL sending into `perform_oauth_flow` function for cleaner code architecture
+- **Browser Failure Handling**: OAuth flow now detects when browser fails to open and sends notification to TUI
+- **Auth Popup UI**: Removed emojis from authentication popup for cleaner display, changed text alignment to left for better URL readability
+- **Demo Screenshot**: Updated README to use new static demo.png instead of animated GIF
+
+### Added
+- **Browser Failure Notifications**: New `__GMAIL_BROWSER_FAILED__` and `__DRIVE_BROWSER_FAILED__` message handlers in TUI to inform users when automatic browser opening fails
+- **Enhanced Drive Logging**: Added detailed logging for folder search and creation operations in drive/folder.rs
+
+### Fixed
+- **Auth URL Display**: URLs now display with left alignment and no trimming for easier copying
+- **OAuth URL Timing**: Auth URLs are now sent to TUI immediately from the OAuth flow rather than after authorization completes
+
+### Technical Improvements
+- **Code Cleanup**: Refactored `authorize_gmail` and `authorize_drive` to accept optional channel parameter for URL sending
+- **Unified OAuth Handling**: Both Gmail and Drive auth now use consistent pattern with service-specific prefixes (GMAIL_, DRIVE_)
+
 ## [0.1.22] - 2025-11-07
 
 ### Changed

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "invoice-pilot"
-version = "0.1.22"
+version = "0.1.23"
 edition = "2024"
 
 [dependencies]

README.md

@@ -12,7 +12,7 @@ Invoice Pilot is a fully automated invoice and bank statement management tool bu
 
 ## Demo
 
-![Demo](src/screenshots/invoice-pilot-demo.gif)
+![Demo](src/screenshots/demo.png)
 
 ## Table of Contents
 

src/auth/drive_auth.rs

@@ -47,7 +47,7 @@ pub async fn get_drive_token(client_id: String, client_secret: String) -> Result
     }
 
     // Need new authorization
-    let (token, _) = authorize_drive(client_id, client_secret).await?;
+    let (token, _) = authorize_drive(client_id, client_secret, None).await?;
     Ok(token)
 }
 
@@ -92,19 +92,18 @@ pub async fn get_drive_token_with_url(client_id: String, client_secret: String,
         }
     }
 
-    // Need new authorization - send URL first, then proceed
-    let (token, auth_url) = authorize_drive(client_id, client_secret).await?;
-    // Send the auth URL to the TUI
-    let _ = tx.send(format!("__DRIVE_AUTH_URL__:{}", auth_url));
+    // Need new authorization - URL will be sent via channel from perform_oauth_flow
+    let (token, _auth_url) = authorize_drive(client_id, client_secret, Some(tx)).await?;
     Ok(token)
 }
 
 /// Perform full Drive authorization flow
-async fn authorize_drive(client_id: String, client_secret: String) -> Result<(String, String)> {
+async fn authorize_drive(client_id: String, client_secret: String, tx: Option<tokio::sync::mpsc::UnboundedSender<String>>) -> Result<(String, String)> {
     let client = create_oauth_client(client_id, client_secret)?;
     let scopes = vec![DRIVE_SCOPE.to_string()];
 
-    let (token, auth_url) = perform_oauth_flow(&client, scopes).await?;
+    let sender_with_prefix = tx.map(|sender| (sender, "DRIVE_"));
+    let (token, auth_url) = perform_oauth_flow(&client, scopes, sender_with_prefix).await?;
 
     let expires_at = token.expires_in()
         .map(|d| chrono::Utc::now().timestamp() + d.as_secs() as i64);

src/auth/gmail_auth.rs

@@ -47,7 +47,7 @@ pub async fn get_gmail_token(client_id: String, client_secret: String) -> Result
     }
 
     // Need new authorization
-    let (token, _) = authorize_gmail(client_id, client_secret).await?;
+    let (token, _) = authorize_gmail(client_id, client_secret, None).await?;
     Ok(token)
 }
 
@@ -92,19 +92,18 @@ pub async fn get_gmail_token_with_url(client_id: String, client_secret: String,
         }
     }
 
-    // Need new authorization - send URL first, then proceed
-    let (token, auth_url) = authorize_gmail(client_id, client_secret).await?;
-    // Send the auth URL to the TUI
-    let _ = tx.send(format!("__GMAIL_AUTH_URL__:{}", auth_url));
+    // Need new authorization - URL will be sent via channel from perform_oauth_flow
+    let (token, _auth_url) = authorize_gmail(client_id, client_secret, Some(tx)).await?;
     Ok(token)
 }
 
 /// Perform full Gmail authorization flow
-async fn authorize_gmail(client_id: String, client_secret: String) -> Result<(String, String)> {
+async fn authorize_gmail(client_id: String, client_secret: String, tx: Option<tokio::sync::mpsc::UnboundedSender<String>>) -> Result<(String, String)> {
     let client = create_oauth_client(client_id, client_secret)?;
     let scopes = vec![GMAIL_SCOPE.to_string()];
 
-    let (token, auth_url) = perform_oauth_flow(&client, scopes).await?;
+    let sender_with_prefix = tx.map(|sender| (sender, "GMAIL_"));
+    let (token, auth_url) = perform_oauth_flow(&client, scopes, sender_with_prefix).await?;
 
     let expires_at = token.expires_in()
         .map(|d| chrono::Utc::now().timestamp() + d.as_secs() as i64);

src/auth/oauth.rs

@@ -92,6 +92,7 @@ pub fn create_oauth_client(
 pub async fn perform_oauth_flow(
     client: &BasicClient,
     scopes: Vec<String>,
+    url_sender: Option<(tokio::sync::mpsc::UnboundedSender<String>, &str)>,
 ) -> Result<(StandardTokenResponse<oauth2::EmptyExtraTokenFields, BasicTokenType>, String)> {
     let (pkce_challenge, pkce_verifier) = PkceCodeChallenge::new_random_sha256();
 
@@ -110,8 +111,23 @@ pub async fn perform_oauth_flow(
     let auth_url_str = auth_url.to_string();
 
     // Try to open the URL in the default browser
-    if let Err(e) = webbrowser::open(&auth_url_str) {
-        warn!("Failed to open browser automatically: {}. Please manually open: {}", e, auth_url_str);
+    let browser_opened = webbrowser::open(&auth_url_str).is_ok();
+
+    if !browser_opened {
+        warn!("Failed to open browser automatically. Please manually open: {}", auth_url_str);
+    }
+
+    info!("Authorization URL ready: {}", auth_url_str);
+
+    // Send URL and browser status to TUI if sender is provided
+    if let Some((sender, prefix)) = url_sender {
+        // Always send the URL first so user can manually open it
+        let _ = sender.send(format!("__{}AUTH_URL__:{}", prefix, auth_url_str));
+
+        // If browser didn't open, send a notification
+        if !browser_opened {
+            let _ = sender.send(format!("__{}BROWSER_FAILED__:Failed to open browser automatically. Please copy and open the URL above manually.", prefix));
+        }
     }
 
     // Start local server to receive callback

src/drive/folder.rs

@@ -29,12 +29,16 @@ async fn find_or_create_single_folder(
     folder_name: &str,
     parent_id: &str,
 ) -> Result<String> {
+    log::info!("Looking for folder '{}' in parent '{}'", folder_name, parent_id);
+
     // Try to find existing folder
     if let Some(folder_id) = find_folder(client, folder_name, parent_id).await? {
+        log::info!("Found existing folder '{}' with ID: {}", folder_name, folder_id);
         return Ok(folder_id);
     }
 
     // Create new folder
+    log::info!("Folder '{}' not found, creating new one", folder_name);
     create_folder(client, folder_name, parent_id).await
 }
 
@@ -51,6 +55,8 @@ async fn find_folder(
         FOLDER_MIME_TYPE
     );
 
+    log::debug!("Drive search query: {}", query);
+
     let url = format!("{}/files", DRIVE_API_BASE);
 
     let response = client.client()
@@ -70,7 +76,15 @@ async fn find_folder(
     let result: FileListResponse = response.json().await
         .context("Failed to parse folder search response")?;
 
-    Ok(result.files.and_then(|files| files.first().map(|f| f.id.clone())))
+    let folder_id = result.files.and_then(|files| {
+        log::debug!("Found {} folders matching search", files.len());
+        files.first().map(|f| {
+            log::debug!("Using folder: name='{}', id='{}'", f.name, f.id);
+            f.id.clone()
+        })
+    });
+
+    Ok(folder_id)
 }
 
 /// Create a new folder

src/interfaces/tui.rs

@@ -137,6 +137,12 @@ async fn run_app<B: Backend>(
             } else if message.starts_with("__DRIVE_AUTH_URL__:") {
                 let url = message.strip_prefix("__DRIVE_AUTH_URL__:").unwrap_or("");
                 app.auth_url = Some(url.to_string());
+            } else if message.starts_with("__GMAIL_BROWSER_FAILED__:") {
+                let error = message.strip_prefix("__GMAIL_BROWSER_FAILED__:").unwrap_or("Browser failed to open");
+                app.add_progress_message(format!("Gmail Auth: {}", error));
+            } else if message.starts_with("__DRIVE_BROWSER_FAILED__:") {
+                let error = message.strip_prefix("__DRIVE_BROWSER_FAILED__:").unwrap_or("Browser failed to open");
+                app.add_progress_message(format!("Drive Auth: {}", error));
             } else if message.starts_with("__RESULTS__:") {
                 // Parse results: processed=5,uploaded=4,failed=1,month=October,folder=Invoices/October
                 let results_str = message.strip_prefix("__RESULTS__:").unwrap_or("");

src/interfaces/ui.rs

@@ -749,36 +749,37 @@ fn draw_specific_auth_url_popup(frame: &mut Frame, app: &mut App, service_name:
 
     // Title
     let title = if app.auth_popup_success {
-        Paragraph::new(format!("✅ {} Authenticated", service_name))
+        Paragraph::new(format!("{} Authenticated", service_name))
             .style(Style::default().fg(Color::Green).add_modifier(Modifier::BOLD))
             .alignment(Alignment::Center)
     } else {
-        Paragraph::new(format!("🔐 Authenticate {}", service_name))
+        Paragraph::new(format!("Authenticate {}", service_name))
             .style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
             .alignment(Alignment::Center)
     };
     frame.render_widget(title, chunks[0]);
 
     // Content display
     let content_text = if app.auth_popup_success {
-        format!("🎉 {} authentication completed successfully!\n\nYour tokens are cached and ready to use.", service_name)
+        format!("{} authentication completed successfully!\n\nYour tokens are cached and ready to use.", service_name)
     } else if let Some(url) = &app.auth_url {
-        format!("🌐 {} Authorization URL:\n\n{}", service_name, url)
+        format!("{} Authorization URL:\n\n{}", service_name, url)
     } else {
-        format!("🔄 Preparing {} authorization URL...\n\nPlease wait while we set up the OAuth flow.", service_name)
+        format!("Preparing {} authorization URL...\n\nPlease wait while we set up the OAuth flow.", service_name)
     };
 
     let content_display = Paragraph::new(content_text)
         .style(Style::default().fg(Color::White))
-        .alignment(Alignment::Center)
-        .wrap(Wrap { trim: true });
+        .alignment(Alignment::Left)
+        .wrap(Wrap { trim: false })
+        .scroll((0, 0));
     frame.render_widget(content_display, chunks[1]);
 
     // Instructions
     let instructions = if app.auth_popup_success {
-        format!("📋 Your {} authentication is active.\nYou can now close this popup or clear tokens if needed.", service_name)
+        format!("Your {} authentication is active.\nYou can now close this popup or clear tokens if needed.", service_name)
     } else {
-        format!("📋 INSTRUCTIONS:\n• Copy the URL above\n• Open it in your web browser\n• Complete the Google OAuth flow for {}\n• Return here when done\n• The app will detect completion automatically", service_name)
+        format!("INSTRUCTIONS:\n- Copy the URL above\n- Open it in your web browser\n- Complete the Google OAuth flow for {}\n- Return here when done\n- The app will detect completion automatically", service_name)
     };
 
     let instructions_widget = Paragraph::new(instructions)