fix: recheck updates while app stays open

Author: itvincent-git

src/App.test.tsx

@@ -3,7 +3,7 @@
 import { act, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { StrictMode } from "react";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import App from "./App";
 import i18n from "./i18n";
 import tauriConfig from "../src-tauri/tauri.conf.json";
@@ -181,6 +181,10 @@ function mockLoadedDashboard() {
 }
 
 describe("App", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
   beforeEach(() => {
     localStorage.clear();
     invokeMock.mockReset();
@@ -231,6 +235,39 @@ describe("App", () => {
     expect(screen.queryByRole("button", { name: "Reset cache" })).not.toBeInTheDocument();
   });
 
+  it("checks for updates again after the app stays open for 24 hours", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-08-03T00:00:00.000Z"));
+    localStorage.setItem("last_update_check_time", Date.now().toString());
+    localStorage.setItem("last_update_check_result", JSON.stringify({
+      hasUpdate: false,
+      currentVersion: tauriConfig.version,
+      latestVersion: tauriConfig.version,
+      latestTag: `v${tauriConfig.version}`,
+      releaseName: null,
+      releaseNotes: null,
+      releaseUrl: "",
+    }));
+    mockLoadedDashboard();
+
+    render(<App />);
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(0);
+    });
+    expect(invokeMock).not.toHaveBeenCalledWith("check_for_updates");
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(24 * 60 * 60_000 - 1);
+    });
+    expect(invokeMock).not.toHaveBeenCalledWith("check_for_updates");
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1);
+    });
+    expect(invokeMock).toHaveBeenCalledWith("check_for_updates");
+  });
+
   it("prevents the default page context menu", () => {
     invokeMock.mockImplementation(async (command: string, args?: { range?: string }) => {
       if (command === "fetch_overview" && args?.range === "30d") {

src/hooks/use-usage-dashboard.ts

@@ -50,6 +50,8 @@ function isNewerVersion(current: string, target: string): boolean {
 }
 
 const AUTO_RESCAN_MS = 5 * 60_000;
+const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60_000;
+const UPDATE_CHECK_RETRY_MS = 60 * 60_000;
 const CODEX_QUOTA_FORECAST_URL = "https://www.willcodexquotareset.com/";
 const CHATGPT_USAGE_URL = "https://chatgpt.com/#settings/Usage";
 
@@ -249,6 +251,7 @@ export function useUsageDashboard() {
   const lastLimitsFetchTimeRef = useRef<number>(0);
   const lastAutoScanTimeRef = useRef<number>(0);
   const scanInFlightRef = useRef<Promise<void> | null>(null);
+  const updateCheckInFlightRef = useRef<Promise<void> | null>(null);
 
   const loadOverview = useEffectEvent(async (nextRange: RangeKey) => {
     const data = await fetchOverview(nextRange);
@@ -363,7 +366,7 @@ export function useUsageDashboard() {
     }
   });
 
-  const runBackgroundUpdateCheck = useEffectEvent(async () => {
+  const performBackgroundUpdateCheck = useEffectEvent(async () => {
     let cachedInfo: UpdateCheckResponse | null = null;
     try {
       const now = Date.now();
@@ -473,6 +476,20 @@ export function useUsageDashboard() {
     }
   });
 
+  const runBackgroundUpdateCheck = useEffectEvent(async () => {
+    if (!updateCheckInFlightRef.current) {
+      const checkPromise = performBackgroundUpdateCheck();
+      updateCheckInFlightRef.current = checkPromise;
+      void checkPromise.finally(() => {
+        if (updateCheckInFlightRef.current === checkPromise) {
+          updateCheckInFlightRef.current = null;
+        }
+      });
+    }
+
+    await updateCheckInFlightRef.current;
+  });
+
   const bootstrap = useEffectEvent(async () => {
     if (hasBootstrappedRef.current) {
       return;
@@ -532,6 +549,47 @@ export function useUsageDashboard() {
     void bootstrap();
   }, [bootstrap]);
 
+  useEffect(() => {
+    if (!bootstrapped) return;
+
+    let cancelled = false;
+    let timer: number | null = null;
+
+    const readTimestamp = (key: string) => {
+      const value = Number(localStorage.getItem(key));
+      return Number.isFinite(value) && value > 0 ? value : null;
+    };
+
+    const scheduleNextCheck = () => {
+      const now = Date.now();
+      const lastSuccess = localStorage.getItem("last_update_check_result")
+        ? readTimestamp("last_update_check_time")
+        : null;
+      const lastFailure = readTimestamp("last_update_check_failed_time");
+      const nextCheckAt = Math.max(
+        lastSuccess ? lastSuccess + UPDATE_CHECK_INTERVAL_MS : now + UPDATE_CHECK_RETRY_MS,
+        lastFailure ? lastFailure + UPDATE_CHECK_RETRY_MS : now,
+      );
+
+      timer = window.setTimeout(() => {
+        void runBackgroundUpdateCheck().finally(() => {
+          if (!cancelled) {
+            scheduleNextCheck();
+          }
+        });
+      }, Math.max(0, nextCheckAt - now));
+    };
+
+    scheduleNextCheck();
+
+    return () => {
+      cancelled = true;
+      if (timer !== null) {
+        window.clearTimeout(timer);
+      }
+    };
+  }, [bootstrapped, runBackgroundUpdateCheck]);
+
   // Re-fetch usage when the page/window regains focus after being inactive ≥5 min.
   useEffect(() => {
     if (!bootstrapped) return;