design polish for tray and widget

Author: Topurrra

src-tauri/Cargo.lock

@@ -28,6 +28,7 @@
     "opener:default",
     "opener:allow-open-url",
     "notification:default",
-    "log:default"
+    "log:default",
+    "main-commands"
   ]
 }

src-tauri/capabilities/default.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "widget",
+  "description": "Least-privilege permissions for the AgentsBar widget window.",
+  "windows": ["widget"],
+  "permissions": [
+    "core:window:allow-start-dragging",
+    "core:event:allow-listen",
+    "core:event:allow-unlisten",
+    "widget-commands"
+  ]
+}

src-tauri/capabilities/widget.json

@@ -0,0 +1,27 @@
+[[permission]]
+identifier = "main-commands"
+description = "Commands used by the primary AgentsBar window."
+commands.allow = [
+  "list_providers",
+  "get_snapshots",
+  "refresh_all",
+  "refresh_provider",
+  "get_config",
+  "get_cadence_secs",
+  "set_config",
+  "set_api_key",
+  "quit_app",
+  "toggle_widget",
+  "list_browsers",
+  "set_cookie_source",
+  "set_cookie_header",
+  "get_history",
+  "get_health",
+  "export_diagnostics",
+  "clear_cookie_cache",
+]
+
+[[permission]]
+identifier = "widget-commands"
+description = "Usage data plus the widget's own order and hide actions."
+commands.allow = ["get_config", "list_providers", "get_snapshots", "set_provider_order", "toggle_widget"]

src-tauri/permissions/commands.toml

@@ -2,9 +2,10 @@ use std::collections::HashMap;
 
 use chrono::{DateTime, Utc};
 use serde::Serialize;
-use tauri::{AppHandle, Manager, State};
+use tauri::{AppHandle, Emitter, Manager, State};
 
 use crate::config::{Config, COOKIE_BROWSERS, COOKIE_SOURCES};
+use crate::health::HealthPoint;
 use crate::history::Sample;
 use crate::providers::{all_providers, AuthKind, ProviderInfo, UsageSnapshot, UsageWindow};
 use crate::state::{AppState, DisplaySnapshot};
@@ -61,6 +62,24 @@ pub async fn get_config(state: State<'_, AppState>) -> Result<Config, String> {
     Ok(state.config.read().await.redacted())
 }
 
+#[tauri::command]
+pub async fn set_provider_order(app: AppHandle, order: Vec<String>) -> Result<Vec<String>, String> {
+    let order = {
+        let state = app.state::<AppState>();
+        let mut config = state.config.write().await;
+        let mut next = config.clone();
+        next.provider_order = order;
+        next.normalize();
+        next.save().map_err(|e| e.to_string())?;
+        let order = next.provider_order.clone();
+        *config = next;
+        order
+    };
+    app.emit("provider-order-updated", &order)
+        .map_err(|e| e.to_string())?;
+    Ok(order)
+}
+
 /// Row 20 and row 24. The longest gap the ACTIVE cadence policy can leave between two
 /// batches, in seconds, for the frontend's staleness threshold.
 ///
@@ -125,6 +144,11 @@ pub fn quit_app(app: AppHandle) {
     app.exit(0);
 }
 
+#[tauri::command]
+pub fn toggle_widget(app: AppHandle) {
+    crate::tray::toggle_widget(&app);
+}
+
 // ------------------------------------------------------------------ cookies
 
 #[derive(Debug, Serialize)]
@@ -234,6 +258,13 @@ pub async fn get_history(
     Ok(state.history.read().await.series().clone())
 }
 
+#[tauri::command]
+pub async fn get_health(
+    state: State<'_, AppState>,
+) -> Result<HashMap<String, Vec<HealthPoint>>, String> {
+    Ok(state.health.read().await.series().clone())
+}
+
 // ------------------------------------------------------------------ diagnostics
 
 /// Row 27. Drop the memoized cookie scans, so the next fetch re-reads the browser.

src-tauri/src/commands.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};
 
 use base64::Engine as _;
@@ -134,21 +134,55 @@ pub struct Config {
     #[serde(default)]
     pub refresh_adaptive: bool,
     pub pinned_provider: Option<String>,
+    /// User's explicit provider order. An empty list uses the live usage ranking.
+    #[serde(default)]
+    pub provider_order: Vec<String>,
     pub providers: HashMap<String, ProviderConfig>,
     pub launch_at_startup: bool,
     pub theme: String,
     #[serde(default = "default_true")]
     pub notify_on_exhaustion: bool,
+    /// Advisor. Notify when a provider's remaining quota first drops to or below this
+    /// percentage. `None`, the default, is OFF: the advisor is opt-in, and a config.json
+    /// written before the field existed has no key, which reads as `None`, so an existing
+    /// install keeps its silence.
+    #[serde(default)]
+    pub alert_below_percent: Option<u8>,
+    /// Advisor. Quiet hours as local hours of the day, 0-23. Alert toasts are suppressed
+    /// inside `[start, end)` when BOTH ends are set; either one `None` means no quiet
+    /// hours. A start after the end wraps midnight (22 to 7 is quiet from 10pm to 7am).
+    #[serde(default)]
+    pub alert_quiet_start: Option<u8>,
+    #[serde(default)]
+    pub alert_quiet_end: Option<u8>,
     /// Optional HTTP(S) proxy all provider requests are routed through, for corporate
     /// networks that egress via one. `None` (the default) is a direct connection.
     #[serde(default)]
     pub proxy_url: Option<String>,
+    /// Last screen position of the desktop widget, so it reopens where it was dragged.
+    /// `None` until the widget has been placed at least once.
+    #[serde(default)]
+    pub widget_x: Option<i32>,
+    #[serde(default)]
+    pub widget_y: Option<i32>,
 }
 
 fn default_true() -> bool {
     true
 }
 
+/// Advisor. `[start, end)` over the hours of a day, wrapping midnight when the start is
+/// after the end. Equal ends are the empty window, which is never quiet: the UI sets
+/// both selects deliberately, and a hand edited file landing both on the same hour must
+/// read as "off", not as "always quiet".
+fn in_quiet_window(start: u8, end: u8, hour: u8) -> bool {
+    if start <= end {
+        (start..end).contains(&hour)
+    } else {
+        hour >= start || hour < end
+    }
+}
+
 impl Default for Config {
     fn default() -> Self {
         let providers = crate::providers::all_providers()
@@ -159,11 +193,17 @@ impl Default for Config {
             refresh_minutes: 5,
             refresh_adaptive: true,
             pinned_provider: None,
+            provider_order: vec![],
             providers,
             launch_at_startup: false,
             theme: "auto".to_string(),
             notify_on_exhaustion: true,
+            alert_below_percent: None,
+            alert_quiet_start: None,
+            alert_quiet_end: None,
             proxy_url: None,
+            widget_x: None,
+            widget_y: None,
         }
     }
 }
@@ -218,12 +258,24 @@ impl Config {
     /// The upper bound keeps `refresh_minutes * 60` from overflowing a u64 duration.
     pub fn normalize(&mut self) {
         self.refresh_minutes = self.refresh_minutes.clamp(1, 1440);
+        // Advisor values come from a hand editable file: clamp them the way
+        // `refresh_minutes` is clamped, instead of trusting them.
+        self.alert_below_percent = self.alert_below_percent.map(|p| p.min(100));
+        self.alert_quiet_start = self.alert_quiet_start.map(|h| h.min(23));
+        self.alert_quiet_end = self.alert_quiet_end.map(|h| h.min(23));
         // A blank or whitespace proxy is no proxy at all.
         self.proxy_url = self
             .proxy_url
             .take()
             .map(|p| p.trim().to_string())
             .filter(|p| !p.is_empty());
+        let known = crate::providers::all_providers()
+            .iter()
+            .map(|provider| provider.id())
+            .collect::<HashSet<_>>();
+        let mut seen = HashSet::new();
+        self.provider_order
+            .retain(|id| known.contains(id.as_str()) && seen.insert(id.clone()));
         for provider in self.providers.values_mut() {
             provider.unwrap_secrets();
             // An unknown source would silently disable a provider, so fall back to auto.
@@ -304,6 +356,17 @@ impl Config {
         self.providers.get(id).is_some_and(|p| p.enabled)
     }
 
+    /// Advisor. Whether alert toasts are suppressed right now. Only active when both
+    /// quiet hour ends are set; the window is `[start, end)` on the LOCAL clock, because
+    /// quiet hours are a sleep schedule, not a UTC interval.
+    pub fn quiet_now(&self) -> bool {
+        use chrono::Timelike;
+        let (Some(start), Some(end)) = (self.alert_quiet_start, self.alert_quiet_end) else {
+            return false;
+        };
+        in_quiet_window(start, end, chrono::Local::now().hour() as u8)
+    }
+
     /// Always one of [`COOKIE_SOURCES`]; providers absent from the file default to auto.
     pub fn cookie_source(&self, id: &str) -> &str {
         self.providers
@@ -640,6 +703,17 @@ mod tests {
         assert!(again.is_enabled("openrouter"));
     }
 
+    #[test]
+    fn provider_order_only_keeps_known_ids_once() {
+        let cfg =
+            Config::parse(r#"{"provider_order":["claude","not-a-provider","claude","codex"]}"#);
+        let value = serde_json::to_value(cfg).unwrap();
+        assert_eq!(
+            value["provider_order"],
+            serde_json::json!(["claude", "codex"])
+        );
+    }
+
     /// Row 24, "fresh installs only". The FIELD level `#[serde(default)]` on
     /// `refresh_adaptive` is the whole migration: delete it and the container default fills
     /// the missing key from `Config::default()`, which is `true`, and every wave 3 install
@@ -798,4 +872,63 @@ mod tests {
         assert_eq!(cfg.cookie_browser("cursor"), Some("edge"));
         assert_eq!(cfg.cookie_header("cursor"), Some("a=1"));
     }
+
+    // ----------------------------------------------------------------------- advisor
+
+    /// The advisor is opt-in: a config written before these keys existed reads them as
+    /// absent and stays silent, and a hand edited file cannot push a value past its
+    /// meaning (a threshold above 100, an hour above 23).
+    #[test]
+    fn the_advisor_defaults_to_off_and_clamps_hand_edited_values() {
+        let cfg = Config::parse(r#"{"refresh_minutes":7}"#);
+        assert_eq!(cfg.alert_below_percent, None);
+        assert_eq!(cfg.alert_quiet_start, None);
+        assert_eq!(cfg.alert_quiet_end, None);
+        assert!(!cfg.quiet_now(), "no ends set is never quiet");
+
+        let cfg = Config::parse(
+            r#"{"alert_below_percent":250,"alert_quiet_start":99,"alert_quiet_end":24}"#,
+        );
+        assert_eq!(cfg.alert_below_percent, Some(100));
+        assert_eq!(cfg.alert_quiet_start, Some(23));
+        assert_eq!(cfg.alert_quiet_end, Some(23));
+
+        // Only one end set is no quiet hours at all, whatever the hour is.
+        let start_only = Config {
+            alert_quiet_start: Some(0),
+            ..Config::default()
+        };
+        assert!(!start_only.quiet_now());
+        let end_only = Config {
+            alert_quiet_end: Some(23),
+            ..Config::default()
+        };
+        assert!(!end_only.quiet_now());
+    }
+
+    /// Quiet hours are `[start, end)`: the end is exclusive, a wrapping window covers
+    /// both sides of midnight, and equal ends are the empty window, not a 24 hour one.
+    #[test]
+    fn quiet_hours_wrap_midnight_and_exclude_the_end() {
+        // A same-day window, 9 until 17.
+        for hour in 9u8..17 {
+            assert!(in_quiet_window(9, 17, hour), "{hour} is inside 9-17");
+        }
+        for hour in [0u8, 8, 17, 23] {
+            assert!(!in_quiet_window(9, 17, hour), "{hour} is outside 9-17");
+        }
+
+        // 22 until 7 wraps midnight.
+        for hour in [22u8, 23, 0, 1, 6] {
+            assert!(in_quiet_window(22, 7, hour), "{hour} is inside 22-7");
+        }
+        for hour in [7u8, 12, 21] {
+            assert!(!in_quiet_window(22, 7, hour), "{hour} is outside 22-7");
+        }
+
+        // Equal ends are the empty window: never quiet.
+        for hour in 0u8..24 {
+            assert!(!in_quiet_window(5, 5, hour));
+        }
+    }
 }