feat: auto backups

bun.lock

···
         "@tauri-apps/plugin-deep-link": "~2",
         "@tauri-apps/plugin-fs": "~2",
         "@tauri-apps/plugin-opener": "^2",
+        "@tauri-apps/plugin-process": "~2",
+        "@tauri-apps/plugin-shell": "~2",
         "@tauri-apps/plugin-store": "~2",
         "@tauri-apps/plugin-updater": "~2",
+        "@tauri-apps/plugin-websocket": "~2",
         "antd": "^5.26.4",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
···
 
     "@tauri-apps/plugin-opener": ["@tauri-apps/plugin-opener@2.4.0", "", { "dependencies": { "@tauri-apps/api": "^2.6.0" } }, "sha512-43VyN8JJtvKWJY72WI/KNZszTpDpzHULFxQs0CJBIYUdCRowQ6Q1feWTDb979N7nldqSuDOaBupZ6wz2nvuWwQ=="],
 
+    "@tauri-apps/plugin-process": ["@tauri-apps/plugin-process@2.3.0", "", { "dependencies": { "@tauri-apps/api": "^2.6.0" } }, "sha512-0DNj6u+9csODiV4seSxxRbnLpeGYdojlcctCuLOCgpH9X3+ckVZIEj6H7tRQ7zqWr7kSTEWnrxtAdBb0FbtrmQ=="],
+
+    "@tauri-apps/plugin-shell": ["@tauri-apps/plugin-shell@2.3.0", "", { "dependencies": { "@tauri-apps/api": "^2.6.0" } }, "sha512-6GIRxO2z64uxPX4CCTuhQzefvCC0ew7HjdBhMALiGw74vFBDY95VWueAHOHgNOMV4UOUAFupyidN9YulTe5xlA=="],
+
     "@tauri-apps/plugin-store": ["@tauri-apps/plugin-store@2.3.0", "", { "dependencies": { "@tauri-apps/api": "^2.6.0" } }, "sha512-mre8er0nXPhyEWQzWCpUd+UnEoBQYcoA5JYlwpwOV9wcxKqlXTGfminpKsE37ic8NUb2BIZqf0QQ9/U3ib2+/A=="],
 
     "@tauri-apps/plugin-updater": ["@tauri-apps/plugin-updater@2.9.0", "", { "dependencies": { "@tauri-apps/api": "^2.6.0" } }, "sha512-j++sgY8XpeDvzImTrzWA08OqqGqgkNyxczLD7FjNJJx/uXxMZFz5nDcfkyoI/rCjYuj2101Tci/r/HFmOmoxCg=="],
+
+    "@tauri-apps/plugin-websocket": ["@tauri-apps/plugin-websocket@2.4.0", "", { "dependencies": { "@tauri-apps/api": "^2.6.0" } }, "sha512-0TpWqPBb5G3I1qPE/rPnPUmMyAQTWsw2B75Ab6SQ6X4EcypPGyqTyvt3OXymG6PzJeZ+D9wE614Fnf0wXnj1mg=="],
 
     "@theguild/remark-mermaid": ["@theguild/remark-mermaid@0.2.0", "", { "dependencies": { "mermaid": "^11.0.0", "unist-util-visit": "^5.0.0" }, "peerDependencies": { "react": "^18.2.0" } }, "sha512-o8n57TJy0OI4PCrNw8z6S+vpHtrwoQZzTA5Y3fL0U1NDRIoMg/78duWgEBFsCZcWM1G6zjE91yg1aKCsDwgE2Q=="],
 

package.json

···
     "@tauri-apps/plugin-deep-link": "~2",
     "@tauri-apps/plugin-fs": "~2",
     "@tauri-apps/plugin-opener": "^2",
+    "@tauri-apps/plugin-process": "~2",
+    "@tauri-apps/plugin-shell": "~2",
     "@tauri-apps/plugin-store": "~2",
     "@tauri-apps/plugin-updater": "~2",
+    "@tauri-apps/plugin-websocket": "~2",
     "antd": "^5.26.4",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",

src-tauri/Cargo.lock

···
 name = "atproto-backup"
 version = "0.1.0"
 dependencies = [
+ "chrono",
  "serde",
  "serde_json",
  "tauri",
···
  "tauri-plugin-deep-link",
  "tauri-plugin-fs",
  "tauri-plugin-opener",
+ "tauri-plugin-process",
+ "tauri-plugin-shell",
  "tauri-plugin-single-instance",
  "tauri-plugin-store",
  "tauri-plugin-updater",
+ "tauri-plugin-websocket",
+ "tokio",
 ]
 
 [[package]]
···
 dependencies = [
  "android-tzdata",
  "iana-time-zone",
+ "js-sys",
  "num-traits",
  "serde",
+ "wasm-bindgen",
  "windows-link",
 ]
 
···
 ]
 
 [[package]]
+name = "data-encoding"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
+
+[[package]]
 name = "deranged"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
 
 [[package]]
 name = "endi"
···
  "tokio",
  "tokio-rustls",
  "tower-service",
- "webpki-roots",
+ "webpki-roots 1.0.1",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "os_pipe"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db335f4760b14ead6290116f2427bf33a14d4f0617d49f78a246de10c1831224"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
 name = "osakit"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "wasm-bindgen-futures",
  "wasm-streams",
  "web-sys",
- "webpki-roots",
+ "webpki-roots 1.0.1",
 ]
 
 [[package]]
···
 ]
 
 [[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
 name = "sha2"
 version = "0.10.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
+name = "shared_child"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e362d9935bc50f019969e2f9ecd66786612daae13e8f277be7bfb66e8bed3f7"
+dependencies = [
+ "libc",
+ "sigchld",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
 name = "shlex"
 version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "sigchld"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47106eded3c154e70176fc83df9737335c94ce22f821c32d17ed1db1f83badb1"
+dependencies = [
+ "libc",
+ "os_pipe",
+ "signal-hook",
+]
+
+[[package]]
+name = "signal-hook"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
 
 [[package]]
 name = "signal-hook-registry"
···
 ]
 
 [[package]]
+name = "tauri-plugin-process"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7461c622a5ea00eb9cd9f7a08dbd3bf79484499fd5c21aa2964677f64ca651ab"
+dependencies = [
+ "tauri",
+ "tauri-plugin",
+]
+
+[[package]]
+name = "tauri-plugin-shell"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b9ffadec5c3523f11e8273465cacb3d86ea7652a28e6e2a2e9b5c182f791d25"
+dependencies = [
+ "encoding_rs",
+ "log",
+ "open",
+ "os_pipe",
+ "regex",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "shared_child",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.12",
+ "tokio",
+]
+
+[[package]]
 name = "tauri-plugin-single-instance"
 version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "url",
  "windows-sys 0.60.2",
  "zip",
+]
+
+[[package]]
+name = "tauri-plugin-websocket"
+version = "2.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "402eaba4a045e93f579637c364343d818de002c4b1abd9244f0fd6fcb9ba43dd"
+dependencies = [
+ "futures-util",
+ "http",
+ "log",
+ "rand 0.8.5",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.12",
+ "tokio",
+ "tokio-tungstenite",
 ]
 
 [[package]]
···
  "io-uring",
  "libc",
  "mio",
+ "parking_lot",
  "pin-project-lite",
+ "signal-hook-registry",
  "slab",
  "socket2",
  "tokio-macros",
···
 ]
 
 [[package]]
+name = "tokio-tungstenite"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "489a59b6730eda1b0171fcfda8b121f4bee2b35cba8645ca35c5f7ba3eb736c1"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
 name = "tokio-util"
 version = "0.7.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "tungstenite"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadc29d668c91fcc564941132e17b28a7ceb2f3ebf0b9dae3e03fd7a6748eb0d"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.9.1",
+ "rustls",
+ "rustls-pki-types",
+ "sha1",
+ "thiserror 2.0.12",
+ "utf-8",
+]
 
 [[package]]
 name = "typeid"
···
  "pkg-config",
  "soup3-sys",
  "system-deps",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.1",
 ]
 
 [[package]]

src-tauri/Cargo.toml

···
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
+tauri = { version = "2.0.0", features = [ "tray-icon" ] }
 
 [dependencies]
-tauri = { version = "2", features = [] }
+tauri = { version = "2", features = ["tray-icon"] }
 tauri-plugin-opener = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tauri-plugin-deep-link = "2"
 tauri-plugin-store = "2"
 tauri-plugin-fs = "2"
+tauri-plugin-process = "2"
+tauri-plugin-shell = "2"
+tokio = { version = "1", features = ["full"] }
+chrono = { version = "0.4", features = ["serde"] }
+tauri-plugin-websocket = "2"
 
 [target."cfg(any(target_os = \"macos\", windows, target_os = \"linux\"))".dependencies]
 tauri-plugin-single-instance = { version = "2.0.0", features = ["deep-link"] }

src-tauri/capabilities/default.json

···
     "fs:allow-document-write-recursive",
     "autostart:allow-enable",
     "autostart:allow-disable",
-    "autostart:allow-is-enabled"
+    "autostart:allow-is-enabled",
+    "updater:default"
   ]
 }

src-tauri/capabilities/desktop.json

···
   ],
   "permissions": [
     "autostart:default",
+    "updater:default",
     "updater:default"
   ]
 }

src-tauri/src/background.rs

···
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tauri::{AppHandle, Emitter, Manager, State};
+use tauri_plugin_store::StoreExt;
+use tokio::sync::Mutex;
+use tokio::time::sleep;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BackupSettings {
+    pub frequency: String, // "daily" or "weekly"
+    pub last_backup_date: Option<String>,
+}
+
+pub struct BackgroundScheduler {
+    app: AppHandle,
+    is_running: Arc<Mutex<bool>>,
+}
+
+impl BackgroundScheduler {
+    pub fn new(app: AppHandle) -> Self {
+        Self {
+            app,
+            is_running: Arc::new(Mutex::new(false)),
+        }
+    }
+
+    pub async fn start(&self) {
+        let mut is_running = self.is_running.lock().await;
+        if *is_running {
+            return;
+        }
+        *is_running = true;
+        drop(is_running);
+
+        let is_running = self.is_running.clone();
+        let app = self.app.clone(); // <-- assuming it's Arc<App>
+
+        tokio::spawn(async move {
+            let mut last_check = Instant::now();
+
+            while *is_running.lock().await {
+                if last_check.elapsed() >= Duration::from_secs(30 * 60) {
+                    last_check = Instant::now();
+
+                    if let Err(e) = Self::check_and_perform_backup(app.clone()).await {
+                        eprintln!("Background backup check failed: {}", e);
+                    }
+                }
+
+                sleep(Duration::from_secs(5 * 60)).await;
+            }
+        });
+    }
+
+    pub async fn stop(&self) {
+        let mut is_running = self.is_running.lock().await;
+        *is_running = false;
+    }
+
+    async fn check_and_perform_backup(app: AppHandle) -> Result<(), Box<dyn std::error::Error>> {
+        // Get settings from store
+        let store = app.store("settings.json")?;
+        let raw_settings: Option<serde_json::Value> = store.get("settings");
+
+        let value = raw_settings.unwrap_or(json!({
+            "frequency": "daily",
+            "last_backup_date": null
+        }));
+
+        let settings: BackupSettings = serde_json::from_value(value)?;
+
+        // Check if backup is needed
+        if Self::should_perform_backup(&settings).await? {
+            println!("Background: Backup due, starting backup...");
+
+            // Emit event to frontend to perform backup
+            app.emit("perform-backup", ())?;
+
+            // Update last backup date
+            let mut updated_settings = settings;
+            updated_settings.last_backup_date = Some(chrono::Utc::now().to_rfc3339());
+            store.set("settings", json!(updated_settings));
+            store.save()?;
+
+            println!("Background: Backup completed");
+        }
+
+        Ok(())
+    }
+
+    async fn should_perform_backup(
+        settings: &BackupSettings,
+    ) -> Result<bool, Box<dyn std::error::Error>> {
+        if settings.last_backup_date.is_none() {
+            return Ok(true);
+        }
+
+        let last_backup =
+            chrono::DateTime::parse_from_rfc3339(&settings.last_backup_date.as_ref().unwrap())?;
+        let now = chrono::Utc::now();
+        let time_diff = now.signed_duration_since(last_backup);
+
+        let required_interval = match settings.frequency.as_str() {
+            "daily" => chrono::Duration::days(1),
+            "weekly" => chrono::Duration::weeks(1),
+            _ => chrono::Duration::days(1),
+        };
+
+        Ok(time_diff >= required_interval)
+    }
+}
+
+#[tauri::command]
+pub async fn start_background_scheduler(app: AppHandle) {
+    let scheduler = BackgroundScheduler::new(app);
+    scheduler.start().await;
+}
+
+#[tauri::command]
+pub async fn stop_background_scheduler() -> Result<(), String> {
+    // This would need to be implemented with a global scheduler reference
+    // For now, we'll handle this differently
+    Ok(())
+}

src-tauri/src/lib.rs

···
+use tauri::{Emitter, Manager};
 // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
 use tauri_plugin_deep_link::DeepLinkExt;
 
+mod background;
+mod tray;
+use background::{start_background_scheduler, stop_background_scheduler};
+use tray::{create_system_tray};
+
 #[tauri::command]
 fn greet(name: &str) -> String {
     format!("Hello, {}! You've been greeted from Rust!", name)
···
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     let mut builder = tauri::Builder::default()
+        .plugin(tauri_plugin_websocket::init())
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_updater::Builder::new().build())
         .plugin(tauri_plugin_autostart::init(
             tauri_plugin_autostart::MacosLauncher::LaunchAgent,
···
         .plugin(tauri_plugin_store::Builder::new().build())
         .plugin(tauri_plugin_deep_link::init())
         .plugin(tauri_plugin_opener::init())
-        .invoke_handler(tauri::generate_handler![greet])
+        .invoke_handler(tauri::generate_handler![
+            greet,
+            start_background_scheduler,
+            stop_background_scheduler
+        ])
+        .on_menu_event(|app, event| match event.id.as_ref() {
+            "quit" => {
+                std::process::exit(0);
+            }
+            "show" => {
+                let window = app.get_webview_window("main").unwrap();
+                window.show().unwrap();
+                window.set_focus().unwrap();
+            }
+            "hide" => {
+                let window = app.get_webview_window("main").unwrap();
+                window.hide().unwrap();
+            }
+            "backup_now" => {
+                // Emit event to trigger backup
+                app.emit("perform-backup", ()).unwrap();
+            }
+            _ => {
+              println!("menu item {:?} not handled", event.id);
+            }
+          })
         .setup(|app| {
             #[cfg(any(windows, target_os = "linux"))]
             {
                 app.deep_link().register_all()?;
             }
+            let tray = create_system_tray(app);
+
             Ok(())
         });
 

src-tauri/src/tray.rs

···
+use tauri::{
+    menu::{Menu, MenuItem},
+    tray::{TrayIcon, TrayIconBuilder},
+};
+
+pub fn create_system_tray(app: &tauri::App) -> Result<TrayIcon, tauri::Error> {
+    let quit_i = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
+    let show_i = MenuItem::with_id(app, "show", "Show", true, None::<&str>)?;
+    let hide_i = MenuItem::with_id(app, "hide", "Hide", true, None::<&str>)?;
+    let backup_now_i = MenuItem::with_id(app, "backup_now", "Backup Now", true, None::<&str>)?;
+
+    let menu = Menu::with_items(app, &[
+        &quit_i,
+        &show_i,
+        &hide_i,
+        &backup_now_i,
+    ])?;
+
+    TrayIconBuilder::new()
+        .menu(&menu)
+        .menu_on_left_click(true)
+        .icon(app.default_window_icon().unwrap().clone())
+        .build(app)
+}

src-tauri/tauri.conf.json

···
     ],
     "security": {
       "csp": null
+    },
+    "trayIcon": {
+      "iconPath": "icons/icon.png",
+      "iconAsTemplate": true
     }
   },
   "bundle": {
···
       "icons/[e-mail]",
       "icons/icon.icns",
       "icons/icon.ico"
-    ]
+    ],
+    "createUpdaterArtifacts": true
   },
   "plugins": {
     "deep-link": {
···
           "atprotobackups"
         ]
       }
+    },
+    "updater": {
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDU2Njg2QTE3N0I2NTI0QUEKUldTcUpHVjdGMnBvVnFNWWE4TkdDQlp2eFo2RUZVVmp4b1IxbGdvS3JHOWd1dkRvQm1MdWsvZ1gK",
+      "endpoints": [
+        "https://github.com/Turtlepaw/atproto-backup/releases/latest/download/latest.json"
+      ]
     }
   }
 }

src/App.tsx

···
 import { initializeLocalStorage } from "./localstorage_ployfill";
 import { Home } from "./routes/Home";
 import { ThemeProvider } from "./theme-provider";
-import { Toaster } from "sonner";
+import { toast, Toaster } from "sonner";
 import { ScrollArea } from "./components/ui/scroll-area";
-import { BackupManager } from "./lib/backup";
+import { BackupAgent } from "./lib/backup";
 import { settingsManager } from "./lib/settings";
+import { check } from "@tauri-apps/plugin-updater";
+import { relaunch } from "@tauri-apps/plugin-process";
+import {
+  BackgroundBackupService,
+  handleBackgroundBackup,
+} from "./lib/backgroundBackup";
 
 function AppContent() {
   const { isLoading, isAuthenticated, profile, client, login, logout, agent } =
···
     initStorage();
   }, []);
 
-  // Auto-backup functionality
+  // Background backup service initialization
+  useEffect(() => {
+    if (!isAuthenticated || !agent) return;
+
+    const backgroundService = BackgroundBackupService.getInstance();
+    backgroundService.initialize();
+
+    // Listen for background backup requests
+    const handleBackgroundBackupRequest = () => {
+      handleBackgroundBackup(agent);
+    };
+
+    window.addEventListener(
+      "background-backup-requested",
+      handleBackgroundBackupRequest
+    );
+
+    return () => {
+      window.removeEventListener(
+        "background-backup-requested",
+        handleBackgroundBackupRequest
+      );
+      backgroundService.stop();
+    };
+  }, [isAuthenticated, agent]);
+
+  // Auto-backup functionality (for when app is open)
   useEffect(() => {
     if (!isAuthenticated || !agent) return;
 
···
     const performBackup = async () => {
       try {
         console.log("Automatic backup due, starting backup...");
-        const manager = new BackupManager(agent);
+        const manager = new BackupAgent(agent);
         await manager.startBackup();
 
         // Update the last backup date
···
       }
     };
   }, [isAuthenticated, agent]);
+
+  useEffect(() => {
+    (async () => {
+      const update = await check();
+      if (update) {
+        console.log(
+          `found update ${update.version} from ${update.date} with notes ${update.body}`
+        );
+        toast("Downloading new update...");
+        let downloaded = 0;
+        let contentLength = 0;
+        // alternatively we could also call update.download() and update.install() separately
+        await update.downloadAndInstall((event) => {
+          switch (event.event) {
+            case "Started":
+              //@ts-expect-error
+              contentLength = event.data.contentLength;
+              console.log(
+                `started downloading ${event.data.contentLength} bytes`
+              );
+              break;
+            case "Progress":
+              downloaded += event.data.chunkLength;
+              console.log(`downloaded ${downloaded} from ${contentLength}`);
+              break;
+            case "Finished":
+              console.log("download finished");
+              break;
+          }
+        });
+
+        toast("Update ready, restarting...");
+        await relaunch();
+      }
+    })();
+  }, []);
 
   return (
     <main className="bg-background dark min-h-screen flex flex-col">

src/assets/react.svg

···
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>

src/components/BackgroundTest.tsx

···
+import { useState } from "react";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { toast } from "sonner";
+
+export function BackgroundTest() {
+  const [isListening, setIsListening] = useState(false);
+
+  const startListening = async () => {
+    try {
+      await listen("perform-backup", () => {
+        toast("🎯 Background backup event received!");
+        console.log("Background backup event received");
+      });
+      setIsListening(true);
+      toast("🎯 Listening for background backup events");
+    } catch (error) {
+      console.error("Failed to start listening:", error);
+      toast("Failed to start listening");
+    }
+  };
+
+  const testBackgroundScheduler = async () => {
+    try {
+      await invoke("start_background_scheduler");
+      toast("🎯 Background scheduler started");
+    } catch (error) {
+      console.error("Failed to start background scheduler:", error);
+      toast("Failed to start background scheduler");
+    }
+  };
+
+  const testEmitEvent = async () => {
+    try {
+      // This will trigger the background backup
+      await invoke("emit", { event: "perform-backup", payload: null });
+      toast("🎯 Test backup event emitted");
+    } catch (error) {
+      console.error("Failed to emit event:", error);
+      toast("Failed to emit event");
+    }
+  };
+
+  return (
+    <Card className="bg-card border-white/10 mb-4">
+      <CardHeader>
+        <CardTitle className="text-white">🎯 Background Backup Test</CardTitle>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        <div className="flex gap-2">
+          <Button
+            onClick={startListening}
+            disabled={isListening}
+            variant="outline"
+            className="cursor-pointer"
+          >
+            {isListening ? "Listening..." : "Start Listening"}
+          </Button>
+
+          <Button
+            onClick={testBackgroundScheduler}
+            variant="outline"
+            className="cursor-pointer"
+          >
+            Start Scheduler
+          </Button>
+
+          <Button
+            onClick={testEmitEvent}
+            variant="outline"
+            className="cursor-pointer"
+          >
+            Test Event
+          </Button>
+        </div>
+
+        <div className="text-xs text-white/60">
+          <p>• Click "Start Listening" to listen for backup events</p>
+          <p>• Click "Start Scheduler" to start background scheduler</p>
+          <p>• Click "Test Event" to manually trigger a backup event</p>
+          <p>• Check browser console for detailed logs</p>
+        </div>
+      </CardContent>
+    </Card>
+  );
+}

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/autoBackup.ts

···
 import { Agent } from "@atproto/api";
-import { BackupManager } from "./backup";
+import { BackupAgent } from "./backup";
 import { settingsManager } from "./settings";
 
 export class AutoBackupScheduler {
···
 
   private async performBackup(): Promise<void> {
     try {
-      const manager = new BackupManager(this.agent);
+      const manager = new BackupAgent(this.agent);
       await manager.startBackup();
 
       // Update the last backup date

src/lib/backgroundBackup.ts

···
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { BackupAgent } from "./backup";
+import { settingsManager } from "./settings";
+import { toast } from "sonner";
+
+export class BackgroundBackupService {
+  private static instance: BackgroundBackupService;
+  private isInitialized = false;
+
+  private constructor() {}
+
+  static getInstance(): BackgroundBackupService {
+    if (!BackgroundBackupService.instance) {
+      BackgroundBackupService.instance = new BackgroundBackupService();
+    }
+    return BackgroundBackupService.instance;
+  }
+
+  async initialize(): Promise<void> {
+    if (this.isInitialized) return;
+
+    // Start the background scheduler
+    try {
+      await invoke("start_background_scheduler");
+      console.log("Background backup scheduler started");
+    } catch (error) {
+      console.error("Failed to start background scheduler:", error);
+    }
+
+    // Listen for backup events from the background scheduler
+    await listen("perform-backup", async () => {
+      console.log("Background backup event received");
+      await this.performBackgroundBackup();
+    });
+
+    this.isInitialized = true;
+  }
+
+  private async performBackgroundBackup(): Promise<void> {
+    try {
+      // Get the agent from the auth context
+      // This is a bit tricky since we need to access the agent from the React context
+      // For now, we'll emit an event that the main app can listen to
+      window.dispatchEvent(new CustomEvent("background-backup-requested"));
+
+      console.log("Background backup request dispatched");
+    } catch (error) {
+      console.error("Background backup failed:", error);
+    }
+  }
+
+  async stop(): Promise<void> {
+    try {
+      await invoke("stop_background_scheduler");
+      console.log("Background backup scheduler stopped");
+    } catch (error) {
+      console.error("Failed to stop background scheduler:", error);
+    }
+  }
+}
+
+// Export a function to handle background backup requests
+export async function handleBackgroundBackup(agent: any): Promise<void> {
+  try {
+    console.log("Performing background backup...");
+
+    const manager = new BackupAgent(agent);
+    await manager.startBackup();
+
+    // Update the last backup date
+    await settingsManager.setLastBackupDate(new Date().toISOString());
+
+    console.log("Background backup completed successfully");
+
+    // Show a notification (if the app is minimized, this might not be visible)
+    toast("Automatic backup completed", {
+      description: "Your data has been backed up automatically",
+    });
+  } catch (error) {
+    console.error("Background backup failed:", error);
+    toast("Automatic backup failed", {
+      description: "Check the console for details",
+    });
+  }
+}

src/lib/backup.ts

···
   timestamp: string;
   backupType: string;
   filePath: string;
+  blobsPath?: string;
+  blobCount?: number;
   stats: CarStats;
 }
 
-export class BackupManager {
+export interface BlobReference {
+  cid: string;
+  mimeType?: string;
+  size?: number;
+}
+
+export type BackupStage =
+  | "fetching"
+  | "writing"
+  | "blobs"
+  | "cleanup"
+  | "complete";
+export interface ProgressInfo {
+  stage: BackupStage;
+  message: string;
+  progress?: number; // 0-100 percentage
+  current?: number;
+  total?: number;
+}
+
+export type ProgressCallback = (progress: ProgressInfo) => void;
+
+export class BackupAgent {
   private agent: Agent;
   private maxBackups = 3;
+  private downloadBlobs = true;
+  private progressCallback?: ProgressCallback;
+  private overwriteBackups = false;
 
-  constructor(agent: Agent) {
+  constructor(
+    agent: Agent,
+    options?: {
+      downloadBlobs?: boolean;
+      onProgress?: ProgressCallback;
+      overwriteBackups?: boolean;
+    }
+  ) {
     this.agent = agent;
+    this.downloadBlobs = options?.downloadBlobs ?? true;
+    this.progressCallback = options?.onProgress;
+    this.overwriteBackups = options?.overwriteBackups ?? false;
+  }
+
+  private reportProgress(progress: ProgressInfo) {
+    if (this.progressCallback) {
+      this.progressCallback(progress);
+    }
   }
 
   async startBackup(): Promise<Metadata> {
     const did = this.agent.did;
     if (did == null) throw Error("Unauthenticated");
 
-    // Get the repo data
-    const data = await this.agent.com.atproto.sync.getRepo({ did: did });
+    try {
+      // Stage 1: Fetching repo data
+      this.reportProgress({
+        stage: "fetching",
+        message: "Fetching repository data...",
+        progress: 10,
+      });
+
+      const data = await this.agent.com.atproto.sync.getRepo({ did: did });
+
+      // Stage 2: Writing backup file
+      this.reportProgress({
+        stage: "writing",
+        message: "Writing backup to file...",
+        progress: 30,
+      });
+
+      const metadata = await this.writeBackupToFile(data.data, did);
+
+      // Stage 3: Download blobs if enabled
+      if (this.downloadBlobs) {
+        this.reportProgress({
+          stage: "blobs",
+          message: "Preparing to download blobs...",
+          progress: 40,
+        });
+
+        await this.downloadBlobsForBackup(metadata);
+      } else {
+        this.reportProgress({
+          stage: "blobs",
+          message: "Skipping blob download (disabled)",
+          progress: 80,
+        });
+      }
 
-    // Write to backup location
-    const metadata = await this.writeBackupToFile(data.data, did);
+      // Clean up old backups or overwrite existing one
+      if (this.overwriteBackups) {
+        this.reportProgress({
+          stage: "cleanup",
+          message: "Cleaning up previous backup...",
+          progress: 90,
+        });
+        await this.cleanupAllBackups();
+      } else {
+        this.reportProgress({
+          stage: "cleanup",
+          message: "Cleaning up old backups...",
+          progress: 90,
+        });
+        await this.cleanupOldBackups();
+      }
 
-    // Clean up old backups after creating new one
-    await this.cleanupOldBackups();
+      // Stage 5: Complete
+      this.reportProgress({
+        stage: "complete",
+        message: "Backup completed successfully!",
+        progress: 100,
+      });
 
-    return metadata;
+      return metadata;
+    } catch (error: any) {
+      this.reportProgress({
+        stage: "complete",
+        message: `Backup failed: ${error.message}`,
+        progress: 0,
+      });
+      throw error;
+    }
   }
 
   private async writeBackupToFile(
···
       // Create backup directory structure
       await createBackupDir();
       const backupDir = await getBackupDir();
-      const timestamp = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
-      const backupPath = await join(backupDir, `${timestamp}_backup`);
+
+      let backupPath: string;
+      if (this.overwriteBackups) {
+        // Use a consistent name for overwriting
+        backupPath = await join(backupDir, "current_backup");
+
+        // Remove existing backup if it exists
+        try {
+          await remove(backupPath, { recursive: true });
+        } catch (e) {
+          // Directory might not exist, which is fine
+        }
+      } else {
+        // Use timestamp-based naming, overwrite if exists for today
+        const timestamp = new Date().toISOString().split("T")[0]; // YYYY-MM-DD
+        backupPath = await join(backupDir, `${timestamp}_backup`);
+
+        // Remove existing backup for today if it exists
+        try {
+          await remove(backupPath, { recursive: true });
+          console.log(`Overwriting existing backup for ${timestamp}`);
+        } catch (e) {
+          // Directory might not exist, which is fine
+        }
+      }
+
       await mkdir(backupPath);
 
       // Write the repo data as binary file
···
     }
   }
 
+  private async downloadBlobsForBackup(metadata: Metadata): Promise<void> {
+    try {
+      const backupDir = await resolve(metadata.filePath, "..");
+      const blobDir = await join(backupDir, "blobs");
+      await mkdir(blobDir);
+
+      // Extract blob references from the CAR file
+      this.reportProgress({
+        stage: "blobs",
+        message: "Extracting blob references...",
+        progress: 45,
+      });
+
+      const blobRefs = await this.extractBlobReferences();
+
+      if (blobRefs.length === 0) {
+        this.reportProgress({
+          stage: "blobs",
+          message: "No blobs found in backup",
+          progress: 80,
+        });
+        console.log("No blobs found in backup");
+        return;
+      }
+
+      console.log(`Downloading ${blobRefs.length} blobs...`);
+      let downloadedCount = 0;
+
+      for (let i = 0; i < blobRefs.length; i++) {
+        const blobRef = blobRefs[i];
+        const progress = 50 + Math.round((i / blobRefs.length) * 30); // 50-80% range
+
+        this.reportProgress({
+          stage: "blobs",
+          message: `Downloading blob ${i + 1} of ${blobRefs.length}...`,
+          progress,
+          current: i + 1,
+          total: blobRefs.length,
+        });
+
+        try {
+          const blobData = await this.agent.com.atproto.sync.getBlob({
+            did: metadata.did,
+            cid: blobRef,
+          });
+
+          const blobPath = await join(blobDir, `${blobRef}.blob`);
+          await writeFile(blobPath, blobData.data);
+          downloadedCount++;
+
+          // Optional: Save blob metadata
+          const blobMetadata = {
+            cid: blobRef,
+            size: blobData.data.length,
+            downloadedAt: new Date().toISOString(),
+          };
+
+          const blobMetadataPath = await join(blobDir, `${blobRef}.json`);
+          await writeFile(
+            blobMetadataPath,
+            new TextEncoder().encode(JSON.stringify(blobMetadata, null, 2))
+          );
+        } catch (error) {
+          console.error(`Failed to download blob ${blobRef}:`, error);
+        }
+      }
+
+      // Update main metadata with blob information
+      const updatedMetadata = {
+        ...metadata,
+        blobsPath: blobDir,
+        blobCount: downloadedCount,
+      };
+
+      const metadataPath = await join(backupDir, "metadata.json");
+      await writeFile(
+        metadataPath,
+        new TextEncoder().encode(JSON.stringify(updatedMetadata, null, 2))
+      );
+
+      this.reportProgress({
+        stage: "blobs",
+        message: `Downloaded ${downloadedCount}/${blobRefs.length} blobs`,
+        progress: 80,
+      });
+
+      console.log(`Downloaded ${downloadedCount}/${blobRefs.length} blobs`);
+    } catch (error) {
+      console.error("Failed to download blobs:", error);
+      // Don't throw - blob download failure shouldn't fail the entire backup
+    }
+  }
+
+  private async extractBlobReferences(): Promise<string[]> {
+    let allBlobs = [];
+    let cursor: string | undefined;
+    while (true) {
+      const blobs = await this.agent.com.atproto.sync.listBlobs({
+        did: this.agent.assertDid,
+        limit: 500,
+        cursor,
+      });
+      allBlobs.push(...blobs.data.cids);
+      if (blobs.data.cursor) cursor = blobs.data.cursor;
+      else break;
+    }
+
+    return allBlobs;
+  }
+
+  private async cleanupAllBackups(): Promise<void> {
+    try {
+      const backups = await this.getBackups();
+
+      for (const backup of backups) {
+        await this.deleteBackup(backup);
+      }
+
+      if (backups.length > 0) {
+        console.log(`Deleted ${backups.length} existing backup(s)`);
+      }
+    } catch (error) {
+      console.error("Failed to cleanup all backups:", error);
+      // Don't throw here - we don't want backup creation to fail because of cleanup issues
+    }
+  }
+
   private async cleanupOldBackups(): Promise<void> {
     try {
       const backups = await this.getBackups();
···
     }
 
     return data;
+  }
+
+  // Method to restore a specific blob
+  async restoreBlob(
+    backupMetadata: Metadata,
+    blobCid: string
+  ): Promise<Uint8Array | null> {
+    if (!backupMetadata.blobsPath) {
+      throw new Error("No blobs available for this backup");
+    }
+
+    try {
+      const blobPath = await join(backupMetadata.blobsPath, `${blobCid}.blob`);
+      const blobData = await readTextFile(blobPath);
+      return new TextEncoder().encode(blobData);
+    } catch (error) {
+      console.error(`Failed to restore blob ${blobCid}:`, error);
+      return null;
+    }
   }
 }

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/lib/testBackground.ts

···
+import { invoke } from "@tauri-apps/api/core";
+import { listen } from "@tauri-apps/api/event";
+import { toast } from "sonner";
+
+export class BackgroundTestService {
+  static async testBackgroundBackup() {
+    try {
+      // Test the background scheduler
+      await invoke("start_background_scheduler");
+      toast("Background scheduler started");
+
+      // Listen for backup events
+      await listen("perform-backup", () => {
+        toast("Background backup event received!");
+        console.log("Background backup event received");
+      });
+
+      console.log("Background test service initialized");
+    } catch (error) {
+      console.error("Background test failed:", error);
+      toast("Background test failed");
+    }
+  }
+
+  static async triggerTestBackup() {
+    try {
+      // Emit a test backup event
+      await invoke("emit", { event: "perform-backup", payload: null });
+      toast("Test backup event triggered");
+    } catch (error) {
+      console.error("Failed to trigger test backup:", error);
+      toast("Failed to trigger test backup");
+    }
+  }
+}

src/routes/Home.tsx

···
+import { useAuth } from "@/Auth";
+import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
+import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
-import { ProfileViewDetailed } from "@atproto/api/dist/client/types/app/bsky/actor/defs";
-import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
 import {
   DropdownMenu,
   DropdownMenuContent,
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
-import { openPath } from "@tauri-apps/plugin-opener";
+import { Progress } from "@/components/ui/progress";
+import { BackupAgent, BackupStage, Metadata } from "@/lib/backup";
 import { createBackupDir, getBackupDir } from "@/lib/paths";
-import { useEffect, useState, useRef } from "react";
+import { settingsManager } from "@/lib/settings";
+import { ProfileViewDetailed } from "@atproto/api/dist/client/types/app/bsky/actor/defs";
+import { openPath } from "@tauri-apps/plugin-opener";
 import {
-  History,
-  LoaderCircleIcon,
   ChevronDown,
-  FolderOpen,
-  Database,
   FileText,
+  FolderOpen,
   HardDrive,
-  Package,
   Heart,
-  Users,
-  User,
+  History,
+  Images,
+  LoaderCircleIcon,
+  Package,
   Settings as SettingsIcon,
+  User,
+  Users,
 } from "lucide-react";
-import { BackupManager, Metadata } from "@/lib/backup";
-import { useAuth } from "@/Auth";
+import { useEffect, useRef, useState } from "react";
 import { toast } from "sonner";
-import { settingsManager } from "@/lib/settings";
-import { Badge } from "@/components/ui/badge";
-import { Progress } from "@/components/ui/progress";
 import Settings from "./Settings";
 
 export function Home({
···
           variant="ghost"
           size="sm"
           onClick={() => setShowSettings(true)}
-          className="text-white/80 hover:text-white"
+          className="text-white/80 hover:text-white cursor-pointer"
         >
           <SettingsIcon className="w-4 h-4" />
         </Button>
       </div>
 
+      {/* For testing auto backup */}
+      {/* <TestAutoBackup /> */}
+      {/* <BackgroundTest /> */}
+
       <div className="bg-card rounded-lg p-4 mb-4">
         <p className="mb-2 text-white">Backups</p>
         <div className="flex gap-2">
···
           </Button>
 
           <StartBackup onBackupComplete={handleBackupComplete} />
+
+          {/* <Button
+            variant="outline"
+            className="cursor-pointer"
+            onClick={async () => {
+              await BackgroundTestService.testBackgroundBackup();
+            }}
+          >
+            Test Background
+          </Button> */}
         </div>
       </div>
 
···
 
 function StartBackup({ onBackupComplete }: { onBackupComplete: () => void }) {
   const [isLoading, setIsLoading] = useState(false);
+  const [stage, setStage] = useState<BackupStage | null>(null);
+  const [_, setProgress] = useState<number | undefined>();
   const { agent } = useAuth();
 
   return (
···
             toast("Agent not initialized, try to reload the app.");
             return;
           }
-          const manager = new BackupManager(agent!!);
+          const manager = new BackupAgent(agent!!, {
+            onProgress: (progress) => {
+              setStage(progress.stage);
+              setProgress(progress.progress);
+            },
+          });
           await manager.startBackup();
           await settingsManager.setLastBackupDate(new Date().toISOString());
           toast("Backup complete!");
···
       disabled={isLoading}
     >
       {isLoading ? (
-        <LoaderCircleIcon className="animate-spin text-white/80" />
+        <>
+          <LoaderCircleIcon className="animate-spin text-white/80" />
+          <span className="capitalize">{stage}</span>
+        </>
       ) : (
         <span>Backup now</span>
       )}
···
     }
     setIsLoading(true);
     try {
-      const manager = new BackupManager(agent);
+      const manager = new BackupAgent(agent);
       const backupsList = await manager.getBackups();
       // Sort backups by timestamp (newest first)
       const sortedBackups = backupsList.sort(
···
                     </div>
 
                     <div className="flex items-center gap-2 p-3 rounded-lg bg-white/5">
-                      <Database className="w-5 h-5 text-purple-400" />
+                      <Images className="w-5 h-5 text-purple-400" />
                       <div>
-                        <p className="text-white/60 text-xs">Blocks</p>
+                        <p className="text-white/60 text-xs">Attachments</p>
                         <p className="text-white font-semibold">
-                          {backup.stats?.totalBlocks?.toLocaleString() || "-"}
+                          {backup.blobCount?.toLocaleString() || "-"}
                         </p>
                       </div>
                     </div>

src/routes/Login.tsx

···
     <div
       className="min-h-screen flex items-center justify-center bg-background px-4 relative"
       style={{
-        backgroundImage: "url(/src/assets/milky_way.jpg)",
+        backgroundImage: "url(/milky_way.jpg)",
         backgroundSize: "300%",
         backgroundPosition: "center",
         backgroundRepeat: "no-repeat",

src/routes/Settings.tsx

···
           variant="ghost"
           size="sm"
           onClick={onBack}
-          className="text-white/80 hover:text-white"
+          className="text-white/80 hover:text-white cursor-pointer"
         >
           <ArrowLeft className="w-4 h-4 mr-2" />
           Back