feat: refresh on focus

src/components/TestAutoBackup.tsx

···
-import { useState } from "react";
-import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { TestAutoBackupScheduler } from "@/lib/testAutoBackup";
-import { useAuth } from "@/Auth";
-import { settingsManager } from "@/lib/settings";
-import { toast } from "sonner";
-
-export function TestAutoBackup() {
-  const [isRunning, setIsRunning] = useState(false);
-  const [scheduler, setScheduler] = useState<TestAutoBackupScheduler | null>(
-    null
-  );
-  const [lastBackupDate, setLastBackupDate] = useState<string | undefined>();
-  const [frequency, setFrequency] = useState<"daily" | "weekly">("daily");
-  const { agent } = useAuth();
-
-  const startTest = () => {
-    if (!agent) {
-      toast("No agent available");
-      return;
-    }
-
-    const testScheduler = new TestAutoBackupScheduler(agent);
-    testScheduler.start();
-    setScheduler(testScheduler);
-    setIsRunning(true);
-    toast("🧪 Test auto-backup started! Check console for logs.");
-  };
-
-  const stopTest = () => {
-    if (scheduler) {
-      scheduler.stop();
-      setScheduler(null);
-      setIsRunning(false);
-      toast("🧪 Test auto-backup stopped");
-    }
-  };
-
-  const checkStatus = async () => {
-    const lastBackup = await settingsManager.getLastBackupDate();
-    const freq = await settingsManager.getBackupFrequency();
-    setLastBackupDate(lastBackup);
-    setFrequency(freq);
-  };
-
-  const clearLastBackup = async () => {
-    await settingsManager.updateSettings({ lastBackupDate: undefined });
-    await checkStatus();
-    toast("🧪 Cleared last backup date");
-  };
-
-  return (
-    <Card className="bg-card border-white/10 mb-4">
-      <CardHeader>
-        <CardTitle className="text-white">🧪 Test Auto-Backup</CardTitle>
-      </CardHeader>
-      <CardContent className="space-y-4">
-        <div className="space-y-2">
-          <p className="text-white/80 text-sm">
-            Current frequency: <span className="font-bold">{frequency}</span>
-          </p>
-          <p className="text-white/80 text-sm">
-            Last backup:{" "}
-            {lastBackupDate
-              ? new Date(lastBackupDate).toLocaleString()
-              : "None"}
-          </p>
-        </div>
-
-        <div className="flex gap-2">
-          <Button
-            onClick={startTest}
-            disabled={isRunning}
-            variant="outline"
-            className="cursor-pointer"
-          >
-            Start Test (30s intervals)
-          </Button>
-
-          <Button
-            onClick={stopTest}
-            disabled={!isRunning}
-            variant="outline"
-            className="cursor-pointer"
-          >
-            Stop Test
-          </Button>
-
-          <Button
-            onClick={checkStatus}
-            variant="outline"
-            className="cursor-pointer"
-          >
-            Check Status
-          </Button>
-
-          <Button
-            onClick={clearLastBackup}
-            variant="outline"
-            className="cursor-pointer"
-          >
-            Clear Last Backup
-          </Button>
-        </div>
-
-        <div className="text-xs text-white/60">
-          <p>• Test uses 1 minute for "daily" and 2 minutes for "weekly"</p>
-          <p>• Check browser console for detailed logs</p>
-          <p>• Change frequency in Settings to test different intervals</p>
-        </div>
-      </CardContent>
-    </Card>
-  );
-}

src/lib/testAutoBackup.ts

···
-import { Agent } from "@atproto/api";
-import { BackupAgent } from "./backup";
-import { settingsManager } from "./settings";
-
-export class TestAutoBackupScheduler {
-  private agent: Agent;
-  private intervalId: NodeJS.Timeout | null = null;
-  private isRunning = false;
-
-  constructor(agent: Agent) {
-    this.agent = agent;
-  }
-
-  start(): void {
-    if (this.isRunning) return;
-
-    this.isRunning = true;
-    // Check every 30 seconds for testing (instead of 1 hour)
-    this.intervalId = setInterval(() => {
-      this.checkAndPerformBackup();
-    }, 30 * 1000); // 30 seconds
-
-    // Also check immediately when starting
-    this.checkAndPerformBackup();
-  }
-
-  stop(): void {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-    this.isRunning = false;
-  }
-
-  private async checkAndPerformBackup(): Promise<void> {
-    try {
-      const shouldBackup = await this.shouldPerformBackup();
-
-      if (shouldBackup) {
-        console.log("🧪 TEST: Automatic backup due, starting backup...");
-        await this.performBackup();
-      } else {
-        console.log("🧪 TEST: No backup needed yet");
-      }
-    } catch (error) {
-      console.error("Error in automatic backup check:", error);
-    }
-  }
-
-  private async shouldPerformBackup(): Promise<boolean> {
-    try {
-      const lastBackupDate = await settingsManager.getLastBackupDate();
-      const frequency = await settingsManager.getBackupFrequency();
-
-      if (!lastBackupDate) {
-        console.log("🧪 TEST: No previous backup, should do one");
-        return true;
-      }
-
-      const lastBackup = new Date(lastBackupDate);
-      const now = new Date();
-      const timeDiff = now.getTime() - lastBackup.getTime();
-
-      // For testing: use shorter intervals
-      if (frequency === "daily") {
-        // Test with 1 minute instead of 24 hours
-        const oneMinute = 60 * 1000;
-        const shouldBackup = timeDiff >= oneMinute;
-        console.log(
-          `🧪 TEST: Daily backup check - ${timeDiff}ms since last backup, need ${oneMinute}ms`
-        );
-        return shouldBackup;
-      } else if (frequency === "weekly") {
-        // Test with 2 minutes instead of 7 days
-        const twoMinutes = 2 * 60 * 1000;
-        const shouldBackup = timeDiff >= twoMinutes;
-        console.log(
-          `🧪 TEST: Weekly backup check - ${timeDiff}ms since last backup, need ${twoMinutes}ms`
-        );
-        return shouldBackup;
-      }
-
-      return false;
-    } catch (error) {
-      console.error("Error checking if backup is due:", error);
-      return false;
-    }
-  }
-
-  private async performBackup(): Promise<void> {
-    try {
-      console.log("🧪 TEST: Starting automatic backup...");
-      const manager = new BackupAgent(this.agent);
-      await manager.startBackup();
-
-      // Update the last backup date
-      await settingsManager.setLastBackupDate(new Date().toISOString());
-
-      console.log("🧪 TEST: Automatic backup completed successfully");
-    } catch (error) {
-      console.error("🧪 TEST: Automatic backup failed:", error);
-    }
-  }
-}

src/routes/Home.tsx

···
   DialogTitle,
   DialogTrigger,
 } from "@/components/ui/dialog";
+import { getCurrentWindow } from "@tauri-apps/api/window";
 
 export function Home({
   profile,
···
   >({});
   const { agent } = useAuth();
   const contentRefs = useRef<Record<string, HTMLDivElement | null>>({});
+  const appWindow = getCurrentWindow();
 
-  const loadBackups = async () => {
+  const loadBackups = async (silent: boolean = false) => {
     if (agent == null) {
       return;
     }
-    setIsLoading(true);
+    if (!silent) setIsLoading(true);
     try {
       const manager = new BackupAgent(agent);
       const backupsList = await manager.getBackups();
···
       toast(err.toString());
       console.error(err);
     } finally {
-      setIsLoading(false);
+      if (!silent) setIsLoading(false);
     }
   };
 
   useEffect(() => {
     loadBackups();
-  }, [agent, refreshTrigger]); // Add refreshTrigger to dependencies
+    const unlistenVisible = appWindow.listen("tauri://focus", () => {
+      loadBackups(true);
+    });
+
+    return () => {
+      // Cleanup listeners
+      unlistenVisible.then((unlisten) => unlisten());
+    };
+  }, []);
 
   //@ts-expect-error
   const units: Record<Intl.RelativeTimeFormatUnit, number> = {