1. 1//! `vak office`: the Office engine for scripts and headless machines
2. 2//! (docs/design/72-openxml-documents.md, P5). Each verb only parses its
3. 3//! arguments and prints the worker's JSON answer: reading, applying,
4. 4//! comparing and verifying run in the same broker worker tasks, over the
5. 5//! same op schema, as the Agent's tools and the Review screen, so a file is
6. 6//! never parsed in this process (invariants 14 and 39).
7. 7
8. 8use std::io::Read as _;
9. 9use std::path::{Path, PathBuf};
10. 10
11. 11use crate::cli::OfficeAction;
12. 12
13. 13pub(crate) async fn run_office(action: OfficeAction) -> i32 {
14. 14 let worker = match std::env::current_exe() {
15. 15 Ok(executable) => executable,
16. 16 Err(error) => return fail(&format!("tool broker unavailable: {error}")),
17. 17 };
18. 18 let answer = match action {
19. 19 OfficeAction::Read {
20. 20 file,
21. 21 from,
22. 22 at,
23. 23 structure,
24. 24 facts,
25. 25 } => read(&worker, &file, from, at, structure, facts).await,
26. 26 OfficeAction::Apply {
27. 27 file,
28. 28 ops,
29. 29 base_digest,
30. 30 out,
31. 31 agent,
32. 32 } => {
33. 33 apply(
34. 34 &worker,
35. 35 file.as_deref(),
36. 36 &ops,
37. 37 base_digest.as_deref(),
38. 38 &out,
39. 39 &agent,
40. 40 )
41. 41 .await
42. 42 }
43. 43 OfficeAction::Diff { before, after } => diff(&worker, &before, &after).await,
44. 44 OfficeAction::Verify { file } => return verify(&worker, &file).await,
45. 45 };
46. 46 match answer {
47. 47 Ok(value) => print(&value),
48. 48 Err(error) => fail(&error),
49. 49 }
50. 50}
51. 51
52. 52async fn read(
53. 53 worker: &Path,
54. 54 file: &Path,
55. 55 from: usize,
56. 56 at: Option<String>,
57. 57 structure: bool,
58. 58 facts: bool,
59. 59) -> Result<serde_json::Value, String> {
60. 60 use vak_tools::broker::OfficeView;
61. 61 let view = match (structure, facts, at) {
62. 62 (true, _, _) => OfficeView::Structure,
63. 63 (_, true, _) => OfficeView::Facts,
64. 64 (_, _, Some(anchor)) => OfficeView::At { anchor },
65. 65 _ => OfficeView::Content { from },
66. 66 };
67. 67 vak_tools::broker::office_project(worker, &absolute(file)?, view).await
68. 68}
69. 69
70. 70async fn apply(
71. 71 worker: &Path,
72. 72 file: Option<&Path>,
73. 73 ops: &str,
74. 74 base_digest: Option<&str>,
75. 75 out: &Path,
76. 76 agent: &str,
77. 77) -> Result<serde_json::Value, String> {
78. 78 let text = if ops == "-" {
79. 79 let mut text = String::new();
80. 80 std::io::stdin()
81. 81 .read_to_string(&mut text)
82. 82 .map_err(|error| format!("could not read ops from stdin: {error}"))?;
83. 83 text
84. 84 } else {
85. 85 std::fs::read_to_string(ops).map_err(|error| format!("could not read {ops}: {error}"))?
86. 86 };
87. 87 let ops: Vec<vak_ooxml::edit::OfficeOp> = serde_json::from_str(&text).map_err(|error| {
88. 88 format!("ops are not valid: {error}. Pass a JSON array of ops, each an object with an \"op\" name and only that op's fields")
89. 89 })?;
90. 90 let origin = match (file, base_digest) {
91. 91 (Some(file), Some(base_digest)) => vak_tools::broker::OfficeOrigin::File {
92. 92 path: absolute(file)?,
93. 93 base_digest: base_digest.to_string(),
94. 94 },
95. 95 (None, None) => vak_tools::broker::OfficeOrigin::Blank,
96. 96 (Some(_), None) => {
97. 97 return Err(
98. 98 "--base-digest is required with a file: pass the sha256 `vak office read` printed for it"
99. 99 .into(),
100. 100 );
101. 101 }
102. 102 (None, Some(_)) => {
103. 103 return Err(
104. 104 "--base-digest names the content of a file; give the file, or leave both out to create --out from scratch"
105. 105 .into(),
106. 106 );
107. 107 }
108. 108 };
109. 109 // A new file from the blank or a template is written clean; anything
110. 110 // else is an edit of the file, tracked (docs/design/72, R7).
111. 111 let new_file = file.is_none_or(|file| {
112. 112 file.extension()
113. 113 .and_then(|extension| extension.to_str())
114. 114 .and_then(vak_ooxml::Format::from_extension)
115. 115 .is_some_and(|format| format.kind == vak_ooxml::FormatKind::Template)
116. 116 });
117. 117 let lineage = vak_tools::broker::OfficeLineage {
118. 118 origin,
119. 119 ops,
120. 120 author: vak_tools::office_apply::tracked_change_author(agent),
121. 121 new_file,
122. 122 };
123. 123 vak_tools::broker::office_apply_to(worker, &lineage, &absolute(out)?).await
124. 124}
125. 125
126. 126async fn diff(worker: &Path, before: &Path, after: &Path) -> Result<serde_json::Value, String> {
127. 127 vak_tools::broker::office_review(worker, Some(&absolute(before)?), &absolute(after)?, None)
128. 128 .await
129. 129}
130. 130
131. 131/// Exits 0 when the file passes the Open XML verifier, 1 when it fails.
132. 132async fn verify(worker: &Path, file: &Path) -> i32 {
133. 133 let (root, name) = match absolute(file).and_then(|path| {
134. 134 let name = path
135. 135 .file_name()
136. 136 .and_then(|name| name.to_str())
137. 137 .map(str::to_string)
138. 138 .ok_or_else(|| format!("{} has no file name", path.display()))?;
139. 139 let root = path
140. 140 .parent()
141. 141 .map(Path::to_path_buf)
142. 142 .ok_or_else(|| format!("{} has no directory", path.display()))?;
143. 143 Ok((root, name))
144. 144 }) {
145. 145 Ok(parts) => parts,
146. 146 Err(error) => return fail(&error),
147. 147 };
148. 148 let checks = [vak_sandbox::TargetCheckPlan {
149. 149 verifier: "format.openxml".into(),
150. 150 path: name,
151. 151 }];
152. 152 let results = vak_tools::broker::verify_targets(worker, &root, &checks).await;
153. 153 let passed = results.iter().all(|result| result.status == "passed");
154. 154 let code = print(&serde_json::json!({ "passed": passed, "checks": results }));
155. 155 if code != 0 {
156. 156 code
157. 157 } else if passed {
158. 158 0
159. 159 } else {
160. 160 1
161. 161 }
162. 162}
163. 163
164. 164fn absolute(path: &Path) -> Result<PathBuf, String> {
165. 165 std::path::absolute(path).map_err(|error| format!("{}: {error}", path.display()))
166. 166}
167. 167
168. 168fn print(value: &serde_json::Value) -> i32 {
169. 169 match serde_json::to_string_pretty(value) {
170. 170 Ok(text) => {
171. 171 println!("{text}");
172. 172 0
173. 173 }
174. 174 Err(error) => fail(&error.to_string()),
175. 175 }
176. 176}
177. 177
178. 178fn fail(message: &str) -> i32 {
179. 179 eprintln!("{}", serde_json::json!({ "error": message }));
180. 180 2
181. 181}
182. 182