1. 1//! `vak backup export|import` (docs/design/29-personal-os.md P3) over
2. 2//! `vak_core::backup`. The CLI layer adds the human guardrails the library
3. 3//! deliberately leaves out: refusing to export onto (or import from) the
4. 4//! live home itself, and a loud terminal warning when secrets ride along.
5. 5
6. 6use std::path::{Path, PathBuf};
7. 7
8. 8use vak_core::Core;
9. 9use vak_core::backup::{self, Conflict};
10. 10
11. 11pub fn run_backup(cwd: PathBuf, action: crate::cli::BackupAction) -> i32 {
12. 12 let core = match Core::new(cwd) {
13. 13 Ok(c) => c,
14. 14 Err(e) => {
15. 15 eprintln!("error: {e}");
16. 16 return 2;
17. 17 }
18. 18 };
19. 19 let home = core.sessions_home();
20. 20 match action {
21. 21 crate::cli::BackupAction::Export {
22. 22 dir,
23. 23 include_secrets,
24. 24 } => export(&home, &dir, include_secrets),
25. 25 crate::cli::BackupAction::Import { dir, conflict } => {
26. 26 let Some(mode) = parse_conflict(&conflict) else {
27. 27 eprintln!("error: unknown --conflict '{conflict}' (skip | rename)");
28. 28 return 2;
29. 29 };
30. 30 import(&home, &dir, mode)
31. 31 }
32. 32 }
33. 33}
34. 34
35. 35fn parse_conflict(word: &str) -> Option<Conflict> {
36. 36 match word {
37. 37 "skip" => Some(Conflict::Skip),
38. 38 "rename" => Some(Conflict::Rename),
39. 39 _ => None,
40. 40 }
41. 41}
42. 42
43. 43fn export(home: &Path, dir: &Path, include_secrets: bool) -> i32 {
44. 44 if same_dir(dir, home) {
45. 45 eprintln!(
46. 46 "error: refusing to export into the live vak home ({}) — pick a directory outside it",
47. 47 home.display()
48. 48 );
49. 49 return 2;
50. 50 }
51. 51 if include_secrets {
52. 52 eprintln!();
53. 53 eprintln!("!! WARNING: --include-secrets will copy the local encrypted");
54. 54 eprintln!("!! credential store (if this host uses one) into the destination,");
55. 55 eprintln!("!! including the key that decrypts it. A host using the OS");
56. 56 eprintln!("!! keychain has nothing to copy here — that store is never backed");
57. 57 eprintln!("!! up by this command.");
58. 58 eprintln!("!! Store that directory encrypted and share it with no one.");
59. 59 eprintln!();
60. 60 }
61. 61 match backup::export_to(home, dir, include_secrets) {
62. 62 Ok(manifest) => {
63. 63 println!(
64. 64 "backed up {} file(s), {} bytes → {}",
65. 65 manifest.file_count,
66. 66 manifest.total_bytes,
67. 67 dir.display()
68. 68 );
69. 69 println!("manifest: {}", dir.join("manifest.json").display());
70. 70 if include_secrets && !manifest.secrets_copied {
71. 71 println!(
72. 72 "note: nothing secret was copied (either none stored, or this host uses the OS keychain, which this command cannot back up)"
73. 73 );
74. 74 }
75. 75 0
76. 76 }
77. 77 Err(e) => {
78. 78 eprintln!("error: export failed: {e}");
79. 79 1
80. 80 }
81. 81 }
82. 82}
83. 83
84. 84fn import(home: &Path, dir: &Path, conflict: Conflict) -> i32 {
85. 85 if same_dir(dir, home) {
86. 86 eprintln!(
87. 87 "error: refusing to import from the live vak home ({}) — pick a backup directory outside it",
88. 88 home.display()
89. 89 );
90. 90 return 2;
91. 91 }
92. 92 match backup::import_from(dir, home, conflict) {
93. 93 Ok(report) => {
94. 94 println!(
95. 95 "restored {} file(s) into {} ({} renamed aside, {} skipped as already present)",
96. 96 report.copied,
97. 97 home.display(),
98. 98 report.renamed,
99. 99 report.skipped
100. 100 );
101. 101 0
102. 102 }
103. 103 Err(e) => {
104. 104 eprintln!("error: import failed: {e}");
105. 105 1
106. 106 }
107. 107 }
108. 108}
109. 109
110. 110/// Same-directory refusal must survive symlinks and trailing separators,
111. 111/// so compare canonical forms when both sides resolve.
112. 112fn same_dir(a: &Path, b: &Path) -> bool {
113. 113 match (a.canonicalize(), b.canonicalize()) {
114. 114 (Ok(ca), Ok(cb)) => ca == cb,
115. 115 _ => a == b,
116. 116 }
117. 117}
118. 118
119. 119#[cfg(test)]
120. 120mod tests {
121. 121 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
122. 122 use super::*;
123. 123
124. 124 #[test]
125. 125 fn same_dir_detects_alias_forms() {
126. 126 let dir = tempfile::tempdir().unwrap();
127. 127 let inner = dir.path().join("home");
128. 128 std::fs::create_dir_all(&inner).unwrap();
129. 129 assert!(same_dir(&inner, &inner));
130. 130 assert!(same_dir(
131. 131 &inner.join("."),
132. 132 &std::fs::canonicalize(&inner).unwrap()
133. 133 ));
134. 134 assert!(!same_dir(&inner, &dir.path().join("other")));
135. 135 }
136. 136
137. 137 #[test]
138. 138 fn conflict_words_map_to_modes() {
139. 139 assert_eq!(parse_conflict("skip"), Some(Conflict::Skip));
140. 140 assert_eq!(parse_conflict("rename"), Some(Conflict::Rename));
141. 141 assert_eq!(parse_conflict("merge"), None);
142. 142 assert_eq!(parse_conflict(""), None);
143. 143 }
144. 144}
145. 145