Skip to main content

second_brain_core/keys/
restore.rs

1use std::collections::BTreeSet;
2use std::fs;
3use std::io::{self, ErrorKind};
4use std::path::{Path, PathBuf};
5
6use anyhow::{Context, Result, anyhow, bail, ensure};
7
8use super::aside::{RESTORE_MARKER, aside_path, carry_over, create_private_dir};
9use super::device::sync_dir;
10use super::hardware::{HardwareSource, SystemHardware};
11use super::storage::create_device_keys_with;
12use super::{
13    DEVICE_KEY_FILE, DEVICE_PUB_FILE, DeviceKeys, HARDWARE_BINDING_FILE, HeldEpoch, IdentityTag,
14    KeyStorage, NEXT_STORE_KEY_FILE, RecoveryPhrase, SEALED_DEVICE_KEY_FILE, STORE_KEY_FILE,
15    StoreKey, WRAPPED_STORE_KEY_FILE, found_identity, refresh_wrapped_store_key,
16    unwrap_store_key_with_epochs, unwrap_store_key_with_phrase, wrap, wrap_for_recovery,
17    write_store_key,
18};
19use crate::machine::MachineIdentity;
20use crate::sqlite_store::SqliteStore;
21use crate::sqlite_store::encrypt_migration::{
22    FileState, PLAINTEXT_COPY_PREFIX, RewriteTo, db_file_state,
23};
24use crate::store::StoreAdmin;
25use crate::write_queue;
26
27const DB_FILE: &str = "brain.db";
28const MACHINE_FILE: &str = "machine.toml";
29const CONFIG_FILE: &str = "config.toml";
30
31/// Files a backup never brings along: what names the old device, its keys
32/// or its peers, and what belongs to the host it ran on.
33const LEFT_BEHIND: &[&str] = &[
34    MACHINE_FILE,
35    DEVICE_KEY_FILE,
36    SEALED_DEVICE_KEY_FILE,
37    HARDWARE_BINDING_FILE,
38    DEVICE_PUB_FILE,
39    "sync.key",
40    "migrated-peers.json",
41    "api.token",
42    ".api.token.lock",
43    "sync-peers",
44    "clock-reading",
45    "service.json",
46    "brain.db-shm",
47    STORE_KEY_FILE,
48    NEXT_STORE_KEY_FILE,
49    "brain.db.enc",
50    "brain.db.enc-journal",
51    "brain.db.enc-wal",
52    "brain.db.enc-shm",
53];
54
55/// Temporary files the key writers leave on a crash, which may hold the old
56/// device's secret.
57const LEFT_BEHIND_PREFIXES: &[&str] = &[".device.key.", ".store.key.", PLAINTEXT_COPY_PREFIX];
58
59/// Host files the data dir being replaced keeps across a restore.
60const HOST_FILES: &[&str] = &["service.json"];
61
62pub struct RestoreRequest<'a> {
63    /// A copy of a device's data dir.
64    pub backup: &'a Path,
65    /// The data dir to restore into; an existing one is moved aside.
66    pub data_dir: &'a Path,
67    pub phrase: &'a RecoveryPhrase,
68    pub storage: &'a KeyStorage,
69    pub now_micros: i64,
70}
71
72/// What opens a backup's keys.
73#[derive(Clone, Copy)]
74#[non_exhaustive]
75pub enum BackupKeys<'a> {
76    /// A recovery phrase the backed-up device trusted.
77    Phrase(&'a RecoveryPhrase),
78    /// Epochs of `K_id`: handed over by a surviving device through
79    /// `sb pair --restore-keys`, or this device's own past epochs.
80    Epochs(&'a [HeldEpoch]),
81}
82
83pub struct BackupRestore<'a> {
84    /// A copy of a device's data dir.
85    pub backup: &'a Path,
86    /// The data dir to restore into; an existing one is moved aside.
87    pub data_dir: &'a Path,
88    pub keys: BackupKeys<'a>,
89    pub storage: &'a KeyStorage,
90    pub now_micros: i64,
91}
92
93#[derive(Debug)]
94#[non_exhaustive]
95pub struct Restored {
96    pub machine: MachineIdentity,
97    pub identity: IdentityTag,
98    /// The identities whose epochs the phrase or the given epochs opened,
99    /// kept decrypt-only.
100    pub opened: Vec<IdentityTag>,
101    /// The phrase of the new identity, to be shown to the user once.
102    pub phrase: RecoveryPhrase,
103    /// Where the data dir that was replaced now lives.
104    pub moved_aside: Option<PathBuf>,
105}
106
107/// Restores a data-dir backup as a new device of a new identity: the copy
108/// gets a fresh machine id and device keys first, the phrase opens the
109/// backup's epochs (kept decrypt-only, wrapped to the new device), and then
110/// the new identity is founded with a new phrase. Nothing in `data_dir`
111/// changes until the restored copy is complete; the old one is then moved
112/// aside, where the daemon deletes it after 90 days. The daemon must not be
113/// running.
114pub fn restore_backup(req: &RestoreRequest<'_>) -> Result<Restored> {
115    restore_backup_with(&BackupRestore {
116        backup: req.backup,
117        data_dir: req.data_dir,
118        keys: BackupKeys::Phrase(req.phrase),
119        storage: req.storage,
120        now_micros: req.now_micros,
121    })
122}
123
124/// `restore_backup` with the backup's keys opened by a phrase or by epochs
125/// of `K_id`, which are kept decrypt-only the same way.
126pub fn restore_backup_with(req: &BackupRestore<'_>) -> Result<Restored> {
127    restore_with_hardware(req, &SystemHardware)
128}
129
130fn restore_with_hardware(
131    req: &BackupRestore<'_>,
132    hardware: &dyn HardwareSource,
133) -> Result<Restored> {
134    let backup = check_backup(req.backup)?;
135    if let Ok(target) = fs::canonicalize(req.data_dir) {
136        ensure!(
137            target != backup,
138            "the backup is the data dir itself; restore from a copy"
139        );
140    }
141    let parent = parent_of(req.data_dir)?;
142    fs::create_dir_all(&parent).with_context(|| format!("creating {}", parent.display()))?;
143    let base = dir_name(req.data_dir)?;
144    let staging_prefix = format!(".{base}.restoring-");
145    remove_stale_staging(&parent, &staging_prefix, &backup);
146    let staging = parent.join(format!("{staging_prefix}{}", uuid::Uuid::new_v4().simple()));
147    let restored = match prepare(req, &backup, &staging, hardware) {
148        Ok(restored) => restored,
149        Err(e) => return Err(with_staging_removed(e, &staging)),
150    };
151    let moved_aside = match swap_in(req.data_dir, &staging, &base, req.now_micros, rename) {
152        Ok(moved) => moved,
153        Err(Swap::Untouched(e)) => return Err(with_staging_removed(e, &staging)),
154        Err(Swap::Stranded(e)) => return Err(e),
155    };
156    if let Err(e) = sync_dir(&parent) {
157        tracing::warn!("the restore is in place but not yet flushed to disk: {e:#}");
158    }
159    Ok(Restored {
160        moved_aside,
161        ..restored
162    })
163}
164
165/// Queued writes that the backup's plain device key opens follow the
166/// restore; the daemon sets the rest aside as unreadable. The backup is only
167/// read, so a key sealed to the old host's TPM is not tried.
168fn reseal_backup_queue(backup: &Path, staging: &Path, device: &DeviceKeys) -> Result<()> {
169    let queue = staging.join(write_queue::DIR_NAME);
170    if !queue.is_dir() {
171        return Ok(());
172    }
173    let old = match DeviceKeys::load(&backup.join(DEVICE_KEY_FILE)) {
174        Ok(Some(old)) => old,
175        Ok(None) => return Ok(()),
176        Err(e) => {
177            tracing::warn!("sealed queued writes in the backup stay unreadable: {e:#}");
178            return Ok(());
179        }
180    };
181    write_queue::reseal_dir(&queue, old.age_identity(), &[device.age_recipient()])?;
182    Ok(())
183}
184
185/// The canonical path of `backup` when it holds a store, so a caller can
186/// refuse a wrong path before it asks for keys.
187pub fn check_backup(backup: &Path) -> Result<PathBuf> {
188    let canonical = fs::canonicalize(backup)
189        .with_context(|| format!("reading the backup {}", backup.display()))?;
190    ensure!(
191        canonical.join(DB_FILE).is_file(),
192        "{} holds no {DB_FILE}; name a copy of a second-brain data dir",
193        canonical.display()
194    );
195    Ok(canonical)
196}
197
198fn prepare(
199    req: &BackupRestore<'_>,
200    backup: &Path,
201    staging: &Path,
202    hardware: &dyn HardwareSource,
203) -> Result<Restored> {
204    if let BackupKeys::Epochs(held) = req.keys {
205        ensure!(
206            !held.is_empty(),
207            "no key epoch was given, so the backup cannot be opened"
208        );
209    }
210    create_private_dir(staging)?;
211    copy_tree(backup, staging, true)?;
212    let machine = MachineIdentity::load_or_create(staging)?;
213    let device = create_device_keys_with(staging, req.storage, hardware)?;
214    reseal_backup_queue(backup, staging, &device)?;
215    let store = open_backup_store(&staging.join(DB_FILE), staging, req.keys, &machine.id)
216        .context("opening the restored database")?;
217    store.register_machine(&machine)?;
218
219    let reopened;
220    let old_epochs: &[HeldEpoch] = match req.keys {
221        BackupKeys::Phrase(phrase) => {
222            reopened =
223                reopen_old_epochs(&store, phrase, &device, req.now_micros).with_context(|| {
224                    format!("opening {} with the recovery phrase", backup.display())
225                })?;
226            &reopened
227        }
228        BackupKeys::Epochs(held) => {
229            keep_epochs(&store, held, &device, req.now_micros)?;
230            held
231        }
232    };
233
234    let phrase = RecoveryPhrase::generate()?;
235    let recipient = phrase.recipient()?;
236    let founded = found_identity(
237        &store,
238        &device,
239        &machine.name,
240        std::slice::from_ref(&recipient),
241        req.now_micros,
242    )?;
243    for held in old_epochs {
244        wrap_for_recovery(
245            &store,
246            &held.identity,
247            &[(held.epoch, &held.key)],
248            std::slice::from_ref(&recipient),
249        )?;
250    }
251    if cfg!(feature = "encryption") {
252        rekey_restored(&store, staging, &device)?;
253    }
254    drop(store);
255    let opened: BTreeSet<&str> = old_epochs.iter().map(|h| h.identity.as_str()).collect();
256    let opened = opened
257        .into_iter()
258        .map(|t| IdentityTag::from(t.to_string()))
259        .collect();
260    sync_tree(staging)?;
261    Ok(Restored {
262        machine,
263        identity: founded.tag,
264        opened,
265        phrase,
266        moved_aside: None,
267    })
268}
269
270/// An encrypted backup opens under the store key its `store.key.wrapped`
271/// gives up to the phrase or an epoch; a plaintext one, from before the
272/// migration, opens as it is.
273fn open_backup_store(
274    db: &Path,
275    staging: &Path,
276    keys: BackupKeys<'_>,
277    machine_id: &str,
278) -> Result<SqliteStore> {
279    match db_file_state(db)? {
280        FileState::Encrypted => {
281            let unwrapped = match keys {
282                BackupKeys::Phrase(phrase) => unwrap_store_key_with_phrase(staging, phrase)?,
283                BackupKeys::Epochs(held) => unwrap_store_key_with_epochs(staging, held)?,
284            };
285            let key = unwrapped.ok_or_else(|| {
286                anyhow!(
287                    "the backup's {DB_FILE} is encrypted but it holds no \
288                     {WRAPPED_STORE_KEY_FILE}; restore a copy of the whole data dir"
289                )
290            })?;
291            SqliteStore::open_with_key(db, machine_id.to_string(), &key)
292        }
293        _ => SqliteStore::open(db, machine_id.to_string()),
294    }
295}
296
297/// Moves the restored store to a store key of its own, so whoever holds
298/// the backup's key or the old identity's `K_id` opens no copy of the
299/// restored device's store.
300fn rekey_restored(store: &SqliteStore, staging: &Path, device: &DeviceKeys) -> Result<()> {
301    let key = StoreKey::generate()?;
302    write_store_key(staging, STORE_KEY_FILE, &key, device)?;
303    store
304        .rewrite_under_key(RewriteTo::Key(&key))
305        .context("rewriting the restored store under a new store key")?;
306    refresh_wrapped_store_key(store, staging, device, &key)
307        .context("wrapping the new store key to the new identity")?;
308    Ok(())
309}
310
311/// Opens every envelope the phrase can open and wraps that epoch to the new
312/// device under its old identity, where it only decrypts.
313fn reopen_old_epochs(
314    store: &SqliteStore,
315    phrase: &RecoveryPhrase,
316    device: &DeviceKeys,
317    now_micros: i64,
318) -> Result<Vec<HeldEpoch>> {
319    let identity = phrase.identity()?;
320    let own = store.machine_id().to_string();
321    let recipient = device.age_recipient();
322    let mut opened = Vec::new();
323    for envelope in store.recovery_envelopes(&phrase.recipient()?)? {
324        let key = match envelope.open(&identity) {
325            Ok(key) => key,
326            Err(e) => {
327                tracing::warn!("skipping a recovery envelope the phrase cannot open: {e:#}");
328                continue;
329            }
330        };
331        let rewrapped = wrap(
332            &key,
333            envelope.epoch.number,
334            &envelope.identity_tag,
335            &recipient,
336            Some(own.clone()),
337        )?;
338        store.put_keys_durably(
339            &envelope.identity_tag,
340            &[envelope.epoch],
341            &[rewrapped],
342            now_micros,
343        )?;
344        opened.push(HeldEpoch::new(envelope.identity_tag, envelope.epoch, key));
345    }
346    if opened.is_empty() {
347        bail!(
348            "this recovery phrase opens no key in the backup; check the phrase, or restore a \
349             backup of a device that trusted it"
350        );
351    }
352    Ok(opened)
353}
354
355/// Wraps each epoch to the new device under its own identity, where it
356/// only decrypts.
357fn keep_epochs(
358    store: &SqliteStore,
359    held: &[HeldEpoch],
360    device: &DeviceKeys,
361    now_micros: i64,
362) -> Result<()> {
363    let own = store.machine_id().to_string();
364    let recipient = device.age_recipient();
365    for h in held {
366        let envelope = wrap(
367            &h.key,
368            h.epoch.number,
369            &h.identity,
370            &recipient,
371            Some(own.clone()),
372        )?;
373        store.put_keys_durably(&h.identity, &[h.epoch], &[envelope], now_micros)?;
374    }
375    Ok(())
376}
377
378enum Swap {
379    /// `data_dir` is as it was; the staged copy can go.
380    Untouched(anyhow::Error),
381    /// Neither copy is at `data_dir`; the error names where both are.
382    Stranded(anyhow::Error),
383}
384
385fn rename(from: &Path, to: &Path) -> io::Result<()> {
386    fs::rename(from, to)
387}
388
389fn swap_in(
390    data_dir: &Path,
391    staging: &Path,
392    base: &str,
393    now_micros: i64,
394    rename: impl Fn(&Path, &Path) -> io::Result<()>,
395) -> Result<Option<PathBuf>, Swap> {
396    let parent = parent_of(data_dir).map_err(Swap::Untouched)?;
397    let moved_aside = match fs::symlink_metadata(data_dir) {
398        Ok(_) => {
399            let carried = HOST_FILES
400                .iter()
401                .try_for_each(|name| carry_over(&data_dir.join(name), &staging.join(name)))
402                .and_then(|()| {
403                    if staging.join(CONFIG_FILE).exists() {
404                        return Ok(());
405                    }
406                    carry_over(&data_dir.join(CONFIG_FILE), &staging.join(CONFIG_FILE))
407                })
408                .and_then(|()| sync_dir(staging));
409            carried.map_err(Swap::Untouched)?;
410            let aside = aside_path(&parent, base, RESTORE_MARKER, now_micros);
411            rename(data_dir, &aside)
412                .with_context(|| {
413                    format!("moving {} aside to {}", data_dir.display(), aside.display())
414                })
415                .map_err(Swap::Untouched)?;
416            Some(aside)
417        }
418        Err(e) if e.kind() == ErrorKind::NotFound => None,
419        Err(e) => {
420            return Err(Swap::Untouched(
421                anyhow!(e).context(format!("reading {}", data_dir.display())),
422            ));
423        }
424    };
425    let Err(e) = rename(staging, data_dir) else {
426        return Ok(moved_aside);
427    };
428    let error = anyhow!(e).context(format!(
429        "moving the restored copy {} into {}",
430        staging.display(),
431        data_dir.display()
432    ));
433    let Some(aside) = moved_aside else {
434        return Err(Swap::Untouched(error));
435    };
436    match rename(&aside, data_dir) {
437        Ok(()) => Err(Swap::Untouched(error)),
438        Err(back) => Err(Swap::Stranded(error.context(format!(
439            "the previous data dir is at {} and could not be moved back ({back}); the restored \
440             copy is at {}",
441            aside.display(),
442            staging.display()
443        )))),
444    }
445}
446
447/// Flushes every file and directory under `dir`, so a power cut after the
448/// swap cannot keep the rename but lose what it points to.
449fn sync_tree(dir: &Path) -> Result<()> {
450    for entry in fs::read_dir(dir).with_context(|| format!("reading {}", dir.display()))? {
451        let entry = entry?;
452        let path = entry.path();
453        let kind = entry.file_type()?;
454        if kind.is_dir() {
455            sync_tree(&path)?;
456        } else if kind.is_file() {
457            fs::File::open(&path)
458                .and_then(|f| f.sync_all())
459                .with_context(|| format!("syncing {}", path.display()))?;
460        }
461    }
462    sync_dir(dir)
463}
464
465fn copy_tree(from: &Path, to: &Path, top: bool) -> Result<()> {
466    for entry in fs::read_dir(from).with_context(|| format!("reading {}", from.display()))? {
467        let entry = entry?;
468        let name = entry.file_name();
469        if top
470            && name.to_str().is_some_and(|n| {
471                LEFT_BEHIND.contains(&n) || LEFT_BEHIND_PREFIXES.iter().any(|p| n.starts_with(p))
472            })
473        {
474            continue;
475        }
476        let source = entry.path();
477        let target = to.join(&name);
478        let kind = entry.file_type()?;
479        if kind.is_dir() {
480            fs::create_dir(&target).with_context(|| format!("creating {}", target.display()))?;
481            copy_tree(&source, &target, false)?;
482        } else if kind.is_file() {
483            fs::copy(&source, &target)
484                .with_context(|| format!("copying {} to {}", source.display(), target.display()))?;
485        } else if kind.is_symlink() {
486            copy_symlink(&source, &target)?;
487        } else {
488            tracing::warn!("restore skips {}, which is not a file", source.display());
489        }
490    }
491    Ok(())
492}
493
494#[cfg(unix)]
495fn copy_symlink(source: &Path, target: &Path) -> Result<()> {
496    let link = fs::read_link(source).with_context(|| format!("reading {}", source.display()))?;
497    std::os::unix::fs::symlink(&link, target)
498        .with_context(|| format!("linking {} to {}", target.display(), link.display()))
499}
500
501#[cfg(not(unix))]
502fn copy_symlink(source: &Path, _target: &Path) -> Result<()> {
503    tracing::warn!("restore skips the link {}", source.display());
504    Ok(())
505}
506
507/// Removes copies a restore cut short by a crash left beside the data dir,
508/// except `backup`, which may be one of them after a failed swap.
509fn remove_stale_staging(parent: &Path, prefix: &str, backup: &Path) {
510    let Ok(entries) = fs::read_dir(parent) else {
511        return;
512    };
513    for entry in entries.flatten() {
514        if !entry.file_name().to_string_lossy().starts_with(prefix)
515            || fs::canonicalize(entry.path()).is_ok_and(|p| p == backup)
516        {
517            continue;
518        }
519        if let Err(e) = fs::remove_dir_all(entry.path()) {
520            tracing::warn!(
521                "cannot remove the partial restore {}: {e}",
522                entry.path().display()
523            );
524        }
525    }
526}
527
528fn with_staging_removed(error: anyhow::Error, staging: &Path) -> anyhow::Error {
529    match fs::remove_dir_all(staging) {
530        Ok(()) => error,
531        Err(e) if e.kind() == ErrorKind::NotFound => error,
532        Err(e) => error.context(format!(
533            "also failed to remove the partial restore {}: {e}",
534            staging.display()
535        )),
536    }
537}
538
539fn parent_of(path: &Path) -> Result<PathBuf> {
540    match path.parent() {
541        Some(dir) if !dir.as_os_str().is_empty() => Ok(dir.to_path_buf()),
542        Some(_) => Ok(PathBuf::from(".")),
543        None => bail!("{} has no parent directory", path.display()),
544    }
545}
546
547fn dir_name(path: &Path) -> Result<String> {
548    path.file_name()
549        .map(|n| n.to_string_lossy().into_owned())
550        .ok_or_else(|| anyhow!("{} has no directory name", path.display()))
551}
552
553#[cfg(test)]
554mod tests {
555    use super::*;
556
557    use crate::keys::{DeviceRecord, Epoch, IdentityKey, create_device_keys};
558    use crate::schema::{Memory, MemoryType};
559    use crate::store::Store;
560
561    const NOW: i64 = 1_793_600_000_000_000;
562
563    struct OldDevice {
564        dir: tempfile::TempDir,
565        tag: IdentityTag,
566        phrase: RecoveryPhrase,
567        memory: Memory,
568    }
569
570    fn open_restored(data_dir: &Path, machine_id: &str) -> SqliteStore {
571        let db = data_dir.join(DB_FILE);
572        if db_file_state(&db).unwrap() != FileState::Encrypted {
573            return SqliteStore::open(&db, machine_id.to_string()).unwrap();
574        }
575        let device = super::super::load_device_keys(data_dir).unwrap().unwrap();
576        let key = super::super::store_key_for(&db, &device).unwrap();
577        SqliteStore::open_with_key(&db, machine_id.to_string(), &key).unwrap()
578    }
579
580    #[cfg(feature = "encryption")]
581    #[test]
582    fn an_encrypted_backup_opens_with_the_phrase_and_comes_back_under_a_new_store_key() {
583        let old = old_device();
584        let old_machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
585        let old_device_keys = super::super::load_device_keys(old.dir.path())
586            .unwrap()
587            .unwrap();
588        {
589            let store =
590                SqliteStore::open(&old.dir.path().join(DB_FILE), old_machine.id.clone()).unwrap();
591            super::super::encrypt_store(&store, old.dir.path(), &old_device_keys).unwrap();
592        }
593        assert!(old.dir.path().join(WRAPPED_STORE_KEY_FILE).exists());
594        let old_store_key =
595            super::super::read_store_key(&old.dir.path().join(STORE_KEY_FILE), &old_device_keys)
596                .unwrap()
597                .unwrap();
598
599        let home = tempfile::tempdir().unwrap();
600        let data_dir = home.path().join(".second-brain");
601        let restored = restore_backup(&RestoreRequest {
602            backup: old.dir.path(),
603            data_dir: &data_dir,
604            phrase: &old.phrase,
605            storage: &KeyStorage::File,
606            now_micros: NOW,
607        })
608        .unwrap();
609
610        let db = data_dir.join(DB_FILE);
611        assert_eq!(db_file_state(&db).unwrap(), FileState::Encrypted);
612        assert!(
613            SqliteStore::open_with_key(&db, restored.machine.id.clone(), &old_store_key).is_err(),
614            "the backup's store key must not open the restored store"
615        );
616        let store = open_restored(&data_dir, &restored.machine.id);
617        assert_eq!(
618            store.get_memory(old.memory.id).unwrap().unwrap().content,
619            old.memory.content
620        );
621        let new_key = super::super::unwrap_store_key_with_phrase(&data_dir, &restored.phrase)
622            .unwrap()
623            .expect("the restored data dir wraps its store key to the new phrase");
624        assert!(SqliteStore::open_with_key(&db, restored.machine.id.clone(), &new_key).is_ok());
625        assert!(
626            super::super::unwrap_store_key_with_phrase(&data_dir, &old.phrase).is_err(),
627            "the old phrase opens no store key of the new identity"
628        );
629    }
630
631    const SEALED_ENTRY: &str = "0000000000000000001-0b5c2f9e-5d0e-4c1a-9a57-0c7f4f1f2a10.sealed";
632
633    fn queued_forget() -> write_queue::Entry {
634        write_queue::Entry {
635            tool: "forget".to_string(),
636            method: "DELETE".to_string(),
637            path: "/v1/memory/m-1".to_string(),
638            query: Some("hard=false&reason=wrong".to_string()),
639            body: None,
640        }
641    }
642
643    /// A data dir of a device that synced with a peer under a migrated
644    /// identity and trusted one recovery phrase.
645    fn old_device() -> OldDevice {
646        let dir = tempfile::tempdir().unwrap();
647        let path = dir.path();
648        let machine = MachineIdentity::load_or_create(path).unwrap();
649        let device = create_device_keys(path, &KeyStorage::File).unwrap();
650        let store = SqliteStore::open(&path.join(DB_FILE), machine.id.clone()).unwrap();
651        store.register_machine(&machine).unwrap();
652
653        let epoch0 = IdentityKey::generate().unwrap();
654        let epoch1 = IdentityKey::generate().unwrap();
655        let tag = IdentityTag::migrated(&epoch0.key_id());
656        let epochs = [
657            Epoch {
658                number: 0,
659                key_id: epoch0.key_id(),
660            },
661            Epoch {
662                number: 1,
663                key_id: epoch1.key_id(),
664            },
665        ];
666        let own = machine.id.clone();
667        let envelopes = [
668            wrap(&epoch0, 0, &tag, &device.age_recipient(), Some(own.clone())).unwrap(),
669            wrap(&epoch1, 1, &tag, &device.age_recipient(), Some(own.clone())).unwrap(),
670        ];
671        let row = DeviceRecord {
672            machine_id: own.clone(),
673            identity_tag: tag.as_str().to_string(),
674            version: 1,
675            name: machine.name.clone(),
676            age_recipient: device.age_recipient().to_string(),
677            ssh_public_key: device.ssh_public_key(),
678            signing_public_key: device.verifying_key().to_bytes(),
679            recovery_fingerprints: Vec::new(),
680            ssh_login: None,
681            ssh_port: None,
682            ssh_host_key: None,
683        }
684        .sign(&own, device.signing_key());
685        store
686            .insert_first_device_record(&row, &own, &device.verifying_key())
687            .unwrap();
688        store
689            .put_keys_durably(&tag, &epochs, &envelopes, NOW)
690            .unwrap();
691
692        let phrase = RecoveryPhrase::generate().unwrap();
693        let held = [(epochs[0], &epoch0), (epochs[1], &epoch1)];
694        wrap_for_recovery(&store, &tag, &held, &[phrase.recipient().unwrap()]).unwrap();
695
696        let memory = Memory::new(
697            "the restored store keeps this".to_string(),
698            MemoryType::Semantic,
699            "test".to_string(),
700            String::new(),
701        );
702        store.store_memory(&memory).unwrap();
703        store.record_peer_ack("old-peer", 3, NOW).unwrap();
704        store.pin_peer("old-peer", 2).unwrap();
705        assert_eq!(store.peer_acks().unwrap().len(), 1);
706        drop(store);
707
708        fs::write(path.join("sync-peers"), "someone@old-peer\n").unwrap();
709        fs::write(path.join(".device.key.0123.tmp"), "half-written key").unwrap();
710        fs::write(path.join("api.token"), "old-token").unwrap();
711        fs::write(path.join(DEVICE_PUB_FILE), "age1old\n").unwrap();
712        fs::write(path.join("service.json"), "{\"from\":\"backup\"}").unwrap();
713        fs::create_dir(path.join("queue")).unwrap();
714        fs::write(path.join("queue").join("pending.json"), "{}").unwrap();
715        fs::write(
716            path.join("queue").join(SEALED_ENTRY),
717            queued_forget()
718                .to_sealed_file(&[device.age_recipient()])
719                .unwrap(),
720        )
721        .unwrap();
722        OldDevice {
723            dir,
724            tag,
725            phrase,
726            memory,
727        }
728    }
729
730    fn pins(store: &SqliteStore) -> i64 {
731        store
732            .conn()
733            .query_row("SELECT COUNT(*) FROM peer_pins", [], |r| r.get(0))
734            .unwrap()
735    }
736
737    #[test]
738    fn the_phrase_restores_a_backup_under_a_new_machine_id_and_identity() {
739        let old = old_device();
740        let old_machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
741        let old_key = fs::read(old.dir.path().join(DEVICE_KEY_FILE)).unwrap();
742
743        let home = tempfile::tempdir().unwrap();
744        let data_dir = home.path().join(".second-brain");
745        fs::create_dir(&data_dir).unwrap();
746        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
747        SqliteStore::open(&data_dir.join(DB_FILE), fresh.id.clone()).unwrap();
748        fs::write(data_dir.join("service.json"), "{\"from\":\"host\"}").unwrap();
749
750        let typed = RecoveryPhrase::parse(&old.phrase.expose_text()).unwrap();
751        let restored = restore_backup(&RestoreRequest {
752            backup: old.dir.path(),
753            data_dir: &data_dir,
754            phrase: &typed,
755            storage: &KeyStorage::File,
756            now_micros: NOW,
757        })
758        .unwrap();
759
760        let machine = MachineIdentity::load_or_create(&data_dir).unwrap();
761        assert_eq!(machine.id, restored.machine.id);
762        assert_ne!(machine.id, old_machine.id);
763        assert_ne!(machine.id, fresh.id);
764        assert_ne!(fs::read(data_dir.join(DEVICE_KEY_FILE)).unwrap(), old_key);
765        assert!(!data_dir.join("sync-peers").exists());
766        assert!(!data_dir.join(".device.key.0123.tmp").exists());
767        assert!(!data_dir.join("api.token").exists());
768        assert!(!data_dir.join(DEVICE_PUB_FILE).exists());
769        assert_eq!(
770            fs::read_to_string(data_dir.join("service.json")).unwrap(),
771            "{\"from\":\"host\"}"
772        );
773        assert!(data_dir.join("queue").join("pending.json").exists());
774        let sealed = fs::read(data_dir.join("queue").join(SEALED_ENTRY)).unwrap();
775        let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
776        let opened = write_queue::open(&sealed, Some(device.age_identity())).unwrap();
777        assert_eq!(opened, queued_forget());
778        let aside = restored.moved_aside.clone().unwrap();
779        assert!(aside.join(DB_FILE).exists());
780        assert_eq!(
781            MachineIdentity::load_or_create(&aside).unwrap().id,
782            fresh.id
783        );
784        assert!(
785            old.dir.path().join("sync-peers").exists(),
786            "the backup is untouched"
787        );
788
789        let expected = if cfg!(feature = "encryption") {
790            FileState::Encrypted
791        } else {
792            FileState::Plaintext
793        };
794        assert_eq!(db_file_state(&data_dir.join(DB_FILE)).unwrap(), expected);
795        let store = open_restored(&data_dir, &machine.id);
796        assert_eq!(
797            store.get_memory(old.memory.id).unwrap().unwrap().content,
798            old.memory.content
799        );
800        let row = store.device_record(&machine.id).unwrap().unwrap();
801        assert_eq!(row.current.record.identity_tag, restored.identity.as_str());
802        assert!(restored.identity.as_str().starts_with("f-"));
803        assert_ne!(restored.identity, old.tag);
804        assert_eq!(restored.opened, vec![old.tag.clone()]);
805        assert_eq!(
806            row.current.record.recovery_fingerprints,
807            vec![restored.phrase.fingerprint().unwrap()]
808        );
809
810        assert!(
811            store.peer_acks().unwrap().is_empty(),
812            "old neighbours are cleared"
813        );
814        assert_eq!(pins(&store), 0);
815
816        let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
817        let mine = store.envelopes_for_machine(&machine.id).unwrap();
818        let old_epochs: Vec<u32> = mine
819            .iter()
820            .filter(|e| e.identity_tag == old.tag)
821            .map(|e| e.epoch.number)
822            .collect();
823        assert_eq!(
824            old_epochs,
825            vec![0, 1],
826            "old epochs stay readable on the new device"
827        );
828        for envelope in &mine {
829            envelope.open(device.age_identity()).unwrap();
830        }
831        let new_epochs = store.key_epochs(&restored.identity).unwrap();
832        assert_eq!(new_epochs.len(), 1);
833        assert_eq!(new_epochs[0].epoch.number, 1);
834
835        let shown = RecoveryPhrase::parse(&restored.phrase.expose_text()).unwrap();
836        let recipients = store.recovery_recipients(&restored.identity).unwrap();
837        assert_eq!(recipients.len(), 1);
838        assert_eq!(
839            recipients[0].to_string(),
840            shown.recipient().unwrap().to_string()
841        );
842        let envelope = store
843            .recovery_envelopes(&shown.recipient().unwrap())
844            .unwrap();
845        assert_eq!(envelope.len(), 3, "the new epoch and both old ones");
846        envelope[0].open(&shown.identity().unwrap()).unwrap();
847        assert!(
848            store
849                .recovery_recipients(&restored.identity)
850                .unwrap()
851                .iter()
852                .all(|r| r.to_string() != old.phrase.recipient().unwrap().to_string()),
853            "the old phrase is not trusted by the new identity"
854        );
855        let leftovers: Vec<_> = fs::read_dir(home.path())
856            .unwrap()
857            .filter_map(|e| e.ok())
858            .filter(|e| e.file_name().to_string_lossy().contains("restoring"))
859            .collect();
860        assert!(leftovers.is_empty());
861    }
862
863    #[test]
864    fn a_second_restore_with_the_new_phrase_opens_every_earlier_identity() {
865        let old = old_device();
866        let first_home = tempfile::tempdir().unwrap();
867        let first_dir = first_home.path().join(".second-brain");
868        let first = restore_backup(&RestoreRequest {
869            backup: old.dir.path(),
870            data_dir: &first_dir,
871            phrase: &old.phrase,
872            storage: &KeyStorage::File,
873            now_micros: NOW,
874        })
875        .unwrap();
876
877        let second_home = tempfile::tempdir().unwrap();
878        let second_dir = second_home.path().join(".second-brain");
879        let second = restore_backup(&RestoreRequest {
880            backup: &first_dir,
881            data_dir: &second_dir,
882            phrase: &first.phrase,
883            storage: &KeyStorage::File,
884            now_micros: NOW,
885        })
886        .unwrap();
887        let opened: BTreeSet<&str> = second.opened.iter().map(IdentityTag::as_str).collect();
888        assert_eq!(
889            opened,
890            BTreeSet::from([old.tag.as_str(), first.identity.as_str()])
891        );
892
893        let store = open_restored(&second_dir, &second.machine.id);
894        let device = super::super::load_device_keys(&second_dir)
895            .unwrap()
896            .unwrap();
897        let mine = store.envelopes_for_machine(&second.machine.id).unwrap();
898        let held = |tag: &IdentityTag| -> Vec<u32> {
899            mine.iter()
900                .filter(|e| &e.identity_tag == tag)
901                .map(|e| {
902                    e.open(device.age_identity()).unwrap();
903                    e.epoch.number
904                })
905                .collect()
906        };
907        assert_eq!(held(&old.tag), vec![0, 1]);
908        assert_eq!(held(&first.identity), vec![1]);
909        assert_eq!(held(&second.identity), vec![1]);
910        let last = store
911            .recovery_envelopes(&second.phrase.recipient().unwrap())
912            .unwrap();
913        assert_eq!(last.len(), 4, "every epoch reaches the newest phrase");
914    }
915
916    #[test]
917    fn a_restore_from_a_stranded_copy_keeps_that_copy() {
918        let old = old_device();
919        let home = tempfile::tempdir().unwrap();
920        let stranded = home.path().join("..second-brain.restoring-0123");
921        fs::create_dir(&stranded).unwrap();
922        copy_tree(old.dir.path(), &stranded, false).unwrap();
923        restore_backup(&RestoreRequest {
924            backup: &stranded,
925            data_dir: &home.path().join(".second-brain"),
926            phrase: &old.phrase,
927            storage: &KeyStorage::File,
928            now_micros: NOW,
929        })
930        .unwrap();
931        assert!(stranded.join(DB_FILE).exists());
932    }
933
934    #[test]
935    fn a_restore_binds_the_new_device_keys_to_this_hardware_not_the_backups() {
936        use crate::keys::{
937            HardwareCheck, HardwareId, check_hardware_with, read_binding, write_binding,
938        };
939
940        struct Here;
941        impl HardwareSource for Here {
942            fn read(&self, _data_dir: &Path) -> HardwareId {
943                HardwareId::parse("disk:the-new-hardware")
944            }
945        }
946
947        let old = old_device();
948        write_binding(
949            old.dir.path(),
950            &HardwareId::parse("disk:the-backups-hardware"),
951        )
952        .unwrap();
953        let home = tempfile::tempdir().unwrap();
954        let data_dir = home.path().join(".second-brain");
955        let restored = restore_with_hardware(
956            &BackupRestore {
957                backup: old.dir.path(),
958                data_dir: &data_dir,
959                keys: BackupKeys::Phrase(&old.phrase),
960                storage: &KeyStorage::File,
961                now_micros: NOW,
962            },
963            &Here,
964        )
965        .unwrap();
966        assert_eq!(
967            read_binding(&data_dir).unwrap(),
968            Some(HardwareId::parse("disk:the-new-hardware"))
969        );
970        assert_eq!(
971            check_hardware_with(&data_dir, &data_dir, &KeyStorage::File, &Here).unwrap(),
972            HardwareCheck::Bound
973        );
974        assert_eq!(
975            MachineIdentity::load_or_create(&data_dir).unwrap().id,
976            restored.machine.id
977        );
978    }
979
980    #[test]
981    fn a_restore_into_a_missing_data_dir_creates_it() {
982        let old = old_device();
983        let home = tempfile::tempdir().unwrap();
984        let data_dir = home.path().join(".second-brain");
985        let stale = home.path().join("..second-brain.restoring-0123");
986        fs::create_dir(&stale).unwrap();
987        fs::write(stale.join(DB_FILE), "left by a crash").unwrap();
988        let restored = restore_backup(&RestoreRequest {
989            backup: old.dir.path(),
990            data_dir: &data_dir,
991            phrase: &old.phrase,
992            storage: &KeyStorage::File,
993            now_micros: NOW,
994        })
995        .unwrap();
996        assert!(restored.moved_aside.is_none());
997        assert!(!stale.exists(), "a crashed restore's copy is removed");
998        assert!(data_dir.join(DB_FILE).exists());
999        assert!(!data_dir.join("service.json").exists());
1000    }
1001
1002    fn handed_from(old: &OldDevice) -> Vec<HeldEpoch> {
1003        let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1004        let device = super::super::load_device_keys(old.dir.path())
1005            .unwrap()
1006            .unwrap();
1007        let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1008        let held = super::super::every_held_epoch(&store, &device).unwrap();
1009        let transit = DeviceKeys::generate().unwrap();
1010        let envelopes = super::super::hand_over(&held, &transit.age_recipient()).unwrap();
1011        super::super::open_handed(&envelopes, &transit).unwrap()
1012    }
1013
1014    #[cfg(feature = "encryption")]
1015    #[test]
1016    fn epochs_a_surviving_device_hands_over_restore_an_encrypted_backup_as_a_new_identity() {
1017        let old = old_device();
1018        let backup = tempfile::tempdir().unwrap();
1019        {
1020            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1021            let device = super::super::load_device_keys(old.dir.path())
1022                .unwrap()
1023                .unwrap();
1024            let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1025            super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1026        }
1027        copy_tree(old.dir.path(), backup.path(), false).unwrap();
1028        let held = {
1029            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1030            let device = super::super::load_device_keys(old.dir.path())
1031                .unwrap()
1032                .unwrap();
1033            let key = super::super::store_key_for(&old.dir.path().join(DB_FILE), &device).unwrap();
1034            let store = SqliteStore::open_with_key(&old.dir.path().join(DB_FILE), machine.id, &key)
1035                .unwrap();
1036            let held = super::super::every_held_epoch(&store, &device).unwrap();
1037            let transit = DeviceKeys::generate().unwrap();
1038            let envelopes = super::super::hand_over(&held, &transit.age_recipient()).unwrap();
1039            super::super::open_handed(&envelopes, &transit).unwrap()
1040        };
1041
1042        let home = tempfile::tempdir().unwrap();
1043        let data_dir = home.path().join(".second-brain");
1044        let restored = restore_backup_with(&BackupRestore {
1045            backup: backup.path(),
1046            data_dir: &data_dir,
1047            keys: BackupKeys::Epochs(&held),
1048            storage: &KeyStorage::File,
1049            now_micros: NOW,
1050        })
1051        .unwrap();
1052
1053        assert_ne!(restored.identity, old.tag);
1054        assert_eq!(restored.opened, vec![old.tag.clone()]);
1055        let store = open_restored(&data_dir, &restored.machine.id);
1056        assert_eq!(
1057            store.get_memory(old.memory.id).unwrap().unwrap().content,
1058            old.memory.content
1059        );
1060        let device = super::super::load_device_keys(&data_dir).unwrap().unwrap();
1061        let kept: Vec<u32> = store
1062            .envelopes_for_machine(&restored.machine.id)
1063            .unwrap()
1064            .iter()
1065            .filter(|e| e.identity_tag == old.tag)
1066            .map(|e| e.epoch.number)
1067            .collect();
1068        assert_eq!(kept, vec![0, 1], "the handed epochs stay decrypt-only");
1069        let opened = super::super::every_held_epoch(&store, &device).unwrap();
1070        assert_eq!(opened.len(), 3, "both old epochs and the new identity's");
1071        let recovery = store
1072            .recovery_envelopes(&restored.phrase.recipient().unwrap())
1073            .unwrap();
1074        assert_eq!(recovery.len(), 3, "the new phrase opens the old epochs too");
1075    }
1076
1077    #[cfg(feature = "encryption")]
1078    #[test]
1079    fn a_surviving_device_restores_onto_itself_with_its_own_past_epochs() {
1080        let old = old_device();
1081        {
1082            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1083            let device = super::super::load_device_keys(old.dir.path())
1084                .unwrap()
1085                .unwrap();
1086            let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1087            super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1088        }
1089        let backup = tempfile::tempdir().unwrap();
1090        copy_tree(old.dir.path(), backup.path(), false).unwrap();
1091        let own = super::super::every_held_epoch_in(old.dir.path(), &KeyStorage::File).unwrap();
1092        assert_eq!(own.len(), 2);
1093
1094        let restored = restore_backup_with(&BackupRestore {
1095            backup: backup.path(),
1096            data_dir: old.dir.path(),
1097            keys: BackupKeys::Epochs(&own),
1098            storage: &KeyStorage::File,
1099            now_micros: NOW,
1100        })
1101        .unwrap();
1102
1103        let aside = restored
1104            .moved_aside
1105            .clone()
1106            .expect("its own store moves aside");
1107        assert!(aside.to_string_lossy().contains(".before-restore-"));
1108        assert!(aside.join(DB_FILE).exists());
1109        assert!(aside.join(DEVICE_KEY_FILE).exists());
1110        assert_eq!(restored.opened, vec![old.tag.clone()]);
1111        assert_eq!(
1112            db_file_state(&backup.path().join(DB_FILE)).unwrap(),
1113            FileState::Encrypted,
1114            "the backup opens only through the wrapped store key"
1115        );
1116        let store = open_restored(old.dir.path(), &restored.machine.id);
1117        assert_eq!(
1118            store.get_memory(old.memory.id).unwrap().unwrap().content,
1119            old.memory.content
1120        );
1121        fs::remove_dir_all(&aside).unwrap();
1122    }
1123
1124    #[cfg(feature = "encryption")]
1125    #[test]
1126    fn handed_epochs_that_do_not_seal_the_backup_change_nothing() {
1127        let old = old_device();
1128        {
1129            let machine = MachineIdentity::load_or_create(old.dir.path()).unwrap();
1130            let device = super::super::load_device_keys(old.dir.path())
1131                .unwrap()
1132                .unwrap();
1133            let store = SqliteStore::open(&old.dir.path().join(DB_FILE), machine.id).unwrap();
1134            super::super::encrypt_store(&store, old.dir.path(), &device).unwrap();
1135        }
1136        let held = handed_from(&old_device());
1137        let home = tempfile::tempdir().unwrap();
1138        let data_dir = home.path().join(".second-brain");
1139        fs::create_dir(&data_dir).unwrap();
1140        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1141
1142        let err = restore_backup_with(&BackupRestore {
1143            backup: old.dir.path(),
1144            data_dir: &data_dir,
1145            keys: BackupKeys::Epochs(&held),
1146            storage: &KeyStorage::File,
1147            now_micros: NOW,
1148        })
1149        .unwrap_err();
1150
1151        assert!(
1152            format!("{err:#}").contains("none of the keys at hand"),
1153            "{err:#}"
1154        );
1155        assert_eq!(
1156            MachineIdentity::load_or_create(&data_dir).unwrap().id,
1157            fresh.id
1158        );
1159        let names: Vec<String> = fs::read_dir(home.path())
1160            .unwrap()
1161            .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
1162            .collect();
1163        assert_eq!(names, vec![".second-brain".to_string()]);
1164    }
1165
1166    #[test]
1167    fn no_handed_epochs_change_nothing() {
1168        let old = old_device();
1169        let home = tempfile::tempdir().unwrap();
1170        let data_dir = home.path().join(".second-brain");
1171        fs::create_dir(&data_dir).unwrap();
1172        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1173
1174        let err = restore_backup_with(&BackupRestore {
1175            backup: old.dir.path(),
1176            data_dir: &data_dir,
1177            keys: BackupKeys::Epochs(&[]),
1178            storage: &KeyStorage::File,
1179            now_micros: NOW,
1180        })
1181        .unwrap_err();
1182
1183        assert!(format!("{err:#}").contains("no key"), "{err:#}");
1184        assert_eq!(
1185            MachineIdentity::load_or_create(&data_dir).unwrap().id,
1186            fresh.id
1187        );
1188    }
1189
1190    #[test]
1191    fn a_wrong_phrase_changes_nothing() {
1192        let old = old_device();
1193        let home = tempfile::tempdir().unwrap();
1194        let data_dir = home.path().join(".second-brain");
1195        fs::create_dir(&data_dir).unwrap();
1196        let fresh = MachineIdentity::load_or_create(&data_dir).unwrap();
1197
1198        let other = RecoveryPhrase::generate().unwrap();
1199        let err = restore_backup(&RestoreRequest {
1200            backup: old.dir.path(),
1201            data_dir: &data_dir,
1202            phrase: &other,
1203            storage: &KeyStorage::File,
1204            now_micros: NOW,
1205        })
1206        .unwrap_err();
1207        assert!(format!("{err:#}").contains("opens no key"), "{err:#}");
1208        assert_eq!(
1209            MachineIdentity::load_or_create(&data_dir).unwrap().id,
1210            fresh.id
1211        );
1212        let names: Vec<String> = fs::read_dir(home.path())
1213            .unwrap()
1214            .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
1215            .collect();
1216        assert_eq!(names, vec![".second-brain".to_string()]);
1217    }
1218
1219    #[test]
1220    fn a_directory_without_a_store_is_not_a_backup() {
1221        let empty = tempfile::tempdir().unwrap();
1222        let home = tempfile::tempdir().unwrap();
1223        let phrase = RecoveryPhrase::generate().unwrap();
1224        let err = restore_backup(&RestoreRequest {
1225            backup: empty.path(),
1226            data_dir: &home.path().join(".second-brain"),
1227            phrase: &phrase,
1228            storage: &KeyStorage::File,
1229            now_micros: NOW,
1230        })
1231        .unwrap_err();
1232        assert!(format!("{err:#}").contains("holds no brain.db"), "{err:#}");
1233    }
1234
1235    /// A rename that fails on calls `first..=last`, counting from 1.
1236    fn failing(first: usize, last: usize) -> impl Fn(&Path, &Path) -> io::Result<()> {
1237        let calls = std::cell::Cell::new(0);
1238        move |from, to| {
1239            calls.set(calls.get() + 1);
1240            if (first..=last).contains(&calls.get()) {
1241                return Err(io::Error::other("injected rename failure"));
1242            }
1243            fs::rename(from, to)
1244        }
1245    }
1246
1247    fn dirs_with_marker(home: &Path) -> (PathBuf, PathBuf) {
1248        let data_dir = home.join(".second-brain");
1249        let staging = home.join(".second-brain.restoring-test");
1250        fs::create_dir(&data_dir).unwrap();
1251        fs::write(data_dir.join("marker"), "old").unwrap();
1252        fs::create_dir(&staging).unwrap();
1253        fs::write(staging.join("marker"), "restored").unwrap();
1254        (data_dir, staging)
1255    }
1256
1257    #[test]
1258    fn a_failed_swap_puts_the_old_data_dir_back() {
1259        let home = tempfile::tempdir().unwrap();
1260        let (data_dir, staging) = dirs_with_marker(home.path());
1261        let Err(Swap::Untouched(err)) =
1262            swap_in(&data_dir, &staging, ".second-brain", NOW, failing(2, 2))
1263        else {
1264            panic!("the swap must fail with the data dir back in place");
1265        };
1266        assert!(format!("{err:#}").contains("injected"), "{err:#}");
1267        assert_eq!(fs::read_to_string(data_dir.join("marker")).unwrap(), "old");
1268        assert!(staging.join("marker").exists());
1269    }
1270
1271    #[test]
1272    fn a_swap_that_cannot_move_back_names_both_copies_and_keeps_them() {
1273        let home = tempfile::tempdir().unwrap();
1274        let (data_dir, staging) = dirs_with_marker(home.path());
1275        let Err(Swap::Stranded(err)) =
1276            swap_in(&data_dir, &staging, ".second-brain", NOW, failing(2, 3))
1277        else {
1278            panic!("the swap must report both copies");
1279        };
1280        let shown = format!("{err:#}");
1281        assert!(shown.contains(&staging.display().to_string()), "{shown}");
1282        assert!(shown.contains("before-restore"), "{shown}");
1283        assert!(staging.join("marker").exists());
1284    }
1285}