ai_usagebar/
active.rs

1//! Active-vendor state file. Set by `--cycle-next` / `--cycle-prev` (which
2//! Waybar's `on-scroll-up`/`on-scroll-down` invoke), read by the widget on
3//! every tick. The TUI does NOT consult this — it has its own tab state.
4//!
5//! On-disk shape: a single line with the vendor slug (e.g. `openai`). Located
6//! at `<cache-dir>/active_vendor`.
7
8use std::fs;
9use std::path::{Path, PathBuf};
10use std::time::Duration;
11
12use crate::cache::{acquire_lock, atomic_write};
13use crate::error::{AppError, Result};
14use crate::vendor::VendorId;
15
16/// Much shorter than the vendors' fetch locks (15–45s): the critical section
17/// here is one small read plus a rename, so a wait this long already means a
18/// wedged holder — and a scroll event that blocks for seconds is worse than a
19/// dropped one.
20const LOCK_TIMEOUT: Duration = Duration::from_secs(5);
21
22fn state_dir() -> Result<PathBuf> {
23    let base = directories::BaseDirs::new()
24        .ok_or_else(|| AppError::Other("could not resolve XDG cache dir".into()))?;
25    Ok(base.cache_dir().join("ai-usagebar"))
26}
27
28fn state_path() -> Result<PathBuf> {
29    Ok(state_dir()?.join("active_vendor"))
30}
31
32/// Read the persisted active vendor, if any. `None` means "no override —
33/// callers fall back to [ui] primary or anthropic".
34pub fn read() -> Option<VendorId> {
35    read_from(&state_path().ok()?)
36}
37
38/// Read the persisted active vendor from an explicit path. The real-path
39/// [`read`] is a thin wrapper over this; tests use this directly with a
40/// `TempDir`-backed path so they never touch `~/.cache/ai-usagebar`.
41pub fn read_from(path: &Path) -> Option<VendorId> {
42    let raw = fs::read_to_string(path).ok()?;
43    parse_slug(raw.trim())
44}
45
46/// Persist `vendor` as the active one. Atomic.
47pub fn write(vendor: VendorId) -> Result<()> {
48    write_to(&state_path()?, vendor)
49}
50
51/// Persist `vendor` to an explicit path. Atomic. Test-friendly counterpart
52/// to [`write`] (mirrors [`crate::cache::Cache::at`] vs `for_vendor`).
53pub fn write_to(path: &Path, vendor: VendorId) -> Result<()> {
54    atomic_write(path, vendor.slug().as_bytes())
55}
56
57/// Cycle the active vendor by `delta` positions through `enabled` (which
58/// preserves canonical order). Wraps. If no state exists, starts at `start`
59/// (usually `[ui] primary` or anthropic).
60pub fn cycle(enabled: &[VendorId], start: VendorId, delta: i32) -> Result<VendorId> {
61    cycle_at(&state_path()?, enabled, start, delta)
62}
63
64/// The flock guarding a state file's read-modify-write, as a sibling of the
65/// state file itself (mirroring `Cache::lock_path`'s `.fetch.lock`).
66fn lock_path_for(state: &Path) -> PathBuf {
67    let mut p = state.as_os_str().to_os_string();
68    p.push(".lock");
69    PathBuf::from(p)
70}
71
72/// Cycle using an explicit state-file path. The real-path [`cycle`] is a thin
73/// wrapper over this; tests drive this with a `TempDir` path so the cycle +
74/// persistence logic is covered without reading or writing the real cache.
75pub fn cycle_at(
76    path: &Path,
77    enabled: &[VendorId],
78    start: VendorId,
79    delta: i32,
80) -> Result<VendorId> {
81    if enabled.is_empty() {
82        return Err(AppError::Other("no enabled vendors to cycle".into()));
83    }
84    // One flick of a scroll wheel fires several `--cycle-next` processes at
85    // once. An atomic *write* only guarantees no torn file — it does not stop
86    // two of them reading the same current vendor and both persisting the same
87    // next one, silently eating a step. The lock has to span read→compute→write.
88    let _lock = acquire_lock(&lock_path_for(path), LOCK_TIMEOUT)?;
89    let current = read_from(path)
90        .filter(|v| enabled.contains(v))
91        .unwrap_or(start);
92    let cur_idx = enabled.iter().position(|v| *v == current).unwrap_or(0);
93    let n = enabled.len() as i32;
94    let next_idx = ((cur_idx as i32 + delta).rem_euclid(n)) as usize;
95    let next = enabled[next_idx];
96    write_to(path, next)?;
97    Ok(next)
98}
99
100fn parse_slug(s: &str) -> Option<VendorId> {
101    match s {
102        "anthropic" => Some(VendorId::Anthropic),
103        "anthropic_api" => Some(VendorId::AnthropicApi),
104        "openai" => Some(VendorId::Openai),
105        "zai" => Some(VendorId::Zai),
106        "openrouter" => Some(VendorId::Openrouter),
107        "deepseek" => Some(VendorId::Deepseek),
108        "kimi" => Some(VendorId::Kimi),
109        "kilo" => Some(VendorId::Kilo),
110        "novita" => Some(VendorId::Novita),
111        "moonshot" => Some(VendorId::Moonshot),
112        "grok" => Some(VendorId::Grok),
113        "antigravity" => Some(VendorId::Antigravity),
114        "cursor" => Some(VendorId::Cursor),
115        _ => None,
116    }
117}
118
119#[cfg(test)]
120mod tests {
121    use super::*;
122    use tempfile::TempDir;
123
124    // Deliberately excludes Deepseek so the not-in-enabled-set fallback test
125    // below has a real vendor to persist that is outside this cycle set.
126    const CYCLE_SET: [VendorId; 4] = [
127        VendorId::Anthropic,
128        VendorId::Openai,
129        VendorId::Zai,
130        VendorId::Openrouter,
131    ];
132
133    /// One flick of a scroll wheel fires several `--cycle-next` processes at
134    /// once. Before the lock spanned the read-modify-write, two of them could
135    /// read the same current vendor and both persist the same next one, so N
136    /// events advanced fewer than N steps. With the lock held across the whole
137    /// operation, every cycle observes its predecessor's write.
138    #[test]
139    fn concurrent_cycles_do_not_lose_a_step() {
140        let td = TempDir::new().unwrap();
141        let path = td.path().join("active_vendor");
142        let start = VendorId::Anthropic;
143
144        // Four threads, each doing one +1 step, over a 4-vendor set: if no step
145        // is lost the value returns exactly to `start`.
146        const THREADS: usize = 4;
147        std::thread::scope(|s| {
148            for _ in 0..THREADS {
149                s.spawn(|| {
150                    let _ = cycle_at(&path, &CYCLE_SET, start, 1);
151                });
152            }
153        });
154
155        let landed = read_from(&path).expect("a vendor must have been persisted");
156        assert_eq!(
157            landed,
158            start,
159            "{THREADS} single steps over {} vendors must return to the start; \
160             landing on {landed:?} means a step was lost to a race",
161            CYCLE_SET.len()
162        );
163    }
164
165    #[test]
166    fn parse_slug_round_trip() {
167        for id in VendorId::all() {
168            assert_eq!(parse_slug(id.slug()), Some(*id));
169        }
170    }
171
172    #[test]
173    fn parse_slug_unknown_returns_none() {
174        assert!(parse_slug("not-a-vendor").is_none());
175        assert!(parse_slug("").is_none());
176    }
177
178    #[test]
179    fn read_from_missing_or_garbage_returns_none() {
180        let td = TempDir::new().unwrap();
181        // Missing file → None.
182        assert!(read_from(&td.path().join("active_vendor")).is_none());
183        // Round-trip a real slug.
184        let path = td.path().join("active_vendor");
185        write_to(&path, VendorId::Zai).unwrap();
186        assert_eq!(read_from(&path), Some(VendorId::Zai));
187        // Garbage content → None (not a known slug).
188        fs::write(&path, "not-a-vendor").unwrap();
189        assert!(read_from(&path).is_none());
190    }
191
192    #[test]
193    fn cycle_at_persists_state_across_calls() {
194        let td = TempDir::new().unwrap();
195        let path = td.path().join("active_vendor");
196
197        // No state yet → starts at `start`, steps forward to Openai.
198        let v = cycle_at(&path, &CYCLE_SET, VendorId::Anthropic, 1).unwrap();
199        assert_eq!(v, VendorId::Openai);
200        assert_eq!(read_from(&path), Some(VendorId::Openai));
201
202        // Next forward step reads the persisted Openai → Zai.
203        let v = cycle_at(&path, &CYCLE_SET, VendorId::Anthropic, 1).unwrap();
204        assert_eq!(v, VendorId::Zai);
205        assert_eq!(read_from(&path), Some(VendorId::Zai));
206    }
207
208    #[test]
209    fn cycle_at_wraps_forward_and_backward() {
210        let td = TempDir::new().unwrap();
211        let path = td.path().join("active_vendor");
212        write_to(&path, VendorId::Anthropic).unwrap();
213
214        // backward from Anthropic wraps to Openrouter
215        assert_eq!(
216            cycle_at(&path, &CYCLE_SET, VendorId::Anthropic, -1).unwrap(),
217            VendorId::Openrouter
218        );
219        // forward from Openrouter wraps back to Anthropic
220        assert_eq!(
221            cycle_at(&path, &CYCLE_SET, VendorId::Anthropic, 1).unwrap(),
222            VendorId::Anthropic
223        );
224    }
225
226    #[test]
227    fn cycle_at_ignores_persisted_vendor_not_in_enabled_set() {
228        let td = TempDir::new().unwrap();
229        let path = td.path().join("active_vendor");
230        // Persist a vendor that isn't in the enabled set → fall back to `start`.
231        write_to(&path, VendorId::Deepseek).unwrap();
232        let enabled = [VendorId::Anthropic, VendorId::Openai];
233        // start=Openai (idx 1), +1 wraps to idx 0 = Anthropic.
234        let v = cycle_at(&path, &enabled, VendorId::Openai, 1).unwrap();
235        assert_eq!(v, VendorId::Anthropic);
236    }
237
238    #[test]
239    fn cycle_at_errors_on_empty_enabled() {
240        let td = TempDir::new().unwrap();
241        let path = td.path().join("active_vendor");
242        let res = cycle_at(&path, &[], VendorId::Anthropic, 1);
243        assert!(matches!(res, Err(AppError::Other(_))));
244    }
245}
ai_usagebar/active.rs

ai_usagebar/
active.rs
