Port upstream CodexBar 0.56.3 [review]

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

@@ -6,7 +6,7 @@ use uuid::Uuid;
 
 use codexbar::codex_accounts::{
     AccountStore, CodexAccount, CodexAccountApi, CodexAccountManager, CodexAccountManagerError,
-    CodexApiError, CodexSwitchResult, SnapshotStore, restart_codex_desktop,
+    CodexApiError, CodexSwitchResult, SnapshotStore, display_names_by_id, restart_codex_desktop,
 };
 
 use crate::state::AppState;
@@ -310,6 +310,7 @@ fn into_api_message(error: CodexApiError) -> String {
 #[serde(rename_all = "camelCase")]
 pub struct CodexAccountsStateBridge {
     pub accounts: Vec<CodexAccount>,
+    pub display_names: HashMap<Uuid, String>,
     pub snapshots: HashMap<Uuid, codexbar::codex_accounts::AccountUsageSnapshot>,
 }
 
@@ -318,8 +319,10 @@ pub fn get_codex_accounts_state(
     state: tauri::State<'_, Mutex<AppState>>,
 ) -> Result<CodexAccountsStateBridge, String> {
     let _guard = state.lock().map_err(|e| e.to_string())?;
+    let accounts = load_codex_accounts()?;
     Ok(CodexAccountsStateBridge {
-        accounts: load_codex_accounts()?,
+        display_names: display_names_by_id(&accounts),
+        accounts,
         snapshots: codex_account_snapshots()?,
     })
 }

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

@@ -126,7 +126,7 @@ fn build_usage_spend_summary_cached(
     }
     // Hold the cache mutex while building: callers for the same app revision
     // coalesce behind this single scan instead of starting parallel rescans.
-    let summary = build_usage_spend_summary(cached, selected_days, &settings);
+    let summary = build_usage_spend_summary(cached, selected_days, &settings, force_refresh);
     *guard = Some(CachedUsageSpendSummary {
         key,
         summary: summary.clone(),
@@ -196,19 +196,29 @@ fn build_usage_spend_summary(
     cached: &[ProviderUsageSnapshot],
     selected_days: u32,
     settings: &codexbar::settings::Settings,
+    force_refresh: bool,
 ) -> UsageSpendSummary {
     let include_opencodex = settings.open_codex_usage_logs_enabled;
     let hide_native = settings.hide_native_codex_cost_when_open_codex_present;
 
     // Upstream 0.55.0 #3105: independent provider baselines load in parallel.
     // Keep each provider's 7d/30d scans serial so they can safely share that
     // provider's incremental cache, while Codex and Claude run concurrently.
+    let codex_scan_options = if force_refresh {
+        codexbar::core::CostScanOptions::app_driven()
+    } else {
+        codexbar::core::CostScanOptions::default()
+    };
     let ((codex_7_summary, codex_30_summary), (claude_7_summary, claude_30_summary)) =
         std::thread::scope(|scope| {
-            let codex = scope.spawn(|| {
+            let codex = scope.spawn(move || {
                 (
-                    CostScanner::new(7).scan_codex(),
-                    CostScanner::new(30).scan_codex(),
+                    CostScanner::new(7)
+                        .with_options(codex_scan_options)
+                        .scan_codex(),
+                    CostScanner::new(30)
+                        .with_options(codex_scan_options)
+                        .scan_codex(),
                 )
             });
             let claude = scope.spawn(|| {
@@ -428,7 +438,9 @@ fn build_usage_spend_summary(
     let selected_summary: CostSummary = match history_days {
         7 => codex_7_summary,
         30 => codex_30_summary,
-        days => CostScanner::new(days).scan_codex(),
+        days => CostScanner::new(days)
+            .with_options(codex_scan_options)
+            .scan_codex(),
     };
     let contract = build_local_spend_contract_from_summary(
         "codex",

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

@@ -259,6 +259,21 @@ mod tests {
         );
     }
 
+    #[test]
+    fn single_meaningful_quota_omits_the_companion_icon_lane() {
+        let mut snapshot = snapshot();
+        snapshot
+            .secondary
+            .as_mut()
+            .expect("fixture has a secondary window")
+            .is_informational = true;
+
+        let (selected, companion) = selected_usage_icon_windows(&snapshot, &Settings::default());
+
+        assert_eq!(selected.used_percent, 20.0);
+        assert!(companion.is_none());
+    }
+
     #[test]
     fn average_preference_derives_the_combined_percentage() {
         let mut snapshot = snapshot();

apps/desktop-tauri/src/components/CodexAccountsMenu.tsx

@@ -8,6 +8,7 @@ import type {
 import { useLocale } from "../hooks/useLocale";
 import { useFormattedResetTime } from "../hooks/useFormattedResetTime";
 import { maskEmail } from "./MenuCard";
+import { buildCodexAccountDisplayNames } from "./codexAccountDisplay";
 import {
   codexAccountSwitch,
   getCodexAccountsState,
@@ -35,6 +36,7 @@ export default function CodexAccountsMenu({
   const [snapshots, setSnapshots] = useState<
     Record<string, CodexAccountUsageSnapshot>
   >({});
+  const [displayNames, setDisplayNames] = useState<Record<string, string>>({});
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
@@ -44,6 +46,7 @@ export default function CodexAccountsMenu({
     try {
       const next: CodexAccountsStateBridge = await getCodexAccountsState();
       setAccounts(next.accounts);
+      setDisplayNames(next.displayNames ?? {});
       setSnapshots(next.snapshots);
     } catch (err: unknown) {
       setError(err instanceof Error ? err.message : String(err));
@@ -86,6 +89,11 @@ export default function CodexAccountsMenu({
     return null;
   }
 
+  const accountDisplayNames = buildCodexAccountDisplayNames(
+    accounts,
+    displayNames,
+  );
+
   return (
     <details className="codex-menu-accounts">
       <summary className="codex-menu-accounts__summary">
@@ -103,6 +111,7 @@ export default function CodexAccountsMenu({
             key={account.id}
             account={account}
             snapshot={snapshots[account.id]}
+            displayName={accountDisplayNames[account.id]}
             hideEmail={hideEmail}
             resetTimeRelative={resetTimeRelative}
             busy={busy}
@@ -117,13 +126,15 @@ export default function CodexAccountsMenu({
 function CodexAccountRow({
   account,
   snapshot,
+  displayName,
   hideEmail,
   resetTimeRelative,
   busy,
   onSwitch,
 }: {
   account: CodexAccount;
   snapshot: CodexAccountUsageSnapshot | undefined;
+  displayName: string;
   hideEmail: boolean;
   resetTimeRelative: boolean;
   busy: boolean;
@@ -147,12 +158,13 @@ function CodexAccountRow({
       : `${t("MetricResetsIn")} ${resetText}`
     : null;
   const windowLabel = formatWindowLabel(usageWindow?.limitWindowSeconds);
-  const label =
-    account.nickname ??
-    account.emailHint ??
-    account.authSubject ??
-    shrink(account.id);
-  const shown = hideEmail ? maskEmail(label) : label;
+  // Only mask labels that actually contain an email. Generic/nickname labels
+  // have no personal data to hide, and masking them would erase their opaque
+  // workspace suffix and make distinct accounts look identical.
+  const shown =
+    hideEmail && displayName.includes("@")
+      ? maskEmail(displayName)
+      : displayName;
   const isAmbient = account.source === "ambient";
 
   return (
@@ -212,7 +224,3 @@ function formatWindowLabel(
   }
   return null;
 }
-
-function shrink(id: string): string {
-  return id.length <= 12 ? id : `${id.slice(0, 8)}…`;
-}

apps/desktop-tauri/src/components/codexAccountDisplay.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import type { CodexAccount } from "../types/bridge";
+import { buildCodexAccountDisplayNames } from "./codexAccountDisplay";
+
+function account(id: string, providerAccountId: string): CodexAccount {
+  return {
+    id,
+    nickname: null,
+    emailHint: "same@example.com",
+    authSubject: null,
+    providerAccountId,
+    codexHomePath: `C:/private/${providerAccountId}`,
+    source: "managedByApp",
+    createdAt: "2024-01-01T00:00:00Z",
+    updatedAt: "2024-01-01T00:00:00Z",
+    lastAuthenticatedAt: null,
+  };
+}
+
+describe("Codex account display labels", () => {
+  it("keeps same-email workspace labels opaque and stable across ordering", () => {
+    const first = account(
+      "11111111-1111-1111-1111-111111111111",
+      "workspace-alpha",
+    );
+    const second = account(
+      "22222222-2222-2222-2222-222222222222",
+      "workspace-beta",
+    );
+
+    const labels = buildCodexAccountDisplayNames([first, second]);
+    const reversed = buildCodexAccountDisplayNames([second, first]);
+
+    expect(labels[first.id]).not.toBe(labels[second.id]);
+    expect(labels[first.id]).toMatch(/^same@example\.com · [0-9a-f]{8}$/);
+    expect(labels[second.id]).toMatch(/^same@example\.com · [0-9a-f]{8}$/);
+    expect(labels[first.id]).not.toContain("workspace-alpha");
+    expect(labels[second.id]).not.toContain("workspace-beta");
+    expect(reversed[first.id]).toBe(labels[first.id]);
+    expect(reversed[second.id]).toBe(labels[second.id]);
+  });
+
+  it("binds canonical labels to account ids without exposing fallback fields", () => {
+    const first = account(
+      "33333333-3333-3333-3333-333333333333",
+      "internal-one",
+    );
+    const second = account(
+      "44444444-4444-4444-4444-444444444444",
+      "internal-two",
+    );
+    const canonical = {
+      [first.id]: "same@example.com · 1111aaaa",
+      [second.id]: "same@example.com · 2222bbbb",
+    };
+
+    const labels = buildCodexAccountDisplayNames(
+      [second, first],
+      canonical,
+    );
+
+    expect(labels[first.id]).toBe(canonical[first.id]);
+    expect(labels[second.id]).toBe(canonical[second.id]);
+    expect(Object.values(labels).join(" ")).not.toContain("internal-");
+  });
+
+  it("uses a generic privacy-safe fallback when identity fields are absent", () => {
+    const missingIdentity = {
+      ...account("55555555-5555-5555-5555-555555555555", "secret-workspace"),
+      nickname: null,
+      emailHint: null,
+      authSubject: "auth0|secret-subject",
+      codexHomePath: "C:/private/secret-workspace",
+    };
+
+    const [label] = Object.values(
+      buildCodexAccountDisplayNames([missingIdentity]),
+    );
+
+    expect(label).toBe("Workspace");
+    expect(label).not.toContain("secret-workspace");
+    expect(label).not.toContain("secret-subject");
+    expect(label).not.toContain("C:/private");
+  });
+});

apps/desktop-tauri/src/components/codexAccountDisplay.ts

@@ -0,0 +1,56 @@
+import type { CodexAccount } from "../types/bridge";
+
+/**
+ * Return the same account labels in Settings and the tray menu. The backend
+ * normally supplies the canonical SHA-256-derived labels; the deterministic
+ * opaque-id fallback keeps older/test bridges collision-safe too.
+ */
+export function buildCodexAccountDisplayNames(
+  accounts: readonly CodexAccount[],
+  canonical: Readonly<Record<string, string>> = {},
+): Record<string, string> {
+  const groups = new Map<string, CodexAccount[]>();
+  for (const account of accounts) {
+    const base = codexAccountBaseName(account);
+    const key = base.trim().toLowerCase();
+    const group = groups.get(key) ?? [];
+    group.push(account);
+    groups.set(key, group);
+  }
+
+  const result: Record<string, string> = {};
+  for (const account of accounts) {
+    const supplied = canonical[account.id]?.trim();
+    if (supplied) {
+      result[account.id] = supplied;
+      continue;
+    }
+
+    const base = codexAccountBaseName(account);
+    const group = groups.get(base.trim().toLowerCase()) ?? [];
+    result[account.id] =
+      group.length > 1
+        ? `${base} · ${opaqueAccountSuffix(account.id)}`
+        : base;
+  }
+  return result;
+}
+
+export function codexAccountBaseName(account: CodexAccount): string {
+  const nickname = account.nickname?.trim();
+  const email = account.emailHint?.trim().toLowerCase();
+  if (email && nickname) return `${email} — ${nickname}`;
+  return nickname || email || "Workspace";
+}
+
+function opaqueAccountSuffix(id: string): string {
+  // Production account ids are app-owned UUIDs. FNV-1a is only a fallback
+  // when the Rust bridge did not provide its SHA-256 label; no provider id,
+  // email, or filesystem path is exposed by this path.
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < id.length; index += 1) {
+    hash ^= id.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}

apps/desktop-tauri/src/hooks/useFormattedResetTime.test.tsx

@@ -3,6 +3,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { LocaleProvider } from "../i18n/LocaleProvider";
 import { buildBundle } from "../test/localeHarness";
 import {
+  normalizeResetDescription,
   useFormattedResetTime,
   type ResetTimeFormatMode,
 } from "./useFormattedResetTime";
@@ -61,6 +62,22 @@ describe("useFormattedResetTime", () => {
     vi.useRealTimers();
   });
 
+  it.each([
+    ["Reset", "Resets"],
+    ["Resets", "Resets"],
+    ["Reset Jul 10 at 2:59am (Europe/Prague)", "Resets Jul 10 at 2:59am (Europe/Prague)"],
+    ["Reset in 11m", "Resets in 11m"],
+    ["Resets in 11m", "Resets in 11m"],
+    ["Reset at 23:30 (UTC)", "Resets at 23:30 (UTC)"],
+    ["  rEsEt In 2h 5m \n", "Resets in 2h 5m"],
+    ["Reset demain à 23:30", "Resets demain à 23:30"],
+    ["at 23:30 (UTC)", "Resets at 23:30 (UTC)"],
+    ["Resetting soon", "Resets Resetting soon"],
+    ["   \n\t", null],
+  ] as const)("normalizes reset description %j", (description, expected) => {
+    expect(normalizeResetDescription(description)).toBe(expected);
+  });
+
   it("returns a complete localized countdown in relative mode", async () => {
     const target = new Date("2024-06-01T03:42:00Z").toISOString();
     await mountWithLocale(
@@ -77,11 +94,19 @@ describe("useFormattedResetTime", () => {
     expect(screen.getByTestId("reset")).toHaveTextContent("Resets in 40m");
   });
 
-  it("leaves fallback text unlabelled in relative mode", async () => {
+  it("normalizes a fallback reset description in relative mode", async () => {
+    await mountWithLocale(
+      <Probe resetsAt={null} fallback="Reset in 3h" relative={true} />,
+    );
+    expect(screen.getByTestId("reset")).toHaveTextContent("Resets in 3h");
+  });
+
+  it("gives a parsed reset timestamp precedence over fallback wording", async () => {
+    const target = new Date("2024-06-01T03:42:00Z").toISOString();
     await mountWithLocale(
-      <Probe resetsAt={null} fallback="3h" relative={true} />,
+      <Probe resetsAt={target} fallback="Reset in 99h" relative={true} />,
     );
-    expect(screen.getByTestId("reset")).toHaveTextContent("3h");
+    expect(screen.getByTestId("reset")).toHaveTextContent("Resets in 3h 42m");
   });
 
   it("returns an absolute local time without the reset label", async () => {