refactor: centralize HTTP client and extract TUI handlers for better modularity (#436)

- Centralize HTTP client creation in cortex-common::http_client
  - cortex-engine::api_client now re-exports from cortex-common
  - Eliminates duplicated HTTP client factory code

- Extract auth handlers to cortex-tui/src/runner/auth_handlers.rs
  - Login flow (device code OAuth)
  - Logout functionality
  - Account info loading
  - Browser URL opening helper

- Extract billing handlers to cortex-tui/src/runner/billing_handlers.rs
  - Billing status fetching
  - Usage breakdown queries
  - Billing data parsing

These changes improve code organization and reduce the massive
event_loop.rs file (11k+ lines) by moving handlers into dedicated modules.
This follows Rust best practices for module organization and makes the
codebase easier to navigate and maintain.

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

Author: echobt

cortex-engine/src/api_client.rs

@@ -11,6 +11,9 @@
 //! - `create_client_with_timeout(duration)` - Custom timeout
 //!
 //! All clients include: User-Agent, tcp_nodelay, and proper error handling.
+//!
+//! Note: This module re-exports and wraps functions from `cortex_common::http_client`
+//! with appropriate error types for cortex-engine.
 
 use std::collections::HashMap;
 use std::time::Duration;
@@ -20,58 +23,35 @@ use serde::{Deserialize, Serialize, de::DeserializeOwned};
 
 use crate::error::{CortexError, Result};
 
-// ============================================================================
-// Global HTTP Client Constants
-// ============================================================================
-
-/// User-Agent string for all HTTP requests
-pub const USER_AGENT: &str = concat!("cortex-cli/", env!("CARGO_PKG_VERSION"));
-
-/// Default timeout for standard API requests (30 seconds)
-pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(30);
-
-/// Extended timeout for LLM streaming requests (5 minutes)
-pub const STREAMING_TIMEOUT: Duration = Duration::from_secs(300);
-
-/// Short timeout for health checks (5 seconds)
-pub const HEALTH_CHECK_TIMEOUT: Duration = Duration::from_secs(5);
+// Re-export constants from cortex-common
+pub use cortex_common::http_client::{
+    DEFAULT_TIMEOUT, HEALTH_CHECK_TIMEOUT, STREAMING_TIMEOUT, USER_AGENT,
+};
 
 /// Default connection timeout (10 seconds)
 pub const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
 
 // ============================================================================
-// Global HTTP Client Factory Functions
+// Global HTTP Client Factory Functions (wrapping cortex-common)
 // ============================================================================
 
 /// Creates an HTTP client with default configuration (30s timeout).
 ///
 /// Includes: User-Agent, tcp_nodelay, 30s timeout.
-///
-/// # Example
-/// ```ignore
-/// let client = create_default_client()?;
-/// let resp = client.get("https://api.example.com/data").send().await?;
-/// ```
 pub fn create_default_client() -> Result<Client> {
-    create_client_with_timeout(DEFAULT_TIMEOUT)
+    cortex_common::http_client::create_default_client().map_err(|e| CortexError::Internal(e))
 }
 
 /// Creates an HTTP client for LLM streaming (5min timeout).
 ///
 /// Use this for endpoints that stream responses (SSE, chunked transfer).
-///
-/// # Example
-/// ```ignore
-/// let client = create_streaming_client()?;
-/// let resp = client.post("https://api.example.com/chat").send().await?;
-/// ```
 pub fn create_streaming_client() -> Result<Client> {
-    create_client_with_timeout(STREAMING_TIMEOUT)
+    cortex_common::http_client::create_streaming_client().map_err(|e| CortexError::Internal(e))
 }
 
 /// Creates an HTTP client for health checks (5s timeout).
 pub fn create_health_check_client() -> Result<Client> {
-    create_client_with_timeout(HEALTH_CHECK_TIMEOUT)
+    cortex_common::http_client::create_health_check_client().map_err(|e| CortexError::Internal(e))
 }
 
 /// Creates an HTTP client with a custom timeout.
@@ -81,13 +61,8 @@ pub fn create_health_check_client() -> Result<Client> {
 /// - tcp_nodelay: true (for lower latency)
 /// - Specified timeout (applies to both connect and overall request)
 pub fn create_client_with_timeout(timeout: Duration) -> Result<Client> {
-    Client::builder()
-        .user_agent(USER_AGENT)
-        .timeout(timeout)
-        .connect_timeout(timeout) // Apply timeout to TCP connection phase as well (#2710)
-        .tcp_nodelay(true)
-        .build()
-        .map_err(|e| CortexError::Internal(format!("Failed to build HTTP client: {e}")))
+    cortex_common::http_client::create_client_with_timeout(timeout)
+        .map_err(|e| CortexError::Internal(e))
 }
 
 /// Creates an HTTP client with separate connect and response timeouts.
@@ -115,43 +90,23 @@ pub fn create_client_with_timeouts(
 ///
 /// Use this when you need to customize the client further before building.
 /// Note: The timeout is applied to both the TCP connection phase and the overall request.
-///
-/// # Example
-/// ```ignore
-/// let client = create_client_builder()
-///     .redirect(reqwest::redirect::Policy::none())
-///     .build()?;
-/// ```
 pub fn create_client_builder() -> reqwest::ClientBuilder {
-    Client::builder()
-        .user_agent(USER_AGENT)
-        .timeout(DEFAULT_TIMEOUT)
-        .connect_timeout(DEFAULT_TIMEOUT) // Apply timeout to TCP connection phase as well
-        .tcp_nodelay(true)
+    cortex_common::http_client::create_client_builder()
 }
 
 // ============================================================================
-// Blocking Client Factory (for sync code)
+// Blocking Client Factory (wrapping cortex-common)
 // ============================================================================
 
 /// Creates a blocking HTTP client with default configuration.
 pub fn create_blocking_client() -> Result<reqwest::blocking::Client> {
-    reqwest::blocking::Client::builder()
-        .user_agent(USER_AGENT)
-        .timeout(DEFAULT_TIMEOUT)
-        .connect_timeout(DEFAULT_TIMEOUT) // Apply timeout to TCP connection phase as well
-        .build()
-        .map_err(|e| CortexError::Internal(format!("Failed to build blocking HTTP client: {e}")))
+    cortex_common::http_client::create_blocking_client().map_err(|e| CortexError::Internal(e))
 }
 
 /// Creates a blocking HTTP client with custom timeout.
 pub fn create_blocking_client_with_timeout(timeout: Duration) -> Result<reqwest::blocking::Client> {
-    reqwest::blocking::Client::builder()
-        .user_agent(USER_AGENT)
-        .timeout(timeout)
-        .connect_timeout(timeout) // Apply timeout to TCP connection phase as well
-        .build()
-        .map_err(|e| CortexError::Internal(format!("Failed to build blocking HTTP client: {e}")))
+    cortex_common::http_client::create_blocking_client_with_timeout(timeout)
+        .map_err(|e| CortexError::Internal(e))
 }
 
 // ============================================================================