v0.1.44 - harden JSONL cache edge cases

Author: EcomCJ

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "tally",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "private": true,
   "scripts": {
     "tauri": "tauri",

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "tally"
-version = "0.1.43"
+version = "0.1.44"
 edition = "2021"
 rust-version = "1.77"
 

src-tauri/Cargo.lock

@@ -51,6 +51,26 @@ struct FileSignature {
     local_ordinal: u32,
 }
 
+impl FileSignature {
+    fn new(local_now: chrono::DateTime<Local>) -> Self {
+        Self {
+            files: 0,
+            bytes: 0,
+            newest_mtime_ns: 0,
+            local_year: local_now.year(),
+            local_ordinal: local_now.ordinal(),
+        }
+    }
+
+    fn observe_file(&mut self, len: u64, modified: std::time::SystemTime) {
+        if let Ok(delta) = modified.duration_since(std::time::UNIX_EPOCH) {
+            self.newest_mtime_ns = self.newest_mtime_ns.max(delta.as_nanos());
+        }
+        self.files += 1;
+        self.bytes = self.bytes.saturating_add(len);
+    }
+}
+
 fn stats_cache() -> &'static Mutex<Option<(FileSignature, ClaudeStats)>> {
     static CACHE: OnceLock<Mutex<Option<(FileSignature, ClaudeStats)>>> = OnceLock::new();
     CACHE.get_or_init(|| Mutex::new(None))
@@ -117,13 +137,7 @@ pub(crate) fn collect_token_stats() -> Result<ClaudeStats> {
         .unwrap_or(now);
 
     let mut jsonl_files: Vec<(std::path::PathBuf, std::fs::Metadata)> = Vec::new();
-    let mut signature = FileSignature {
-        files: 0,
-        bytes: 0,
-        newest_mtime_ns: 0,
-        local_year: now_local.year(),
-        local_ordinal: now_local.ordinal(),
-    };
+    let mut signature = FileSignature::new(now_local);
 
     for entry in walk_roots
         .iter()
@@ -143,12 +157,10 @@ pub(crate) fn collect_token_stats() -> Result<ClaudeStats> {
             if mt < cutoff_30d {
                 continue;
             }
-            if let Ok(delta) = mtime.duration_since(std::time::UNIX_EPOCH) {
-                signature.newest_mtime_ns = signature.newest_mtime_ns.max(delta.as_nanos());
-            }
+            signature.observe_file(meta.len(), mtime);
+        } else {
+            signature.observe_file(meta.len(), std::time::UNIX_EPOCH);
         }
-        signature.files += 1;
-        signature.bytes = signature.bytes.saturating_add(meta.len());
         jsonl_files.push((path, meta));
     }
 
@@ -273,3 +285,53 @@ fn add(w: &mut TokenWindow, u: &ClaudeUsage) {
     w.cache_read += u.cache_read_input_tokens;
     w.cache_write += u.cache_creation_input_tokens;
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::TimeZone;
+
+    #[test]
+    fn file_signature_changes_when_jsonl_tree_changes() {
+        let day = Local.with_ymd_and_hms(2026, 5, 27, 8, 0, 0).unwrap();
+        let mut a = FileSignature::new(day);
+        a.observe_file(
+            100,
+            std::time::UNIX_EPOCH + std::time::Duration::from_secs(10),
+        );
+
+        let mut same = FileSignature::new(day);
+        same.observe_file(
+            100,
+            std::time::UNIX_EPOCH + std::time::Duration::from_secs(10),
+        );
+        assert_eq!(a, same);
+
+        let mut size_changed = FileSignature::new(day);
+        size_changed.observe_file(
+            101,
+            std::time::UNIX_EPOCH + std::time::Duration::from_secs(10),
+        );
+        assert_ne!(a, size_changed);
+
+        let mut mtime_changed = FileSignature::new(day);
+        mtime_changed.observe_file(
+            100,
+            std::time::UNIX_EPOCH + std::time::Duration::from_secs(11),
+        );
+        assert_ne!(a, mtime_changed);
+    }
+
+    #[test]
+    fn file_signature_changes_on_local_day_rollover() {
+        let before_midnight = Local.with_ymd_and_hms(2026, 5, 27, 23, 59, 0).unwrap();
+        let after_midnight = Local.with_ymd_and_hms(2026, 5, 28, 0, 1, 0).unwrap();
+        let mut a = FileSignature::new(before_midnight);
+        let mut b = FileSignature::new(after_midnight);
+        let mtime = std::time::UNIX_EPOCH + std::time::Duration::from_secs(10);
+        a.observe_file(100, mtime);
+        b.observe_file(100, mtime);
+
+        assert_ne!(a, b);
+    }
+}

src-tauri/Cargo.toml

@@ -551,6 +551,26 @@ struct FileSignature {
     local_ordinal: u32,
 }
 
+impl FileSignature {
+    fn new(local_now: chrono::DateTime<Local>) -> Self {
+        Self {
+            files: 0,
+            bytes: 0,
+            newest_mtime_ns: 0,
+            local_year: local_now.year(),
+            local_ordinal: local_now.ordinal(),
+        }
+    }
+
+    fn observe_file(&mut self, len: u64, modified: std::time::SystemTime) {
+        if let Ok(delta) = modified.duration_since(std::time::UNIX_EPOCH) {
+            self.newest_mtime_ns = self.newest_mtime_ns.max(delta.as_nanos());
+        }
+        self.files += 1;
+        self.bytes = self.bytes.saturating_add(len);
+    }
+}
+
 #[derive(Debug, Default, Clone)]
 struct LocalTokenStats {
     today: CodexPeriodStats,
@@ -630,13 +650,7 @@ pub fn collect() -> Result<CodexStats> {
     }
 
     let mut jsonl_files: Vec<(PathBuf, std::fs::Metadata)> = Vec::new();
-    let mut signature = FileSignature {
-        files: 0,
-        bytes: 0,
-        newest_mtime_ns: 0,
-        local_year: now_local.year(),
-        local_ordinal: now_local.ordinal(),
-    };
+    let mut signature = FileSignature::new(now_local);
     for entry in roots
         .iter()
         .flat_map(|r| WalkDir::new(r).into_iter())
@@ -655,12 +669,10 @@ pub fn collect() -> Result<CodexStats> {
             if mt < cutoff_30d {
                 continue;
             }
-            if let Ok(delta) = mtime.duration_since(std::time::UNIX_EPOCH) {
-                signature.newest_mtime_ns = signature.newest_mtime_ns.max(delta.as_nanos());
-            }
+            signature.observe_file(meta.len(), mtime);
+        } else {
+            signature.observe_file(meta.len(), std::time::UNIX_EPOCH);
         }
-        signature.files += 1;
-        signature.bytes = signature.bytes.saturating_add(meta.len());
         jsonl_files.push((path, meta));
     }
 
@@ -795,3 +807,56 @@ fn apply_local_token_stats(stats: &mut CodexStats, local: &LocalTokenStats) {
     stats.d30 = local.d30.clone();
     stats.mtd = local.mtd.clone();
 }
+
+#[cfg(test)]
+mod local_cache_tests {
+    use super::*;
+    use chrono::TimeZone;
+
+    #[test]
+    fn file_signature_changes_on_file_or_day_changes() {
+        let day = Local.with_ymd_and_hms(2026, 5, 27, 8, 0, 0).unwrap();
+        let next_day = Local.with_ymd_and_hms(2026, 5, 28, 8, 0, 0).unwrap();
+        let mtime = std::time::UNIX_EPOCH + std::time::Duration::from_secs(10);
+
+        let mut base = FileSignature::new(day);
+        base.observe_file(42, mtime);
+
+        let mut same = FileSignature::new(day);
+        same.observe_file(42, mtime);
+        assert_eq!(base, same);
+
+        let mut size_changed = FileSignature::new(day);
+        size_changed.observe_file(43, mtime);
+        assert_ne!(base, size_changed);
+
+        let mut day_changed = FileSignature::new(next_day);
+        day_changed.observe_file(42, mtime);
+        assert_ne!(base, day_changed);
+    }
+
+    #[test]
+    fn cached_local_token_stats_do_not_overwrite_live_limit_fields() {
+        let mut stats = CodexStats {
+            plan_label: "PRO 5x".to_string(),
+            plan_label_raw: "prolite".to_string(),
+            last_event_at: Some(Utc::now()),
+            ..Default::default()
+        };
+        stats.rate_limits.primary_used_percent = 12.0;
+        let local = LocalTokenStats {
+            today: CodexPeriodStats {
+                requests: 7,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        apply_local_token_stats(&mut stats, &local);
+
+        assert_eq!(stats.today.requests, 7);
+        assert_eq!(stats.rate_limits.primary_used_percent, 12.0);
+        assert_eq!(stats.plan_label_raw, "prolite");
+        assert!(stats.last_event_at.is_some());
+    }
+}

src-tauri/src/claude/jsonl.rs

@@ -330,4 +330,56 @@ mod tests {
         assert_eq!(usage.requests, 5);
         assert_eq!(usage.api_equiv, 12.50);
     }
+
+    #[test]
+    fn daily_upsert_reports_no_change_for_lower_or_equal_usage() {
+        let existing = DailyUsage {
+            tokens: DailyTokens {
+                input: 100,
+                output: 50,
+                cache_read: 20,
+                cache_write: 10,
+                cached_input: 30,
+                reasoning: 40,
+            },
+            requests: 5,
+            api_equiv: 12.50,
+        };
+        let incoming = DailyUsage {
+            tokens: DailyTokens {
+                input: 90,
+                output: 50,
+                cache_read: 20,
+                cache_write: 10,
+                cached_input: 30,
+                reasoning: 40,
+            },
+            requests: 5,
+            api_equiv: 12.50,
+        };
+        let mut slot = Some(existing.clone());
+
+        assert!(!upsert_vendor_day(&mut slot, &incoming));
+        assert_eq!(slot.unwrap().tokens.input, existing.tokens.input);
+    }
+
+    #[test]
+    fn daily_upsert_reports_change_for_growth_or_new_day() {
+        let incoming = DailyUsage {
+            requests: 1,
+            api_equiv: 1.0,
+            ..Default::default()
+        };
+        let mut empty = None;
+        assert!(upsert_vendor_day(&mut empty, &incoming));
+
+        let mut existing = Some(incoming.clone());
+        let larger = DailyUsage {
+            requests: 2,
+            api_equiv: 3.0,
+            ..Default::default()
+        };
+        assert!(upsert_vendor_day(&mut existing, &larger));
+        assert_eq!(existing.unwrap().requests, 2);
+    }
 }

src-tauri/src/codex.rs

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "TALLY - Ai Usage Monitor",
-  "version": "0.1.43",
+  "version": "0.1.44",
   "identifier": "com.cjmedia.tally",
   "build": {
     "frontendDist": "../src"