Complete mailbox backup to .eml files (#6)

* Add complete mailbox backup to .eml files (CLI)

`tutabridge backup <dir>` exports every mail of every folder to a
plaintext `.eml` tree, mirroring the IMAP folder hierarchy.

A backup must be *complete*: it enumerates all mails per folder from
the server (`limit == 0`), not just the `sync_limit`-capped subset the
bridge keeps cached. Dumping only the synced subset would silently drop
mail — live-tested here against an INBOX with 6288 server-side mails vs
1050 cached, all 6288 exported. The encrypted local cache
(`.eml.enc`) is used as a fast path; only never-synced mails trigger a
rate-limited (150ms) server fetch.

Format: one `.eml` per mail in `<output>/<folder path>/<YYYYMMDD-HHMMSS>_<id>.eml`.
EML is the most portable target — native to Thunderbird/Apple Mail/
Outlook, no Maildir `:2,S` colons that break on Windows, and a single
corrupt file never takes down the whole archive. Folder path segments
are sanitised for cross-platform filesystems (Windows-illegal chars +
trailing dot/space stripped); the date prefix makes a directory listing
sort chronologically.

`backup::export_eml` is surface-agnostic (takes a progress callback) so
a GUI button can wrap the same engine later. Per-mail failures are
collected in `BackupStats::errors` rather than aborting the run. The CLI
shares the keychain/password login flow with the bridge via the new
`login_session` helper, and opens the cache without the bridge's
reset-on-key-mismatch (a backup must never destroy the cache).

8 backup unit/integration tests: filename + folder sanitisation,
date stamp, and an end-to-end export over a mock backend asserting the
cache-vs-server split, file tree layout, and verbatim cached bodies.

GUI button is a follow-up (needs the Tauri dialog plugin).

* Make backup resumable / incremental

Skip a mail when its `.eml` is already on disk, before any cache read
or server fetch. The filename is deterministic (stable receivedDate +
element id) and mail content is immutable, so an existing file is never
stale. This turns an interrupted backup into a resume (re-run continues
where it stopped) and a periodic re-backup into an incremental one
(only new mail is fetched — the expensive part). New
`BackupStats::skipped` counter, surfaced in the CLI summary.

Two tests: a re-run skips every already-exported mail (zero server
loads), and an incremental run fetches only the newly-arrived mail.

* Add Backup tab to the GUI

A "Backup" tab wraps the same `backup::export_eml` engine as the CLI:
a native folder picker (tauri-plugin-dialog), a live per-folder
progress bar driven by `bridge://backup-progress` events, and a result
summary (mails written, folders, MB, cache vs server vs skipped).

`BridgeHandle` now keeps the logged-in backend + local cache after
`start` and exposes them via `backend_and_store()`, so the
`export_mails` command reuses the live session instead of opening a
second one — and drops the handle lock before the (minutes-long)
export so status/stats stay responsive. The button is disabled unless
the bridge is running.

`BackupStats` is now `Serialize` so it can cross the Tauri boundary.

* Keep backup state across tab switches

The Backup tab is conditionally rendered, so switching away unmounted
`BackupPanel` mid-export — dropping its progress + result state and the
`bridge://backup-progress` listener while the Rust task kept running.
Coming back showed an idle panel even though the backup was still going.

Lift all backup state (busy / progress / result / error), the
`startBackup` action, and the progress listener into the always-mounted
`useBridge` hook. The listener is now active regardless of which tab is
shown, and `BackupPanel` is purely presentational — switch tabs freely
mid-backup and the progress is intact on return. `startBackup` guards
against a double launch while one is in flight.

src-tauri/src/commands.rs

@@ -1,12 +1,22 @@
 use std::sync::Arc;
-use tauri::State;
+use tauri::{AppHandle, Emitter, State};
 use tokio::sync::Mutex;
+use tutabridge_core::backup;
 use tutabridge_core::bridge::{BridgeHandle, BridgeStats, BridgeStatus};
 use tutabridge_core::config::{self, Config};
 use tutabridge_core::tuta;
 
 pub type BridgeState = Arc<Mutex<BridgeHandle>>;
 
+/// Progress event pushed to the UI during a backup (`bridge://backup-progress`).
+#[derive(Clone, serde::Serialize)]
+struct BackupProgressEvent {
+    folder: String,
+    done: usize,
+    total: usize,
+    finished: bool,
+}
+
 #[tauri::command]
 pub async fn get_config() -> Result<Config, String> {
     match config::load_config() {
@@ -78,3 +88,50 @@ pub async fn regenerate_bridge_password() -> Result<String, String> {
         .ok_or("No config found")?;
     config::regenerate_bridge_password(&mut cfg).map_err(|e| e.to_string())
 }
+
+/// Export every mail to `output_dir` as a tree of `.eml` files. Requires the
+/// bridge to be running (reuses its live session + cache). Streams progress
+/// via `bridge://backup-progress` events and resolves with the final stats.
+#[tauri::command]
+pub async fn export_mails(
+    output_dir: String,
+    app: AppHandle,
+    state: State<'_, BridgeState>,
+) -> Result<backup::BackupStats, String> {
+    // Grab the live backend + cache, then drop the lock immediately — a
+    // backup can run for minutes and must not block status/stats reads.
+    let (backend, local_store) = {
+        let handle = state.lock().await;
+        handle
+            .backend_and_store()
+            .ok_or("Start the bridge before backing up")?
+    };
+
+    let out = std::path::Path::new(&output_dir);
+    let stats = backup::export_eml(&*backend, &local_store, out, |p| {
+        // Throttle: emit every 20 mails plus the last one of each folder.
+        if p.done == p.total || p.done % 20 == 0 {
+            let _ = app.emit(
+                "bridge://backup-progress",
+                BackupProgressEvent {
+                    folder: p.folder.clone(),
+                    done: p.done,
+                    total: p.total,
+                    finished: false,
+                },
+            );
+        }
+    })
+    .await?;
+
+    let _ = app.emit(
+        "bridge://backup-progress",
+        BackupProgressEvent {
+            folder: String::new(),
+            done: 0,
+            total: 0,
+            finished: true,
+        },
+    );
+    Ok(stats)
+}

src-tauri/src/main.rs

@@ -23,6 +23,7 @@ fn main() {
 
     tauri::Builder::default()
         .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_dialog::init())
         .manage(shared as BridgeState)
         .invoke_handler(tauri::generate_handler![
             commands::get_config,
@@ -34,6 +35,7 @@ fn main() {
             commands::get_stats,
             commands::get_bridge_password,
             commands::regenerate_bridge_password,
+            commands::export_mails,
         ])
         .setup(|app| {
             let app_handle = app.handle().clone();