1. 1//! Shared, versioned editing rooms for one Office file in a saved candidate.
2. 2//!
3. 3//! Room metadata is a replaceable snapshot for fast reads; its revisions are
4. 4//! append-only entries, each pointing at an immutable saved candidate. Office
5. 5//! bytes are always produced and checked by the document worker.
6. 6
7. 7use axum::{
8. 8 Json,
9. 9 extract::{Path, State},
10. 10 http::StatusCode,
11. 11 response::IntoResponse,
12. 12};
13. 13use serde::{Deserialize, Serialize};
14. 14use std::{
15. 15 fs,
16. 16 path::{Path as FsPath, PathBuf},
17. 17};
18. 18
19. 19use crate::{AppState, AuthenticatedPrincipal};
20. 20
21. 21const MAX_OPS: usize = 32;
22. 22const MAX_OPERATION_BYTES: usize = 32 * 1024;
23. 23
24. 24#[derive(Debug, Clone, Serialize, Deserialize)]
25. 25struct OfficeRoom {
26. 26 schema: u32,
27. 27 room_id: String,
28. 28 session_id: String,
29. 29 path: String,
30. 30 created_at: String,
31. 31 branches: Vec<OfficeBranch>,
32. 32 revisions: Vec<OfficeRevision>,
33. 33}
34. 34
35. 35#[derive(Debug, Clone, Serialize, Deserialize)]
36. 36struct OfficeBranch {
37. 37 branch_id: String,
38. 38 name: String,
39. 39 base_candidate_id: String,
40. 40 head_candidate_id: String,
41. 41 shared: bool,
42. 42 archived: bool,
43. 43}
44. 44
45. 45#[derive(Debug, Clone, Serialize, Deserialize)]
46. 46struct OfficeRevision {
47. 47 candidate_id: String,
48. 48 parent_candidate_id: String,
49. 49 #[serde(default)]
50. 50 merge_parent_candidate_id: Option<String>,
51. 51 branch_id: String,
52. 52 author_id: String,
53. 53 author_name: String,
54. 54 created_at: String,
55. 55 ops: Vec<vak_ooxml::edit::OfficeOp>,
56. 56}
57. 57
58. 58#[derive(Debug, Deserialize)]
59. 59pub(super) struct CreateBody {
60. 60 candidate_id: String,
61. 61 path: String,
62. 62}
63. 63
64. 64#[derive(Debug, Deserialize)]
65. 65#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
66. 66pub(super) enum Action {
67. 67 Branch {
68. 68 name: String,
69. 69 expected_head: String,
70. 70 },
71. 71 Edit {
72. 72 branch_id: String,
73. 73 expected_head: String,
74. 74 ops: Vec<vak_ooxml::edit::OfficeOp>,
75. 75 },
76. 76 Merge {
77. 77 branch_id: String,
78. 78 expected_shared_head: String,
79. 79 },
80. 80 Import {
81. 81 branch_id: String,
82. 82 expected_head: String,
83. 83 candidate_id: String,
84. 84 },
85. 85}
86. 86
87. 87#[derive(Debug, Deserialize)]
88. 88pub(super) struct FocusBody {
89. 89 anchor: Option<String>,
90. 90 #[serde(default = "default_focus_active")]
91. 91 active: bool,
92. 92}
93. 93
94. 94fn default_focus_active() -> bool {
95. 95 true
96. 96}
97. 97
98. 98fn id_ok(value: &str) -> bool {
99. 99 !value.is_empty()
100. 100 && value.len() <= 128
101. 101 && value
102. 102 .bytes()
103. 103 .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
104. 104}
105. 105
106. 106fn room_path(state: &AppState, session_id: &str, room_id: &str) -> Option<PathBuf> {
107. 107 if !id_ok(session_id) || !id_ok(room_id) {
108. 108 return None;
109. 109 }
110. 110 Some(
111. 111 vak_config::paths::office_workspaces_at(&state.core.sessions_home(), session_id)
112. 112 .join(format!("{room_id}.json")),
113. 113 )
114. 114}
115. 115
116. 116fn load(path: &FsPath) -> Result<OfficeRoom, ()> {
117. 117 let bytes = fs::read(path).map_err(|_| ())?;
118. 118 if bytes.len() > 4 * 1024 * 1024 {
119. 119 return Err(());
120. 120 }
121. 121 serde_json::from_slice(&bytes).map_err(|_| ())
122. 122}
123. 123
124. 124fn save(path: &FsPath, room: &OfficeRoom) -> Result<(), ()> {
125. 125 let parent = path.parent().ok_or(())?;
126. 126 fs::create_dir_all(parent).map_err(|_| ())?;
127. 127 let temp = parent.join(format!(".{}.{}.tmp", room.room_id, uuid::Uuid::now_v7()));
128. 128 let bytes = serde_json::to_vec(room).map_err(|_| ())?;
129. 129 if bytes.len() > 4 * 1024 * 1024 {
130. 130 return Err(());
131. 131 }
132. 132 let result = (|| {
133. 133 use std::io::Write;
134. 134 let mut file = fs::OpenOptions::new()
135. 135 .write(true)
136. 136 .create_new(true)
137. 137 .open(&temp)?;
138. 138 file.write_all(&bytes)?;
139. 139 file.sync_all()?;
140. 140 fs::rename(&temp, path)?;
141. 141 Ok::<(), std::io::Error>(())
142. 142 })();
143. 143 if result.is_err() {
144. 144 let _ = fs::remove_file(temp);
145. 145 }
146. 146 result.map_err(|_| ())
147. 147}
148. 148
149. 149fn authority(
150. 150 state: &AppState,
151. 151 session_id: &str,
152. 152 principal: &AuthenticatedPrincipal,
153. 153 edit: bool,
154. 154) -> Result<(String, String, String), StatusCode> {
155. 155 match principal {
156. 156 AuthenticatedPrincipal::Operator => Ok(("operator".into(), "You".into(), "owner".into())),
157. 157 AuthenticatedPrincipal::Participant(p) => {
158. 158 let audience =
159. 159 super::conversation_audience(state, session_id).ok_or(StatusCode::NOT_FOUND)?;
160. 160 if p.conversation_id != session_id
161. 161 || p.audience_id != audience
162. 162 || !p.capabilities.iter().any(|c| c == "read")
163. 163 {
164. 164 return Err(StatusCode::FORBIDDEN);
165. 165 }
166. 166 if edit && !p.capabilities.iter().any(|c| c == "edit") {
167. 167 return Err(StatusCode::FORBIDDEN);
168. 168 }
169. 169 Ok((
170. 170 p.principal_id.clone(),
171. 171 p.display_name.clone(),
172. 172 p.grant_id.clone(),
173. 173 ))
174. 174 }
175. 175 }
176. 176}
177. 177
178. 178pub(super) async fn create(
179. 179 State(state): State<AppState>,
180. 180 Path(session_id): Path<String>,
181. 181 axum::Extension(principal): axum::Extension<AuthenticatedPrincipal>,
182. 182 Json(body): Json<CreateBody>,
183. 183) -> axum::response::Response {
184. 184 if !matches!(principal, AuthenticatedPrincipal::Operator) {
185. 185 return StatusCode::FORBIDDEN.into_response();
186. 186 }
187. 187 if !vak_ooxml::is_openxml_path(&body.path) {
188. 188 return (
189. 189 StatusCode::BAD_REQUEST,
190. 190 "Choose a Word, Excel, PowerPoint or Visio file.",
191. 191 )
192. 192 .into_response();
193. 193 }
194. 194 let saved = match super::saved_candidate(&state, &session_id, &body.candidate_id) {
195. 195 Ok(v) => v,
196. 196 Err(s) => return s.into_response(),
197. 197 };
198. 198 if !saved
199. 199 .candidate
200. 200 .files
201. 201 .iter()
202. 202 .any(|f| f.path == body.path && f.operation == vak_sandbox::CandidateOperation::Upsert)
203. 203 {
204. 204 return StatusCode::NOT_FOUND.into_response();
205. 205 }
206. 206 if let Err(status) =
207. 207 super::sandbox_candidate_file_bytes(&state, &session_id, &body.candidate_id, &body.path)
208. 208 .await
209. 209 {
210. 210 return status.into_response();
211. 211 }
212. 212 let room_id = uuid::Uuid::now_v7().to_string();
213. 213 let now = chrono::Utc::now().to_rfc3339();
214. 214 let room = OfficeRoom {
215. 215 schema: 1,
216. 216 room_id: room_id.clone(),
217. 217 session_id: session_id.clone(),
218. 218 path: body.path,
219. 219 created_at: now.clone(),
220. 220 branches: vec![OfficeBranch {
221. 221 branch_id: "shared".into(),
222. 222 name: "Shared draft".into(),
223. 223 base_candidate_id: body.candidate_id.clone(),
224. 224 head_candidate_id: body.candidate_id.clone(),
225. 225 shared: true,
226. 226 archived: false,
227. 227 }],
228. 228 revisions: vec![OfficeRevision {
229. 229 candidate_id: body.candidate_id,
230. 230 parent_candidate_id: String::new(),
231. 231 merge_parent_candidate_id: None,
232. 232 branch_id: "shared".into(),
233. 233 author_id: "operator".into(),
234. 234 author_name: "You".into(),
235. 235 created_at: now,
236. 236 ops: Vec::new(),
237. 237 }],
238. 238 };
239. 239 let Some(path) = room_path(&state, &session_id, &room_id) else {
240. 240 return StatusCode::BAD_REQUEST.into_response();
241. 241 };
242. 242 if save(&path, &room).is_err() {
243. 243 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
244. 244 }
245. 245 Json(room).into_response()
246. 246}
247. 247
248. 248pub(super) async fn list(
249. 249 State(state): State<AppState>,
250. 250 Path(session_id): Path<String>,
251. 251 axum::Extension(principal): axum::Extension<AuthenticatedPrincipal>,
252. 252) -> axum::response::Response {
253. 253 if !id_ok(&session_id) {
254. 254 return StatusCode::BAD_REQUEST.into_response();
255. 255 }
256. 256 if let Err(status) = authority(&state, &session_id, &principal, false) {
257. 257 return status.into_response();
258. 258 }
259. 259 let root = vak_config::paths::office_workspaces_at(&state.core.sessions_home(), &session_id);
260. 260 let entries = match fs::read_dir(root) {
261. 261 Ok(e) => e,
262. 262 Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
263. 263 return Json(serde_json::json!({"workspaces": []})).into_response();
264. 264 }
265. 265 Err(_) => return StatusCode::INTERNAL_SERVER_ERROR.into_response(),
266. 266 };
267. 267 let mut rooms = Vec::new();
268. 268 for entry in entries.flatten() {
269. 269 if entry.path().extension().is_some_and(|e| e == "json") {
270. 270 match load(&entry.path()) {
271. 271 Ok(room) if room.session_id == session_id => rooms.push(room),
272. 272 Ok(_) => return StatusCode::FORBIDDEN.into_response(),
273. 273 Err(_) => return StatusCode::INTERNAL_SERVER_ERROR.into_response(),
274. 274 }
275. 275 }
276. 276 }
277. 277 rooms.sort_by(|a, b| a.created_at.cmp(&b.created_at));
278. 278 Json(serde_json::json!({"workspaces": rooms})).into_response()
279. 279}
280. 280
281. 281pub(super) async fn focus(
282. 282 State(state): State<AppState>,
283. 283 Path((session_id, room_id)): Path<(String, String)>,
284. 284 axum::Extension(principal): axum::Extension<AuthenticatedPrincipal>,
285. 285 Json(body): Json<FocusBody>,
286. 286) -> axum::response::Response {
287. 287 let (principal_id, display_name, _) = match authority(&state, &session_id, &principal, false) {
288. 288 Ok(v) => v,
289. 289 Err(s) => return s.into_response(),
290. 290 };
291. 291 let Some(path) = room_path(&state, &session_id, &room_id) else {
292. 292 return StatusCode::BAD_REQUEST.into_response();
293. 293 };
294. 294 let room = match load(&path) {
295. 295 Ok(room) if room.session_id == session_id => room,
296. 296 Ok(_) => return StatusCode::FORBIDDEN.into_response(),
297. 297 Err(_) => return StatusCode::NOT_FOUND.into_response(),
298. 298 };
299. 299 if body
300. 300 .anchor
301. 301 .as_deref()
302. 302 .is_some_and(|anchor| anchor.len() > 256 || !vak_ooxml::is_anchor(anchor))
303. 303 {
304. 304 return StatusCode::BAD_REQUEST.into_response();
305. 305 }
306. 306 super::touch_coworking_presence(&state, &session_id, &principal_id, &display_name);
307. 307 if let Ok(mut all) = state.coworking_presence.lock()
308. 308 && let Some(presence) = all
309. 309 .get_mut(&session_id)
310. 310 .and_then(|people| people.get_mut(&principal_id))
311. 311 {
312. 312 presence.office_room_id = body.active.then(|| room_id.clone());
313. 313 presence.office_anchor = body.active.then_some(body.anchor).flatten();
314. 314 presence.seen_at = std::time::Instant::now();
315. 315 }
316. 316 if let Some(handle) = state.get(&session_id) {
317. 317 let _ = handle.coworking_comments_tx.send(());
318. 318 }
319. 319 Json(serde_json::json!({"ok":true,"room_id":room.room_id})).into_response()
320. 320}
321. 321
322. 322pub(super) async fn mutate(
323. 323 State(state): State<AppState>,
324. 324 Path((session_id, room_id)): Path<(String, String)>,
325. 325 axum::Extension(principal): axum::Extension<AuthenticatedPrincipal>,
326. 326 Json(action): Json<Action>,
327. 327) -> axum::response::Response {
328. 328 let (actor_id, actor_name, _grant) = match authority(&state, &session_id, &principal, true) {
329. 329 Ok(v) => v,
330. 330 Err(s) => return s.into_response(),
331. 331 };
332. 332 let Some(path) = room_path(&state, &session_id, &room_id) else {
333. 333 return StatusCode::BAD_REQUEST.into_response();
334. 334 };
335. 335 let lock_path = path.with_extension("lock");
336. 336 if let Some(parent) = lock_path.parent()
337. 337 && fs::create_dir_all(parent).is_err()
338. 338 {
339. 339 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
340. 340 }
341. 341 let lock = match fs::OpenOptions::new()
342. 342 .read(true)
343. 343 .write(true)
344. 344 .create(true)
345. 345 .truncate(false)
346. 346 .open(&lock_path)
347. 347 {
348. 348 Ok(f) => f,
349. 349 Err(_) => return StatusCode::INTERNAL_SERVER_ERROR.into_response(),
350. 350 };
351. 351 if lock.try_lock().is_err() {
352. 352 return (
353. 353 StatusCode::CONFLICT,
354. 354 Json(serde_json::json!({"error":"This draft is being updated; try again shortly."})),
355. 355 )
356. 356 .into_response();
357. 357 }
358. 358 let mut room = match load(&path) {
359. 359 Ok(r) if r.session_id == session_id && r.room_id == room_id => r,
360. 360 Ok(_) => return StatusCode::FORBIDDEN.into_response(),
361. 361 Err(_) => return StatusCode::NOT_FOUND.into_response(),
362. 362 };
363. 363 let (branch_id, current_head) = match &action {
364. 364 Action::Branch { expected_head, .. } => ("shared", expected_head),
365. 365 Action::Edit {
366. 366 branch_id,
367. 367 expected_head,
368. 368 ..
369. 369 }
370. 370 | Action::Import {
371. 371 branch_id,
372. 372 expected_head,
373. 373 ..
374. 374 } => (branch_id.as_str(), expected_head),
375. 375 Action::Merge {
376. 376 branch_id: _,
377. 377 expected_shared_head,
378. 378 } => ("shared", expected_shared_head),
379. 379 };
380. 380 let Some(branch_pos) = room
381. 381 .branches
382. 382 .iter()
383. 383 .position(|b| b.branch_id == branch_id && !b.archived)
384. 384 else {
385. 385 return StatusCode::NOT_FOUND.into_response();
386. 386 };
387. 387 if room.branches[branch_pos].head_candidate_id != *current_head {
388. 388 return (StatusCode::CONFLICT, Json(serde_json::json!({"error":"This version changed. Reload the draft before editing."}))).into_response();
389. 389 }
390. 390 match action {
391. 391 Action::Branch { name, .. } => {
392. 392 let name = name.trim();
393. 393 if name.is_empty()
394. 394 || name.chars().count() > 80
395. 395 || name.chars().any(char::is_control)
396. 396 || room.branches.len() >= 24
397. 397 {
398. 398 return StatusCode::BAD_REQUEST.into_response();
399. 399 }
400. 400 let branch_id = uuid::Uuid::now_v7().to_string();
401. 401 let base = room.branches[branch_pos].head_candidate_id.clone();
402. 402 room.branches.push(OfficeBranch {
403. 403 branch_id: branch_id.clone(),
404. 404 name: name.into(),
405. 405 base_candidate_id: base.clone(),
406. 406 head_candidate_id: base,
407. 407 shared: false,
408. 408 archived: false,
409. 409 });
410. 410 if save(&path, &room).is_err() {
411. 411 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
412. 412 }
413. 413 Json(serde_json::json!({"workspace":room})).into_response()
414. 414 }
415. 415 Action::Edit { branch_id, ops, .. } => {
416. 416 if ops.is_empty()
417. 417 || ops.len() > MAX_OPS
418. 418 || serde_json::to_vec(&ops).map_or(true, |b| b.len() > MAX_OPERATION_BYTES)
419. 419 {
420. 420 return StatusCode::BAD_REQUEST.into_response();
421. 421 }
422. 422 return create_revision(
423. 423 &state, &path, room, branch_pos, branch_id, actor_id, actor_name, ops, None,
424. 424 )
425. 425 .await;
426. 426 }
427. 427 Action::Import {
428. 428 branch_id,
429. 429 candidate_id,
430. 430 ..
431. 431 } => {
432. 432 let imported = match super::saved_candidate(&state, &session_id, &candidate_id) {
433. 433 Ok(c) => c,
434. 434 Err(s) => return s.into_response(),
435. 435 };
436. 436 if !imported.candidate.files.iter().any(|f| {
437. 437 f.path == room.path && f.operation == vak_sandbox::CandidateOperation::Upsert
438. 438 }) {
439. 439 return StatusCode::BAD_REQUEST.into_response();
440. 440 }
441. 441 let parent_id = room.branches[branch_pos].head_candidate_id.clone();
442. 442 let imported_parent_id = match imported.parent_candidate_id.as_deref() {
443. 443 Some(id) => id.to_string(),
444. 444 None => {
445. 445 return (
446. 446 StatusCode::CONFLICT,
447. 447 "This saved version has no recorded base to compare against.",
448. 448 )
449. 449 .into_response();
450. 450 }
451. 451 };
452. 452 let base_bytes = match super::sandbox_candidate_file_bytes(
453. 453 &state,
454. 454 &session_id,
455. 455 &imported_parent_id,
456. 456 &room.path,
457. 457 )
458. 458 .await
459. 459 {
460. 460 Ok(b) => b,
461. 461 Err(s) => return s.into_response(),
462. 462 };
463. 463 let head_bytes = match super::sandbox_candidate_file_bytes(
464. 464 &state,
465. 465 &session_id,
466. 466 &parent_id,
467. 467 &room.path,
468. 468 )
469. 469 .await
470. 470 {
471. 471 Ok(b) => b,
472. 472 Err(s) => return s.into_response(),
473. 473 };
474. 474 let base_hash = vak_sandbox::digest(&base_bytes);
475. 475 let head_hash = vak_sandbox::digest(&head_bytes);
476. 476 if base_hash != head_hash {
477. 477 return (StatusCode::CONFLICT, Json(serde_json::json!({"error":"The Agent version starts from another document version. Review it separately or start a branch from that version."}))).into_response();
478. 478 }
479. 479 let lineage = match super::office_lineage(
480. 480 &state,
481. 481 &session_id,
482. 482 &imported.execution_id,
483. 483 &room.path,
484. 484 ) {
485. 485 Ok(lineage) => lineage,
486. 486 Err(reason) => {
487. 487 return (
488. 488 StatusCode::CONFLICT,
489. 489 Json(serde_json::json!({"error":reason})),
490. 490 )
491. 491 .into_response();
492. 492 }
493. 493 };
494. 494 if let Err(status) =
495. 495 super::sandbox_candidate_file_bytes(&state, &session_id, &candidate_id, &room.path)
496. 496 .await
497. 497 {
498. 498 return status.into_response();
499. 499 }
500. 500 let branch = &mut room.branches[branch_pos];
501. 501 branch.head_candidate_id = candidate_id.clone();
502. 502 room.revisions.push(OfficeRevision {
503. 503 candidate_id,
504. 504 parent_candidate_id: parent_id,
505. 505 merge_parent_candidate_id: None,
506. 506 branch_id,
507. 507 author_id: actor_id,
508. 508 author_name: actor_name,
509. 509 created_at: chrono::Utc::now().to_rfc3339(),
510. 510 ops: lineage.ops,
511. 511 });
512. 512 if save(&path, &room).is_err() {
513. 513 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
514. 514 }
515. 515 Json(serde_json::json!({"workspace":room})).into_response()
516. 516 }
517. 517 Action::Merge { branch_id, .. } => {
518. 518 let shared_head = room.branches[branch_pos].head_candidate_id.clone();
519. 519 let Some(other_pos) = room
520. 520 .branches
521. 521 .iter()
522. 522 .position(|b| b.branch_id == branch_id && !b.shared && !b.archived)
523. 523 else {
524. 524 return StatusCode::NOT_FOUND.into_response();
525. 525 };
526. 526 let source_head = room.branches[other_pos].head_candidate_id.clone();
527. 527 if source_head == shared_head {
528. 528 return Json(room).into_response();
529. 529 }
530. 530 let base = room.branches[other_pos].base_candidate_id.clone();
531. 531 let shared_ops = operations_since(&room, &shared_head, &base);
532. 532 let branch_ops = operations_since(&room, &source_head, &base);
533. 533 let (Some(shared_ops), Some(branch_ops)) = (shared_ops, branch_ops) else {
534. 534 return (StatusCode::CONFLICT, Json(serde_json::json!({"error":"These versions no longer share a mergeable base."}))).into_response();
535. 535 };
536. 536 if has_conflict(&shared_ops, &branch_ops) {
537. 537 return (StatusCode::CONFLICT, Json(serde_json::json!({"error":"Both versions changed the same document area. Review them separately; this merge needs a manual edit."}))).into_response();
538. 538 }
539. 539 return create_revision(
540. 540 &state,
541. 541 &path,
542. 542 room,
543. 543 branch_pos,
544. 544 "shared".into(),
545. 545 actor_id,
546. 546 actor_name,
547. 547 branch_ops,
548. 548 Some(source_head),
549. 549 )
550. 550 .await;
551. 551 }
552. 552 }
553. 553}
554. 554
555. 555#[allow(clippy::too_many_arguments)]
556. 556async fn create_revision(
557. 557 state: &AppState,
558. 558 path: &FsPath,
559. 559 mut room: OfficeRoom,
560. 560 branch_pos: usize,
561. 561 branch_id: String,
562. 562 actor_id: String,
563. 563 actor_name: String,
564. 564 ops: Vec<vak_ooxml::edit::OfficeOp>,
565. 565 merge_parent: Option<String>,
566. 566) -> axum::response::Response {
567. 567 let parent_id = room.branches[branch_pos].head_candidate_id.clone();
568. 568 let session_id = room.session_id.clone();
569. 569 let parent = match super::saved_candidate(state, &session_id, &parent_id) {
570. 570 Ok(c) => c,
571. 571 Err(s) => return s.into_response(),
572. 572 };
573. 573 let Some(parent_file) =
574. 574 parent.candidate.files.iter().find(|f| {
575. 575 f.path == room.path && f.operation == vak_sandbox::CandidateOperation::Upsert
576. 576 })
577. 577 else {
578. 578 return StatusCode::CONFLICT.into_response();
579. 579 };
580. 580 let id = uuid::Uuid::now_v7().to_string();
581. 581 let staging_root = state
582. 582 .core
583. 583 .sessions_home()
584. 584 .join("sandbox")
585. 585 .join("staging")
586. 586 .join(&id);
587. 587 if vak_sandbox::prepare_revision_copy(&parent.candidate, &staging_root).is_err() {
588. 588 return StatusCode::CONFLICT.into_response();
589. 589 }
590. 590 let Some(draft_path) = super::confined_path(&staging_root, &room.path) else {
591. 591 let _ = fs::remove_dir_all(&staging_root);
592. 592 return StatusCode::FORBIDDEN.into_response();
593. 593 };
594. 594 let Some(parent_source) = super::confined_path(&parent.candidate.source_root, &room.path)
595. 595 else {
596. 596 let _ = fs::remove_dir_all(&staging_root);
597. 597 return StatusCode::FORBIDDEN.into_response();
598. 598 };
599. 599 let Some(extension) = FsPath::new(&room.path).extension().and_then(|e| e.to_str()) else {
600. 600 let _ = fs::remove_dir_all(&staging_root);
601. 601 return StatusCode::BAD_REQUEST.into_response();
602. 602 };
603. 603 let output_path = draft_path.with_file_name(format!("vak-{id}.{extension}"));
604. 604 let lineage = vak_tools::broker::OfficeLineage {
605. 605 origin: vak_tools::broker::OfficeOrigin::File {
606. 606 path: parent_source,
607. 607 base_digest: parent_file.candidate_hash.clone(),
608. 608 },
609. 609 ops: ops.clone(),
610. 610 author: actor_name.clone(),
611. 611 new_file: false,
612. 612 };
613. 613 let applied = match vak_tools::broker::office_apply_to(
614. 614 &state.core.tool_worker_exe(),
615. 615 &lineage,
616. 616 &output_path,
617. 617 )
618. 618 .await
619. 619 {
620. 620 Ok(a) => a,
621. 621 Err(e) => {
622. 622 let _ = fs::remove_dir_all(&staging_root);
623. 623 return (
624. 624 StatusCode::UNPROCESSABLE_ENTITY,
625. 625 Json(serde_json::json!({"error":e})),
626. 626 )
627. 627 .into_response();
628. 628 }
629. 629 };
630. 630 if fs::remove_file(&draft_path).is_err() || fs::rename(&output_path, &draft_path).is_err() {
631. 631 let _ = fs::remove_dir_all(&staging_root);
632. 632 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
633. 633 }
634. 634 let frozen_root = super::sandbox_candidates_root(state).join(&id);
635. 635 let candidate = match vak_sandbox::freeze_revision_candidate(
636. 636 &id,
637. 637 &staging_root,
638. 638 &parent.candidate,
639. 639 &frozen_root,
640. 640 ) {
641. 641 Ok(c) => c,
642. 642 Err(e) => {
643. 643 let _ = fs::remove_dir_all(&staging_root);
644. 644 return (
645. 645 StatusCode::UNPROCESSABLE_ENTITY,
646. 646 Json(serde_json::json!({"error":e.to_string()})),
647. 647 )
648. 648 .into_response();
649. 649 }
650. 650 };
651. 651 let _ = fs::remove_dir_all(&staging_root);
652. 652 let mut candidate = candidate;
653. 653 candidate.target_checks = vak_sandbox::default_target_verifiers().plan(&candidate);
654. 654 candidate.workspace_checks = super::planned_workspace_checks(&candidate);
655. 655 let draft_checks = vak_tools::broker::verify_targets(
656. 656 &state.core.tool_worker_exe(),
657. 657 &candidate.source_root,
658. 658 &candidate.target_checks,
659. 659 )
660. 660 .await;
661. 661 let digest = match vak_sandbox::candidate_digest(&candidate) {
662. 662 Ok(d) => d,
663. 663 Err(_) => {
664. 664 let _ = vak_sandbox::remove_frozen_candidate(&frozen_root);
665. 665 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
666. 666 }
667. 667 };
668. 668 let saved = vak_sandbox::CandidateRecord {
669. 669 record_id: format!("candidate-{id}"),
670. 670 session_id: parent.session_id.clone(),
671. 671 turn_id: parent.turn_id.clone(),
672. 672 result_id: parent.result_id.clone(),
673. 673 execution_id: parent.execution_id.clone(),
674. 674 environment_id: "office-workspace".into(),
675. 675 candidate_digest: digest,
676. 676 candidate,
677. 677 verified: true,
678. 678 draft_checks,
679. 679 updated_at: chrono::Utc::now().to_rfc3339(),
680. 680 parent_candidate_id: Some(parent_id.clone()),
681. 681 revision_session_id: None,
682. 682 narrowed: None,
683. 683 };
684. 684 if vak_sandbox::append_record(
685. 685 &super::sandbox_records_path(state),
686. 686 &vak_sandbox::DurableRecord::Candidate(saved.clone()),
687. 687 )
688. 688 .is_err()
689. 689 {
690. 690 let _ = vak_sandbox::remove_frozen_candidate(&frozen_root);
691. 691 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
692. 692 }
693. 693 room.branches[branch_pos].head_candidate_id = id.clone();
694. 694 room.revisions.push(OfficeRevision {
695. 695 candidate_id: id,
696. 696 parent_candidate_id: parent_id,
697. 697 merge_parent_candidate_id: merge_parent,
698. 698 branch_id,
699. 699 author_id: actor_id,
700. 700 author_name: actor_name,
701. 701 created_at: chrono::Utc::now().to_rfc3339(),
702. 702 ops,
703. 703 });
704. 704 if save(path, &room).is_err() {
705. 705 return StatusCode::INTERNAL_SERVER_ERROR.into_response();
706. 706 }
707. 707 if let Some(handle) = state.get(&session_id) {
708. 708 let _ = handle.coworking_comments_tx.send(());
709. 709 }
710. 710 Json(serde_json::json!({"workspace":room,"candidate":saved,"worker_result":applied}))
711. 711 .into_response()
712. 712}
713. 713
714. 714fn operations_since(
715. 715 room: &OfficeRoom,
716. 716 head: &str,
717. 717 base: &str,
718. 718) -> Option<Vec<vak_ooxml::edit::OfficeOp>> {
719. 719 let mut cursor = head;
720. 720 let mut result = Vec::new();
721. 721 for _ in 0..room.revisions.len() {
722. 722 if cursor == base {
723. 723 result.reverse();
724. 724 return Some(result.into_iter().flatten().collect());
725. 725 }
726. 726 let revision = room
727. 727 .revisions
728. 728 .iter()
729. 729 .rev()
730. 730 .find(|r| r.candidate_id == cursor)?;
731. 731 result.push(revision.ops.clone());
732. 732 cursor = &revision.parent_candidate_id;
733. 733 }
734. 734 None
735. 735}
736. 736
737. 737fn op_keys(ops: &[vak_ooxml::edit::OfficeOp]) -> Vec<String> {
738. 738 use vak_ooxml::edit::OfficeOp as O;
739. 739 let mut keys = Vec::new();
740. 740 for op in ops {
741. 741 match op {
742. 742 O::ReplaceParagraphText { anchor, .. }
743. 743 | O::DeleteParagraph { anchor }
744. 744 | O::SetPlaceholderText { anchor, .. }
745. 745 | O::SetNotes { anchor, .. }
746. 746 | O::DeleteSlide { anchor }
747. 747 | O::MoveSlide { anchor, .. } => keys.push(format!("a:{anchor}")),
748. 748 O::AddParagraph { after, .. } | O::AddTable { after, .. } => keys.push(match after {
749. 749 Some(anchor) => format!("a:{anchor}"),
750. 750 None => "doc:end".into(),
751. 751 }),
752. 752 O::SetCells { sheet, cells } => {
753. 753 keys.extend(cells.keys().map(|cell| format!("c:{sheet}!{cell}")))
754. 754 }
755. 755 O::AppendRows { sheet, .. } => keys.push(format!("s:{sheet}:rows")),
756. 756 O::AddSheet { name: sheet } => keys.push(format!("s:{sheet}:create")),
757. 757 // A rename touches everything on the sheet under either name.
758. 758 O::RenameSheet { sheet, name } => {
759. 759 keys.push(format!("s:{sheet}:create"));
760. 760 keys.push(format!("s:{name}:create"));
761. 761 }
762. 762 O::FormatCells { sheet, .. } => keys.push(format!("s:{sheet}:format")),
763. 763 O::SetColumnWidths { sheet, .. } => keys.push(format!("s:{sheet}:columns")),
764. 764 O::AddSlideFromLayout { .. } => keys.push("deck:slides".into()),
765. 765 O::SetTitle { .. } => keys.push("meta:title".into()),
766. 766 }
767. 767 }
768. 768 keys
769. 769}
770. 770
771. 771fn has_conflict(
772. 772 shared: &[vak_ooxml::edit::OfficeOp],
773. 773 branch: &[vak_ooxml::edit::OfficeOp],
774. 774) -> bool {
775. 775 let a = op_keys(shared);
776. 776 let b = op_keys(branch);
777. 777 use vak_ooxml::edit::OfficeOp as O;
778. 778 let changes_paragraph_order = |ops: &[O]| {
779. 779 ops.iter().any(|op| {
780. 780 matches!(
781. 781 op,
782. 782 O::AddParagraph { .. } | O::AddTable { .. } | O::DeleteParagraph { .. }
783. 783 )
784. 784 })
785. 785 };
786. 786 let word = |ops: &[O]| {
787. 787 ops.iter().any(|op| {
788. 788 matches!(
789. 789 op,
790. 790 O::ReplaceParagraphText { .. }
791. 791 | O::AddParagraph { .. }
792. 792 | O::AddTable { .. }
793. 793 | O::DeleteParagraph { .. }
794. 794 )
795. 795 })
796. 796 };
797. 797 let (shared_word, branch_word) = (word(shared), word(branch));
798. 798 (changes_paragraph_order(shared) && branch_word
799. 799 || changes_paragraph_order(branch) && shared_word)
800. 800 || a.iter().any(|left| {
801. 801 b.iter().any(|right| {
802. 802 left == right
803. 803 || (left == "deck:slides" && right.starts_with("a:slide:"))
804. 804 || (right == "deck:slides" && left.starts_with("a:slide:"))
805. 805 || (left.starts_with("s:")
806. 806 && right.starts_with("s:")
807. 807 && left.split(':').nth(1) == right.split(':').nth(1)
808. 808 && (left.ends_with(":create") || right.ends_with(":create")))
809. 809 || (left.starts_with("c:")
810. 810 && right.starts_with("s:")
811. 811 && left
812. 812 .strip_prefix("c:")
813. 813 .and_then(|cell| cell.split_once('!'))
814. 814 .is_some_and(|(sheet, _)| {
815. 815 right
816. 816 .strip_prefix("s:")
817. 817 .is_some_and(|rows| rows.starts_with(&format!("{sheet}:")))
818. 818 }))
819. 819 || (right.starts_with("c:")
820. 820 && left.starts_with("s:")
821. 821 && right
822. 822 .strip_prefix("c:")
823. 823 .and_then(|cell| cell.split_once('!'))
824. 824 .is_some_and(|(sheet, _)| {
825. 825 left.strip_prefix("s:")
826. 826 .is_some_and(|rows| rows.starts_with(&format!("{sheet}:")))
827. 827 }))
828. 828 })
829. 829 })
830. 830}
831. 831
832. 832#[cfg(test)]
833. 833mod tests {
834. 834 use super::*;
835. 835 use vak_ooxml::edit::OfficeOp as O;
836. 836
837. 837 #[test]
838. 838 fn overlapping_cells_and_sheet_creation_conflict() {
839. 839 let left = vec![O::SetCells {
840. 840 sheet: "Sheet 1".into(),
841. 841 cells: [("A1".into(), vak_ooxml::edit::CellValue::Text("one".into()))]
842. 842 .into_iter()
843. 843 .collect(),
844. 844 }];
845. 845 let same = vec![O::SetCells {
846. 846 sheet: "Sheet 1".into(),
847. 847 cells: [("A1".into(), vak_ooxml::edit::CellValue::Text("two".into()))]
848. 848 .into_iter()
849. 849 .collect(),
850. 850 }];
851. 851 assert!(has_conflict(&left, &same));
852. 852 let create = vec![O::AddSheet {
853. 853 name: "Sheet 1".into(),
854. 854 }];
855. 855 assert!(has_conflict(&left, &create));
856. 856 }
857. 857
858. 858 #[test]
859. 859 fn inserting_a_paragraph_conflicts_with_other_word_edits() {
860. 860 let insert = vec![O::AddParagraph {
861. 861 text: "new".into(),
862. 862 style: None,
863. 863 after: Some("p@1".into()),
864. 864 }];
865. 865 let edit = vec![O::ReplaceParagraphText {
866. 866 anchor: "p@8".into(),
867. 867 text: "changed".into(),
868. 868 }];
869. 869 assert!(has_conflict(&insert, &edit));
870. 870 }
871. 871}
872. 872