fix(tui): wait for /me API response before displaying TUI (#476)

Previously, the TUI was initialized immediately and the /me API call was
made in the background with a 500ms timeout. If the response didn't arrive
in time, the welcome screen would display 'User' as a placeholder instead
of the actual username.

This change moves the /me API call to execute BEFORE the TUI is
initialized, ensuring the user's name is available when the welcome
screen is rendered. The API timeout remains at 5 seconds to allow
sufficient time for the response, even on slower connections.

Co-authored-by: Droid Agent <droid@factory.ai>

Author: echobt

cortex-tui/src/runner/app_runner.rs

@@ -613,10 +613,58 @@ impl AppRunner {
         }
 
         // ====================================================================
-        // PERFORMANCE OPTIMIZATION: Start TUI immediately, fetch data in background
+        // Fetch user info BEFORE showing TUI to avoid "User" placeholder
+        // ====================================================================
+        let mut user_name: Option<String> = None;
+        let mut user_email: Option<String> = None;
+        let mut org_name: Option<String> = None;
+
+        // Fetch user info from /me API - wait for this before showing TUI
+        if let Some(token) = cortex_login::get_auth_token() {
+            tracing::debug!("Fetching user info from /me API...");
+            if let Ok(client) = cortex_engine::create_default_client() {
+                match client
+                    .get("https://api.cortex.foundation/auth/me")
+                    .bearer_auth(&token)
+                    .timeout(std::time::Duration::from_secs(5))
+                    .send()
+                    .await
+                {
+                    Ok(resp) if resp.status().is_success() => {
+                        if let Ok(json) = resp.json::<serde_json::Value>().await {
+                            if let Some(name) = json.get("name").and_then(|v| v.as_str()) {
+                                user_name = Some(name.to_string());
+                                tracing::info!("User info loaded: {}", name);
+                            }
+                            if let Some(email) = json.get("email").and_then(|v| v.as_str()) {
+                                user_email = Some(email.to_string());
+                            }
+                            if let Some(orgs) = json.get("organizations").and_then(|v| v.as_array())
+                            {
+                                if let Some(first_org) = orgs.first() {
+                                    if let Some(org) =
+                                        first_org.get("org_name").and_then(|v| v.as_str())
+                                    {
+                                        org_name = Some(org.to_string());
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    Ok(resp) => {
+                        tracing::warn!("Failed to fetch user info: HTTP {}", resp.status());
+                    }
+                    Err(e) => {
+                        tracing::warn!("Failed to fetch user info: {}", e);
+                    }
+                }
+            }
+        }
+
+        // ====================================================================
+        // Now initialize TUI after we have user info
         // ====================================================================
 
-        // Initialize terminal FIRST to minimize perceived latency
         let mut terminal = CortexTerminal::with_options(self.terminal_options)?;
         terminal.set_title("Cortex")?;
 
@@ -641,12 +689,17 @@ impl AppRunner {
 
         let _session_id = cortex_session.id().to_string();
 
-        // Create app state
+        // Create app state with user info already loaded
         let mut app_state = AppState::new()
             .with_model(model.clone())
             .with_provider(provider.clone())
             .with_terminal_size(width, height);
 
+        // Set user info from pre-fetched data
+        app_state.user_name = user_name;
+        app_state.user_email = user_email;
+        app_state.org_name = org_name;
+
         // ====================================================================
         // BACKGROUND TASKS: Spawn non-blocking operations in parallel
         // ====================================================================
@@ -655,31 +708,6 @@ impl AppRunner {
         let session_history_task =
             tokio::task::spawn_blocking(|| CortexSession::list_recent(50).ok());
 
-        // 2. Fetch user info from API (HTTP request) - spawn in background
-        let user_info_task = {
-            let token = cortex_login::get_auth_token();
-            tokio::spawn(async move {
-                if let Some(token) = token {
-                    if let Ok(client) = cortex_engine::create_default_client() {
-                        if let Ok(resp) = client
-                            .get("https://api.cortex.foundation/auth/me")
-                            .bearer_auth(&token)
-                            .timeout(std::time::Duration::from_secs(5))
-                            .send()
-                            .await
-                        {
-                            if resp.status().is_success() {
-                                if let Ok(json) = resp.json::<serde_json::Value>().await {
-                                    return Some(json);
-                                }
-                            }
-                        }
-                    }
-                }
-                None
-            })
-        };
-
         // 3. Models prefetch and session validation - spawn in background
         // We use a channel to receive results and update provider_manager later
         let models_and_validation_task = {
@@ -769,27 +797,6 @@ impl AppRunner {
             );
         }
 
-        // Wait for user info (with short timeout - don't block TUI)
-        if let Ok(Some(json)) =
-            tokio::time::timeout(std::time::Duration::from_millis(500), user_info_task)
-                .await
-                .unwrap_or(Ok(None))
-        {
-            if let Some(name) = json.get("name").and_then(|v| v.as_str()) {
-                app_state.user_name = Some(name.to_string());
-            }
-            if let Some(email) = json.get("email").and_then(|v| v.as_str()) {
-                app_state.user_email = Some(email.to_string());
-            }
-            if let Some(orgs) = json.get("organizations").and_then(|v| v.as_array()) {
-                if let Some(first_org) = orgs.first() {
-                    if let Some(org_name) = first_org.get("org_name").and_then(|v| v.as_str()) {
-                        app_state.org_name = Some(org_name.to_string());
-                    }
-                }
-            }
-        }
-
         // Check validation result (with short timeout - don't block TUI)
         // We'll handle models update after event loop is created
         let validation_result = tokio::time::timeout(