Port upstream CodexBar 0.52.0-0.53.0

apps/desktop-tauri/src-tauri/src/auto_refresh.rs

@@ -98,19 +98,22 @@ pub(crate) fn automatic_interval(
 }
 
 fn resolve_refresh_interval(settings: &Settings) -> Option<Duration> {
+    let effective_low_power = settings
+        .low_power_mode_preference
+        .resolve(system_battery_saver_enabled());
     let requested = if settings.adaptive_refresh {
-        Some(adaptive_delay_now())
+        Some(adaptive_delay_now(effective_low_power))
     } else {
         refresh_interval(settings.refresh_interval_secs)
     };
-    automatic_interval(requested, settings.low_power_mode)
+    automatic_interval(requested, effective_low_power)
 }
 
-fn adaptive_delay_now() -> Duration {
+fn adaptive_delay_now(low_power_mode_enabled: bool) -> Duration {
     let decision = adaptive_next_delay(AdaptiveRefreshInput {
         last_menu_open_age: age_since(&LAST_MENU_OPEN),
         last_coding_activity_age: age_since(&LAST_CODING_ACTIVITY),
-        low_power_mode_enabled: low_power_mode_enabled(),
+        low_power_mode_enabled,
         thermal_pressure: ThermalPressure::Nominal,
     });
     tracing::debug!(
@@ -122,13 +125,13 @@ fn adaptive_delay_now() -> Duration {
     decision.delay
 }
 
-/// Best-effort Windows battery/AC check. Returns false when unknown.
-fn low_power_mode_enabled() -> bool {
+/// Best-effort Windows Battery Saver check. Returns false when unknown.
+fn system_battery_saver_enabled() -> bool {
     #[cfg(windows)]
     {
-        // SYSTEM_POWER_STATUS via kernel32. ACLineStatus: 0 = offline (battery).
-        // BatteryFlag bit 0x08 = charging; BatteryLifePercent 0-100 or 255 unknown.
-        // Treat "on battery and < 20% remaining" as low-power; skip on failure.
+        // SYSTEM_POWER_STATUS via kernel32. SystemStatusFlag bit 0x01 is
+        // the Windows 10+ Battery Saver state. Automatic follows that explicit
+        // system preference only; battery percentage alone is not equivalent.
         #[repr(C)]
         struct SystemPowerStatus {
             ac_line_status: u8,
@@ -154,11 +157,7 @@ fn low_power_mode_enabled() -> bool {
         if !ok {
             return false;
         }
-        let on_battery = status.ac_line_status == 0;
-        let low_pct = status.battery_life_percent <= 20;
-        // system_status_flag bit 0x01 = Battery Saver is on (Win10+)
-        let battery_saver = status.system_status_flag & 0x01 != 0;
-        on_battery && (low_pct || battery_saver)
+        status.system_status_flag & 0x01 != 0
     }
     #[cfg(not(windows))]
     {
@@ -261,7 +260,7 @@ mod tests {
         assert_eq!(automatic_interval(None, true), None);
 
         let settings = Settings {
-            low_power_mode: true,
+            low_power_mode_preference: codexbar::settings::LowPowerModePreference::On,
             adaptive_refresh: false,
             refresh_interval_secs: 300,
             ..Default::default()

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

@@ -642,6 +642,7 @@ pub struct SettingsSnapshot {
     adaptive_refresh: bool,
     refresh_all_providers_on_menu_open: bool,
     low_power_mode: bool,
+    low_power_mode_preference: &'static str,
     start_at_login: bool,
     start_minimized: bool,
     show_notifications: bool,
@@ -701,6 +702,8 @@ pub struct SettingsSnapshot {
     alibaba_token_plan_region: String,
     weekly_progress_work_days: Option<u8>,
     cost_summary_display_style: &'static str,
+    open_codex_usage_logs_enabled: bool,
+    hide_native_codex_cost_when_open_codex_present: bool,
     provider_accent_colors: std::collections::HashMap<String, String>,
 }
 
@@ -749,7 +752,8 @@ impl From<Settings> for SettingsSnapshot {
             refresh_interval_secs: settings.refresh_interval_secs,
             adaptive_refresh: settings.adaptive_refresh,
             refresh_all_providers_on_menu_open: settings.refresh_all_providers_on_menu_open,
-            low_power_mode: settings.low_power_mode,
+            low_power_mode: settings.low_power_mode_preference == codexbar::settings::LowPowerModePreference::On,
+            low_power_mode_preference: settings.low_power_mode_preference.as_str(),
             start_at_login: settings.start_at_login,
             start_minimized: settings.start_minimized,
             show_notifications: settings.show_notifications,
@@ -810,6 +814,8 @@ impl From<Settings> for SettingsSnapshot {
             cost_summary_display_style: cost_summary_display_style_label(
                 settings.cost_summary_display_style,
             ),
+            open_codex_usage_logs_enabled: settings.open_codex_usage_logs_enabled,
+            hide_native_codex_cost_when_open_codex_present: settings.hide_native_codex_cost_when_open_codex_present,
             provider_accent_colors: settings
                 .provider_configs
                 .iter()

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

@@ -27,6 +27,7 @@ mod chart;
 mod tokens;
 mod updater;
 mod usage_spend;
+mod spend_contract;
 
 mod agent_sessions;
 mod bridge;
@@ -67,6 +68,7 @@ pub use chart::*;
 pub use tokens::*;
 pub use updater::*;
 pub use usage_spend::*;
+pub use spend_contract::*;
 
 const PROVIDER_CACHE_STALE_AFTER: std::time::Duration = std::time::Duration::from_secs(30);
 const MAX_API_KEY_LEN: usize = 16 * 1024;

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

@@ -43,6 +43,7 @@ pub struct ProviderDetail {
     // Phase 6c — currently-persisted cookie source & region for round-tripping
     // into the settings UI pickers. `None` for providers that do not support
     // one of the pickers.
+    pub usage_source: Option<String>,
     pub cookie_source: Option<String>,
     pub region: Option<String>,
 }
@@ -96,6 +97,7 @@ pub(crate) fn build_provider_detail(provider_id: &str) -> Result<ProviderDetail,
             None
         },
         has_snapshot: false,
+        usage_source: provider_usage_source_lookup(&settings, id.cli_name()),
         cookie_source: provider_cookie_source_lookup(&settings, id.cli_name()),
         region: provider_region_lookup(&settings, id.cli_name()),
     })

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

@@ -63,6 +63,37 @@ pub fn reorder_providers(
     Ok(build_provider_summaries(&settings))
 }
 
+// ── Per-provider usage source ─────────────────────────────────────────
+
+pub(crate) fn provider_usage_source_lookup(
+    settings: &Settings,
+    provider_id: &str,
+) -> Option<String> {
+    parse_provider_arg(provider_id)
+        .ok()
+        .map(|id| settings.usage_source(id).to_string())
+}
+
+#[tauri::command]
+pub fn set_provider_usage_source(provider_id: String, source: String) -> Result<(), String> {
+    let id = parse_provider_arg(&provider_id)?;
+    let mode = SourceMode::parse(source.trim())
+        .ok_or_else(|| format!("Invalid usage source '{source}' for provider '{provider_id}'"))?;
+    let provider = instantiate_provider(id);
+    if !provider.available_sources().contains(&mode) {
+        return Err(format!("Usage source '{source}' is unavailable for provider '{provider_id}'"));
+    }
+    let value = match mode {
+        SourceMode::Auto => "auto",
+        SourceMode::Cli => "cli",
+        SourceMode::OAuth => "oauth",
+        SourceMode::Web => "web",
+    };
+    let mut settings = Settings::load();
+    settings.set_usage_source(id, value);
+    settings.save().map_err(|e| e.to_string())
+}
+
 // ── Per-provider cookie source + region ───────────────────────────────
 
 /// Map a CLI-name string to a `ProviderId` whose cookie source is exposed in
@@ -86,6 +117,7 @@ fn cookie_source_provider(provider_id: &str) -> Option<codexbar::core::ProviderI
         "codebuddy" => ProviderId::CodeBuddy,
         "sakana" => ProviderId::Sakana,
         "notion" => ProviderId::Notion,
+        "grok" => ProviderId::Grok,
         _ => return None,
     })
 }
@@ -430,6 +462,29 @@ pub fn cookie_source_options_for(provider_id: &str, lang: Language) -> Vec<Cooki
                 None,
             ),
         ],
+        "grok" => vec![
+            cookie_option(
+                lang,
+                "auto",
+                "Automatic imports grok.com browser cookies.",
+                "Paste a Cookie header from a grok.com request.",
+                Some("Grok browser cookies are disabled."),
+            ),
+            cookie_option(
+                lang,
+                "manual",
+                "",
+                "Paste a Cookie header from a grok.com request.",
+                None,
+            ),
+            cookie_option(
+                lang,
+                "off",
+                "",
+                "",
+                Some("Grok browser cookies are disabled."),
+            ),
+        ],
         "opencode" => vec![
             cookie_option(
                 lang,

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

@@ -12,6 +12,7 @@ pub struct SettingsUpdate {
     pub adaptive_refresh: Option<bool>,
     pub refresh_all_providers_on_menu_open: Option<bool>,
     pub low_power_mode: Option<bool>,
+    pub low_power_mode_preference: Option<String>,
     pub start_at_login: Option<bool>,
     pub start_minimized: Option<bool>,
     pub show_notifications: Option<bool>,
@@ -71,6 +72,8 @@ pub struct SettingsUpdate {
     pub alibaba_token_plan_region: Option<String>,
     pub weekly_progress_work_days: Option<u8>,
     pub cost_summary_display_style: Option<String>,
+    pub open_codex_usage_logs_enabled: Option<bool>,
+    pub hide_native_codex_cost_when_open_codex_present: Option<bool>,
 }
 
 impl SettingsUpdate {
@@ -85,6 +88,7 @@ impl SettingsUpdate {
         self.enabled_providers.is_some()
             || self.refresh_interval_secs.is_some()
             || self.low_power_mode.is_some()
+            || self.low_power_mode_preference.is_some()
             || self.adaptive_refresh.is_some()
             || self.codex_custom_sessions_dirs.is_some()
             || self.high_usage_threshold.is_some()
@@ -148,8 +152,23 @@ impl SettingsUpdate {
         if let Some(v) = self.refresh_all_providers_on_menu_open {
             settings.refresh_all_providers_on_menu_open = v;
         }
+        if let Some(v) = self.open_codex_usage_logs_enabled {
+            settings.open_codex_usage_logs_enabled = v;
+        }
+        if let Some(v) = self.hide_native_codex_cost_when_open_codex_present {
+            settings.hide_native_codex_cost_when_open_codex_present = v;
+        }
         if let Some(v) = self.low_power_mode {
-            settings.low_power_mode = v;
+            settings.low_power_mode_preference = if v {
+                codexbar::settings::LowPowerModePreference::On
+            } else {
+                codexbar::settings::LowPowerModePreference::Off
+            };
+        }
+        if let Some(value) = self.low_power_mode_preference.as_deref()
+            && let Some(preference) = codexbar::settings::LowPowerModePreference::parse(value)
+        {
+            settings.low_power_mode_preference = preference;
         }
         if let Some(ref s) = self.tray_icon_mode
             && let Some(mode) = parse_tray_icon_mode(s)
@@ -353,6 +372,11 @@ impl SettingsUpdate {
     }
 
     fn apply_to(self, settings: &mut Settings) -> Result<crate::floatbar::SettingsPatch, String> {
+        if let Some(value) = self.low_power_mode_preference.as_deref()
+            && codexbar::settings::LowPowerModePreference::parse(value).is_none()
+        {
+            return Err(format!("Invalid low power mode preference: {value}"));
+        }
         let float_bar_patch = self.float_bar_patch();
         self.apply_provider_settings(settings)
             .apply_general_settings(settings)?

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

@@ -0,0 +1,37 @@
+//! Upstream 0.53 Usage & Spend accounting bridge.
+
+use codexbar::settings::Settings;
+use codexbar::spend_contract::{SpendContract, build_local_spend_contract_from_summary};
+use codexbar::cost_scanner::CostScanner;
+
+#[tauri::command]
+pub async fn get_spend_contract(
+    provider_id: String,
+    history_days: Option<u32>,
+    include_open_codex: Option<bool>,
+) -> Result<SpendContract, String> {
+    let provider = provider_id.trim().to_ascii_lowercase();
+    if !matches!(provider.as_str(), "codex" | "claude" | "opencodego") {
+        return Err(format!("Spend contract is unavailable for provider: {provider}"));
+    }
+    let days = history_days.unwrap_or(30);
+    let include_import = include_open_codex.unwrap_or(false) && provider == "codex";
+    tauri::async_runtime::spawn_blocking(move || {
+        let history_days = if days == 0 { 365 } else { days.clamp(1, 365) };
+        let scanner = CostScanner::new(history_days);
+        let summary = match provider.as_str() {
+            "codex" => scanner.scan_codex(),
+            "claude" => scanner.scan_claude(),
+            "opencodego" => scanner.scan_opencodego_with_cancel(None),
+            _ => unreachable!(),
+        };
+        let settings = Settings::load();
+        build_local_spend_contract_from_summary(
+            &provider, history_days, include_import,
+            settings.hide_native_codex_cost_when_open_codex_present && provider == "codex",
+            summary,
+        )
+    })
+    .await
+    .map_err(|error| format!("spend contract worker failed: {error}"))
+}