Port upstream CodexBar v0.56.8 [review]

apps/desktop-tauri/src-tauri/src/commands/bridge.rs

@@ -103,6 +103,10 @@ pub struct CostSnapshotBridge {
     #[serde(default)]
     pub balance: Option<f64>,
     #[serde(default)]
+    pub balance_updated_at: Option<String>,
+    #[serde(default)]
+    pub account_id: Option<String>,
+    #[serde(default)]
     pub formatted_balance: Option<String>,
     #[serde(default)]
     pub daily: Vec<CostDailyPointBridge>,
@@ -165,6 +169,15 @@ pub struct SessionEquivalentForecastSnapshot {
     pub weekly_used_percent: f64,
 }
 
+/// Subscription dates from an authenticated OpenAI dashboard/API response.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SubscriptionMetadataSnapshot {
+    pub starts_at: Option<String>,
+    pub expires_at: Option<String>,
+    pub renews_at: Option<String>,
+}
+
 /// A frontend-friendly snapshot of one provider's usage data.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -193,8 +206,12 @@ pub struct ProviderUsageSnapshot {
     pub plan_name: Option<String>,
     #[serde(default)]
     pub account_email: Option<String>,
+    #[serde(default)]
+    pub subscription: Option<SubscriptionMetadataSnapshot>,
     #[serde(default = "default_source_label")]
     pub source_label: String,
+    #[serde(default)]
+    pub has_successful_claude_cli_quota: bool,
     /// Defaults to launch time when absent so the card renders as fresh.
     #[serde(default)]
     pub updated_at: String,
@@ -378,6 +395,8 @@ impl ProviderUsageSnapshot {
                 formatted_used: c.format_used(),
                 formatted_limit: c.format_limit(),
                 balance: c.balance,
+                balance_updated_at: c.balance_updated_at.map(|dt| dt.to_rfc3339()),
+                account_id: c.account_id.clone(),
                 formatted_balance: c.format_balance(),
                 daily: c
                     .daily
@@ -391,7 +410,15 @@ impl ProviderUsageSnapshot {
             }),
             plan_name: usage.login_method.clone(),
             account_email: usage.account_email.clone(),
+            subscription: usage.subscription.as_ref().map(|subscription| {
+                SubscriptionMetadataSnapshot {
+                    starts_at: subscription.starts_at.map(|date| date.to_rfc3339()),
+                    expires_at: subscription.expires_at.map(|date| date.to_rfc3339()),
+                    renews_at: subscription.renews_at.map(|date| date.to_rfc3339()),
+                }
+            }),
             source_label: result.source_label.clone(),
+            has_successful_claude_cli_quota: result.has_successful_claude_cli_quota,
             updated_at: usage.updated_at.to_rfc3339(),
             error: None,
             error_state: codexbar::core::ProviderStateKind::Ready,
@@ -437,7 +464,9 @@ impl ProviderUsageSnapshot {
             cost: None,
             plan_name: None,
             account_email: None,
+            subscription: None,
             source_label: String::new(),
+            has_successful_claude_cli_quota: false,
             updated_at: chrono::Utc::now().to_rfc3339(),
             error: Some(error),
             error_state: state_kind,

apps/desktop-tauri/src-tauri/src/commands/codex_accounts.rs

@@ -105,13 +105,19 @@ pub(crate) async fn refresh_codex_account_lanes(
             let api = CodexAccountApi::new();
             let home_path = account.codex_home_path.clone();
             let email_hint = account.email_hint.clone();
+            let workspace_account_id = account.effective_workspace_account_id();
             match tokio::time::timeout(
                 std::time::Duration::from_secs(DEFAULT_FETCH_TIMEOUT_SECONDS),
-                api.fetch_snapshot(&home_path, email_hint.as_deref(), true),
+                api.fetch_snapshot_for_workspace(
+                    &home_path,
+                    email_hint.as_deref(),
+                    workspace_account_id.as_deref(),
+                    true,
+                ),
             )
             .await
             {
-                Ok(Ok(snapshot)) => Some((account.id, snapshot)),
+                Ok(Ok(snapshot)) => Some((account, snapshot)),
                 Ok(Err(e)) => {
                     tracing::debug!(
                         "codex account lane {} failed: {}",
@@ -128,10 +134,28 @@ pub(crate) async fn refresh_codex_account_lanes(
         }));
     }
 
+    let current_accounts = load_codex_accounts().unwrap_or_default();
+    let current_by_id: HashMap<Uuid, CodexAccount> = current_accounts
+        .iter()
+        .cloned()
+        .map(|account| (account.id, account))
+        .collect();
     let mut snapshots = SnapshotStore::new().load().unwrap_or_default();
+    snapshots.retain(|id, snapshot| {
+        current_by_id
+            .get(id)
+            .is_some_and(|account| account_snapshot_belongs_to(account, snapshot))
+    });
     for handle in handles {
-        if let Ok(Some((id, snapshot))) = handle.await {
-            snapshots.insert(id, snapshot);
+        if let Ok(Some((fetched_account, snapshot))) = handle.await
+            && current_by_id
+                .get(&fetched_account.id)
+                .is_some_and(|current| {
+                    account_lane_is_current(&fetched_account, current)
+                        && account_snapshot_belongs_to(current, &snapshot)
+                })
+        {
+            snapshots.insert(fetched_account.id, snapshot);
         }
     }
     if let Err(e) = SnapshotStore::new().save(&snapshots) {
@@ -232,16 +256,30 @@ pub async fn codex_account_fetch(
     let api = CodexAccountApi::new();
     let home_path = target.codex_home_path.clone();
     let email_hint = target.email_hint.clone();
+    let workspace_account_id = target.effective_workspace_account_id();
     let snapshot = tokio::time::timeout(
         std::time::Duration::from_secs(DEFAULT_FETCH_TIMEOUT_SECONDS),
-        api.fetch_snapshot(&home_path, email_hint.as_deref(), true),
+        api.fetch_snapshot_for_workspace(
+            &home_path,
+            email_hint.as_deref(),
+            workspace_account_id.as_deref(),
+            true,
+        ),
     )
     .await
     .map_err(|_| "Timed out waiting for the Codex usage API.".to_string())?
     .map_err(into_api_message)?;
 
     // Persist snapshot to the snapshot store, keyed by account id.
-    if let Ok(mut snapshots) = SnapshotStore::new().load() {
+    if let Ok(mut snapshots) = SnapshotStore::new().load()
+        && load_codex_accounts().ok().is_some_and(|accounts| {
+            accounts.iter().any(|account| {
+                account.id == target.id
+                    && account_lane_is_current(&target, account)
+                    && account_snapshot_belongs_to(account, &snapshot)
+            })
+        })
+    {
         snapshots.insert(target.id, snapshot.clone());
         let _ = SnapshotStore::new().save(&snapshots);
     }
@@ -306,6 +344,58 @@ fn into_api_message(error: CodexApiError) -> String {
     }
 }
 
+fn account_home_key(account: &CodexAccount) -> String {
+    std::path::absolute(&account.codex_home_path)
+        .unwrap_or_else(|_| account.codex_home_path.clone())
+        .to_string_lossy()
+        .to_lowercase()
+}
+
+/// In-flight results are only authoritative for the selected workspace and
+/// managed home that started the request.
+fn account_lane_is_current(started: &CodexAccount, current: &CodexAccount) -> bool {
+    started.id == current.id
+        && account_home_key(started) == account_home_key(current)
+        && started.effective_workspace_account_id() == current.effective_workspace_account_id()
+}
+
+fn account_snapshot_belongs_to(
+    account: &CodexAccount,
+    snapshot: &codexbar::codex_accounts::AccountUsageSnapshot,
+) -> bool {
+    let snapshot_workspace = snapshot
+        .provider_account_id
+        .as_deref()
+        .map(str::trim)
+        .filter(|id| !id.is_empty())
+        .map(str::to_lowercase);
+    match (account.effective_workspace_account_id(), snapshot_workspace) {
+        (Some(account_workspace), Some(snapshot_workspace)) => {
+            account_workspace == snapshot_workspace
+        }
+        (None, None) => true,
+        _ => false,
+    }
+}
+
+fn snapshots_for_accounts(
+    accounts: &[CodexAccount],
+    snapshots: HashMap<Uuid, codexbar::codex_accounts::AccountUsageSnapshot>,
+) -> HashMap<Uuid, codexbar::codex_accounts::AccountUsageSnapshot> {
+    let accounts_by_id: HashMap<Uuid, &CodexAccount> = accounts
+        .iter()
+        .map(|account| (account.id, account))
+        .collect();
+    snapshots
+        .into_iter()
+        .filter(|(id, snapshot)| {
+            accounts_by_id
+                .get(id)
+                .is_some_and(|account| account_snapshot_belongs_to(account, snapshot))
+        })
+        .collect()
+}
+
 #[derive(Debug, serde::Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct CodexAccountsStateBridge {
@@ -320,10 +410,12 @@ pub fn get_codex_accounts_state(
 ) -> Result<CodexAccountsStateBridge, String> {
     let _guard = state.lock().map_err(|e| e.to_string())?;
     let accounts = load_codex_accounts()?;
+    let display_names = display_names_by_id(&accounts);
+    let snapshots = snapshots_for_accounts(&accounts, codex_account_snapshots()?);
     Ok(CodexAccountsStateBridge {
-        display_names: display_names_by_id(&accounts),
         accounts,
-        snapshots: codex_account_snapshots()?,
+        display_names,
+        snapshots,
     })
 }