1use super::*;
4use serde_json::{Value, json};
5use sha2::{Digest, Sha256};
6
7#[derive(PartialEq, Eq, Serialize, Deserialize)]
10struct OwnerBinding {
11 talk: String,
12 text_sha256: String,
13}
14
15fn digest(text: &str) -> String {
16 use std::fmt::Write as _;
17 let mut encoded = String::with_capacity(64);
18 for byte in Sha256::digest(text.as_bytes()) {
19 write!(encoded, "{byte:02x}").expect("write to String");
20 }
21 encoded
22}
23
24fn binding_path(store: &Talks, request: &str) -> PathBuf {
25 store.root.join("owner-requests").join(digest(request))
26}
27
28fn read_binding(store: &Talks, request: &str) -> Result<Option<OwnerBinding>> {
29 match std::fs::read(binding_path(store, request)) {
30 Ok(bytes) => Ok(Some(
31 serde_json::from_slice(&bytes).context("decode owner request binding")?,
32 )),
33 Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(None),
34 Err(error) => Err(error).context("read owner request binding"),
35 }
36}
37
38fn reserve_binding(store: &Talks, request: &str, binding: &OwnerBinding) -> Result<bool> {
39 let path = binding_path(store, request);
40 std::fs::create_dir_all(path.parent().expect("binding directory"))?;
41 publish_exclusive(
42 &path,
43 &path.with_extension(format!("tmp.{}", fresh_token())),
44 &serde_json::to_string(binding)?,
45 )
46 .context("reserve owner request binding")
47}
48
49#[derive(Debug, Clone, Serialize, Deserialize)]
51pub struct Request {
52 pub request: String,
54 pub sender: String,
56 pub text: String,
58 pub input_turn: usize,
60 pub reply_turn: Option<usize>,
62 pub status: String,
65 pub worker: Option<String>,
67 pub error: Option<String>,
69}
70
71fn owner_input(
75 talk_id: &str,
76 input: Option<&Turn>,
77 record: &Request,
78 binding: Option<&OwnerBinding>,
79) -> Result<bool> {
80 let turn = input.context("recorded CLI input is missing")?;
81 let owner = binding.filter(|binding| binding.talk == talk_id);
82 if let Some(binding) = owner {
83 anyhow::ensure!(
84 binding.text_sha256 == digest(&record.text)
85 && record.sender.is_empty()
86 && turn.who == Who::Operator
87 && turn.sender == Some(Sender::Operator)
88 && turn.body == record.text
89 && turn.messages.iter().all(|message| {
90 message.sender == Some(Sender::Operator) && message.body == record.text
91 }),
92 "saved owner input does not match its admission"
93 );
94 } else {
95 anyhow::ensure!(
96 turn.sender == Some(Sender::External),
97 "saved CLI input has no matching owner binding or external provenance"
98 );
99 }
100 Ok(owner.is_some())
101}
102
103fn ingress(owner: bool) -> &'static str {
104 if owner { "owner" } else { "external" }
105}
106
107fn resolve(store: &Talks, selector: &str) -> Result<std::result::Result<Talk, Value>> {
108 let (talks, unreadable) = store.list_counting_unreadable();
109 let mut hits: Vec<_> = talks
110 .into_iter()
111 .filter(|t| t.id == selector || t.id.starts_with(selector))
112 .collect();
113 if let Some(index) = hits.iter().position(|t| t.id == selector) {
114 return Ok(Ok(hits.swap_remove(index)));
115 }
116 Ok(match hits.len() {
117 0 => Err(json!({"status":"not_found", "selector":selector, "unreadable":unreadable})),
118 1 => Ok(hits.pop().expect("one match")),
119 _ => Err(
120 json!({"status":"ambiguous", "selector":selector, "candidates":hits.iter().map(|t| &t.id).collect::<Vec<_>>()}),
121 ),
122 })
123}
124
125pub fn list(store: &Talks) -> Result<Value> {
127 let (talks, unreadable) = store.list_counting_unreadable();
128 Ok(
129 json!({"talks":talks.iter().map(|t| json!({"id":t.id,"repo":t.repo,"agent":t.agent,"status":t.status,"title":t.title})).collect::<Vec<_>>(),"unreadable":unreadable}),
130 )
131}
132
133fn cursor(talk: &Talk, turn: usize, message: usize) -> String {
134 use sha2::Digest as _;
135 let mut hash = sha2::Sha256::new();
136 if let Some(row) = talk.turns.get(turn) {
137 hash.update(serde_json::to_vec(&row.at).expect("timestamp serialization"));
138 let body = row
139 .messages
140 .get(message)
141 .map_or(row.body.as_str(), |m| m.body.as_str());
142 hash.update(body.as_bytes());
143 }
144 use std::fmt::Write as _;
147 let mut id = format!("{}:{turn}:{message}:", talk.id);
148 id.reserve(64);
149 for byte in hash.finalize() {
150 write!(id, "{byte:02x}").expect("write to string");
151 }
152 id
153}
154
155pub fn history(store: &Talks, selector: &str, after: Option<&str>, limit: usize) -> Result<Value> {
157 anyhow::ensure!(
158 (1..=500).contains(&limit),
159 "limit must be between 1 and 500"
160 );
161 let talk = match resolve(store, selector)? {
162 Ok(t) => t,
163 Err(v) => return Ok(v),
164 };
165 let mut coordinates = talk
166 .turns
167 .iter()
168 .enumerate()
169 .flat_map(|(i, turn)| (0..turn.messages.len().max(1)).map(move |j| (i, j)));
170 if let Some(after) = after {
171 coordinates
172 .find(|&(i, j)| cursor(&talk, i, j) == after)
173 .context("cursor is not a message in this conversation")?;
174 } else {
175 let count: usize = talk.turns.iter().map(|t| t.messages.len().max(1)).sum();
176 for _ in 0..count.saturating_sub(limit) {
177 coordinates.next();
178 }
179 }
180 let messages: Vec<_> = coordinates
181 .by_ref()
182 .take(limit)
183 .map(|(i, j)| {
184 let turn = &talk.turns[i];
185 let message = turn.messages.get(j);
186 let body = message.map_or(turn.body.as_str(), |m| m.body.as_str());
187 let request = talk.external_requests.iter().find(|r| r.input_turn == i);
188 let kind = request
189 .map(|r| {
190 let binding = read_binding(store, &r.request)?;
191 owner_input(&talk.id, Some(turn), r, binding.as_ref()).map(ingress)
192 })
193 .transpose()?;
194 Ok(json!({"id":cursor(&talk,i,j),"sender":sender(turn,message),"body":body,"at":turn.at,
195 "request":request.map(|r| &r.request),"ingress":kind}))
196 })
197 .collect::<Result<_>>()?;
198 let more = coordinates.next().is_some();
199 let last = messages.last().and_then(|v| v["id"].as_str()).or(after);
200 Ok(json!({"talk":talk.id,"messages":messages,"cursor":last,"more":more}))
201}
202
203fn view(store: &Talks, talk: &Talk, record: &Request, owner: bool) -> Value {
204 use crate::worker::Status;
205 let mut status = record.status.as_str();
206 if matches!(status, "accepted" | "started") {
207 let live = record
210 .worker
211 .as_deref()
212 .and_then(|id| crate::worker::get(store.home(), id).ok())
213 .is_some_and(|job| {
214 matches!(job.status, Status::Starting | Status::Running)
215 && (!owner
216 || crate::worker::observe_job_active(store.home(), &job).unwrap_or(false))
217 });
218 status = if !live {
219 "uncertain"
220 } else if owner && status == "accepted" {
221 "queued"
222 } else {
223 status
224 };
225 }
226 let mut goal_authorizations = Vec::new();
229 if owner {
230 for goal in &talk.goals {
231 if goal.source_turn == record.input_turn && goal.owner_input == record.text {
232 goal_authorizations.push(json!({"id":goal.id,"purpose":goal.purpose,
233 "scope":goal.scope,"condition":goal.condition,"current":true,"state":goal.state}));
234 }
235 for revision in &goal.history {
236 if revision.source_turn == record.input_turn && revision.owner_input == record.text
237 {
238 goal_authorizations.push(json!({"id":goal.id,"purpose":revision.purpose,
239 "scope":revision.scope,"condition":revision.condition,
240 "current":false,"state":revision.state}));
241 }
242 }
243 }
244 }
245 json!({"talk":talk.id,"request":record.request,"status":status,"accepted":true,
246 "ingress":ingress(owner),"goal_authorizations":goal_authorizations,
247 "input_id":cursor(talk,record.input_turn,0),
248 "reply_id":record.reply_turn.map(|i| cursor(talk,i,0)),
249 "reply":record.reply_turn.and_then(|i| talk.turns.get(i)).map(|t| &t.body),
250 "worker":record.worker,"error":record.error})
251}
252
253enum InputKind<'a> {
254 External(&'a str),
255 Owner,
256}
257
258pub async fn send(
260 store: &Talks,
261 selector: &str,
262 request: &str,
263 label: &str,
264 text: &str,
265) -> Result<Value> {
266 submit(store, selector, request, InputKind::External(label), text).await
267}
268
269pub async fn send_owner(store: &Talks, id: &str, request: &str, text: &str) -> Result<Value> {
271 let seat_environment = ["MAGI_RUN", "MAGI_NODE", "MAGI_SEAT"];
272 anyhow::ensure!(
273 !seat_environment
274 .iter()
275 .chain(crate::worker::INVOCATION_ENV.iter())
276 .chain(crate::chat_control::bridge::ENVIRONMENT)
277 .any(|key| std::env::var_os(key).is_some()),
278 "send-owner is unavailable inside a magi seat or worker; run it from the owner's trusted local terminal using their private MAGI_HOME"
279 );
280 submit(store, id, request, InputKind::Owner, text).await
281}
282
283async fn submit(
284 store: &Talks,
285 selector: &str,
286 request: &str,
287 input: InputKind<'_>,
288 text: &str,
289) -> Result<Value> {
290 let label = match input {
291 InputKind::External(label) => label,
292 InputKind::Owner => "",
293 };
294 let owner = matches!(input, InputKind::Owner);
295 anyhow::ensure!(
296 !request.is_empty()
297 && request.len() <= 128
298 && request
299 .bytes()
300 .all(|c| c.is_ascii_alphanumeric() || b"-_.".contains(&c)),
301 "request must contain 1..128 ASCII letters, digits, -, _ or ."
302 );
303 if let InputKind::External(label) = input {
304 anyhow::ensure!(
305 !label.trim().is_empty() && label.len() <= 128 && !label.chars().any(char::is_control),
306 "sender must be a nonempty single-line label of at most 128 bytes"
307 );
308 }
309 anyhow::ensure!(!text.trim().is_empty(), "nothing to send");
310 let expected_binding = owner.then(|| OwnerBinding {
311 talk: selector.to_owned(),
312 text_sha256: digest(text),
313 });
314 let binding_status = |binding: &OwnerBinding| {
315 let status = if Some(binding) == expected_binding.as_ref() {
316 "uncertain"
317 } else {
318 "conflict"
319 };
320 json!({"talk":selector,"request":request,"status":status})
321 };
322 let talk = match resolve(store, selector)? {
323 Ok(t) => t,
324 Err(v) => {
325 return Ok(if owner {
326 read_binding(store, request)?
327 .as_ref()
328 .map_or(v, binding_status)
329 } else {
330 v
331 });
332 }
333 };
334 anyhow::ensure!(
335 !owner || talk.id == selector,
336 "send-owner requires the full Chat ID from magi talk list"
337 );
338 let scoped_binding = || -> Result<Option<OwnerBinding>> {
341 Ok(read_binding(store, request)?.filter(|binding| owner || binding.talk == talk.id))
342 };
343 let replay = |talk: &Talk, r: &Request| -> Result<Value> {
344 let binding = scoped_binding()?;
345 let saved_owner = owner_input(&talk.id, talk.turns.get(r.input_turn), r, binding.as_ref())?;
346 Ok(
347 if saved_owner == owner && r.text == text && r.sender == label {
348 view(store, talk, r, saved_owner)
349 } else {
350 json!({"talk":talk.id,"request":request,"status":"conflict"})
351 },
352 )
353 };
354 if let Some(r) = talk.external_requests.iter().find(|r| r.request == request) {
355 return replay(&talk, r);
356 }
357 if let Some(binding) = scoped_binding()? {
358 let fresh = read_path(&store.path_of(&talk.id))?;
361 return match fresh
362 .external_requests
363 .iter()
364 .find(|r| r.request == request)
365 {
366 Some(r) => replay(&fresh, r),
367 None => Ok(binding_status(&binding)),
368 };
369 }
370 let Some(_publication) = crate::chat_worker::try_publication_guard(store, &talk.id)? else {
371 return Ok(json!({"talk":talk.id,"request":request,"status":"busy"}));
372 };
373 let fresh = read_path(&store.path_of(&talk.id))?;
375 if let Some(r) = fresh
376 .external_requests
377 .iter()
378 .find(|r| r.request == request)
379 {
380 return replay(&fresh, r);
381 }
382 if !fresh.status.open() {
383 return Ok(json!({"talk":fresh.id,"request":request,"status":"closed"}));
384 }
385 if crate::chat_worker::turn_worker_active(store, &fresh.id) {
388 return Ok(json!({"talk":fresh.id,"request":request,"status":"busy"}));
389 }
390 let Some(_turn) = store.claim_turn(&fresh.id)? else {
391 return Ok(json!({"talk":fresh.id,"request":request,"status":"busy"}));
392 };
393 {
394 let _guard = store.guard()?;
395 let mut fresh = read_path(&store.path_of(&talk.id))?;
396 if let Some(binding) = scoped_binding()? {
397 return Ok(binding_status(&binding));
398 }
399 if !fresh.status.open() {
400 return Ok(json!({"talk":fresh.id,"request":request,"status":"closed"}));
401 }
402 if !fresh.pending.is_empty()
403 || !fresh.pending_messages.is_empty()
404 || !fresh.pending_attachments.is_empty()
405 {
406 return Ok(json!({"talk":fresh.id,"request":request,"status":"busy"}));
407 }
408 let index = fresh.turns.len();
409 if let Some(binding) = &expected_binding
410 && !reserve_binding(store, request, binding)?
411 {
412 let winner =
413 read_binding(store, request)?.context("owner request binding disappeared")?;
414 return Ok(binding_status(&winner));
415 }
416 fresh.turns.push(match input {
417 InputKind::Owner => operator_turn(text, Vec::new(), None),
418 InputKind::External(label) => Turn {
419 sender: Some(Sender::External),
420 who: Who::Operator,
421 body: format!("External agent [{label}]:\n{text}"),
422 at: Timestamp::now(),
423 attachments: Vec::new(),
424 usage: None,
425 breaks: Some(Vec::new()),
426 messages: Vec::new(),
427 posted_by: None,
428 },
429 });
430 fresh.external_requests.push(Request {
431 request: request.to_owned(),
432 sender: label.to_owned(),
433 text: text.to_owned(),
434 input_turn: index,
435 reply_turn: None,
436 status: "accepted".into(),
437 worker: None,
438 error: None,
439 });
440 store.put(&mut fresh)?;
441 }
442 let result = crate::worker::spawn(
445 store.home(),
446 "chat",
447 &format!("chat-external:{}:{request}", talk.id),
448 json!({"talk":talk.id,"external_request":request}),
449 )
450 .await;
451 {
452 let _guard = store.guard()?;
453 let mut fresh = read_path(&store.path_of(&talk.id))?;
454 let r = fresh
455 .external_requests
456 .iter_mut()
457 .find(|r| r.request == request)
458 .context("CLI request disappeared")?;
459 record_launch(r, result);
460 store.put(&mut fresh)?;
461 }
462 let fresh = read_path(&store.path_of(&talk.id))?;
463 replay(
464 &fresh,
465 fresh
466 .external_requests
467 .iter()
468 .find(|r| r.request == request)
469 .context("CLI request disappeared")?,
470 )
471}
472
473fn record_launch(r: &mut Request, result: Result<crate::worker::Job>) {
474 match result {
475 Ok(job) => r.worker = Some(job.id),
476 Err(error) => {
477 if r.status == "accepted" {
480 if let Some(pending) = error.downcast_ref::<crate::worker::StartupUnacknowledged>()
481 {
482 r.worker = Some(pending.id.clone());
483 } else if crate::worker::not_started(&error) {
484 r.status = "not_started".into();
485 }
486 }
487 r.error = Some(format!("{error:#}"));
488 }
489 }
490}
491
492pub async fn reply(store: &Talks, selector: &str, request: &str, wait: u64) -> Result<Value> {
494 let binding = read_binding(store, request)?;
495 let talk = match resolve(store, selector)? {
496 Ok(t) => t,
497 Err(v) => {
498 return Ok(if binding.as_ref().is_some_and(|b| b.talk == selector) {
499 json!({"talk":selector,"request":request,"status":"uncertain"})
500 } else {
501 v
502 });
503 }
504 };
505 let deadline = tokio::time::Instant::now()
506 .checked_add(Duration::from_secs(wait))
507 .context("wait duration exceeds the monotonic clock range")?;
508 loop {
509 let fresh = read_path(&store.path_of(&talk.id))?;
510 let Some(record) = fresh
511 .external_requests
512 .iter()
513 .find(|r| r.request == request)
514 else {
515 let status = match &binding {
516 Some(b) if b.talk == fresh.id => "uncertain",
517 Some(_) => "conflict",
518 None => "not_found",
519 };
520 return Ok(json!({"talk":talk.id,"request":request,"status":status}));
521 };
522 let binding = read_binding(store, request)?;
523 let owner = owner_input(
524 &fresh.id,
525 fresh.turns.get(record.input_turn),
526 record,
527 binding.as_ref(),
528 )?;
529 let mut value = view(store, &fresh, record, owner);
530 if wait == 0 || matches!(record.status.as_str(), "replied" | "failed" | "not_started") {
531 return Ok(value);
532 }
533 if tokio::time::Instant::now() >= deadline {
534 value["state"] = value["status"].clone();
535 value["status"] = json!("timeout");
536 return Ok(value);
537 }
538 tokio::time::sleep(Duration::from_millis(100)).await;
539 }
540}
541
542pub(crate) async fn run_worker(store: &Talks, id: &str, request: &str) -> Result<()> {
544 let job = crate::worker::current_job(store.home())?.context("CLI submission has no worker")?;
545 anyhow::ensure!(
546 job.kind == "chat"
547 && job.payload["talk"].as_str() == Some(id)
548 && job.payload["external_request"].as_str() == Some(request),
549 "CLI submission does not belong to this worker"
550 );
551 loop {
552 if let Some(lease) = store.claim_turn(id)? {
553 let publication = crate::chat_worker::publication_guard(store, id).await?;
554 let (mut talk, index) = {
555 let _guard = store.guard()?;
556 let mut talk = read_path(&store.path_of(id))?;
557 let pos = talk
558 .external_requests
559 .iter()
560 .position(|r| r.request == request)
561 .context("CLI request missing")?;
562 let r = &talk.external_requests[pos];
563 if r.status != "accepted" {
565 return Ok(());
566 }
567 let binding = read_binding(store, request)?;
568 let owner = owner_input(id, talk.turns.get(r.input_turn), r, binding.as_ref())?;
569 let r = &mut talk.external_requests[pos];
570 if owner && !talk.status.open() {
571 r.status = "not_started".into();
572 r.error = Some("conversation closed before execution".into());
573 store.put(&mut talk)?;
574 return Ok(());
575 }
576 anyhow::ensure!(
577 r.worker.as_deref().is_none_or(|worker| worker == job.id),
578 "CLI submission belongs to a different worker"
579 );
580 r.status = "started".into();
581 r.worker = Some(job.id.clone());
582 r.error = None;
583 let index = r.input_turn;
584 store.put(&mut talk)?;
585 (talk, index)
586 };
587 let text = talk
588 .turns
589 .get(index)
590 .context("recorded CLI input is missing")?
591 .body
592 .clone();
593 drop(publication);
594 let (cfg, _) = Config::discover(&talk.repo, None)?;
595 return super::respond_at(&lease, &mut talk, store, &cfg, &text, Some(index)).await;
596 }
597 tokio::time::sleep(Duration::from_millis(100)).await;
598 }
599}
600
601#[cfg(test)]
602mod tests {
603 use super::*;
604
605 #[test]
606 fn stale_owner_admission_cannot_replace_a_request_binding() {
607 let home = tempfile::tempdir().unwrap();
608 let store = Talks::at(home.path().join("talks"));
609 let request = "follow";
610 let first = OwnerBinding {
611 talk: "first".into(),
612 text_sha256: digest("Observe the release"),
613 };
614 let second = OwnerBinding {
615 talk: "second".into(),
616 text_sha256: digest("Observe the release"),
617 };
618
619 assert!(read_binding(&store, request).unwrap().is_none());
621 assert!(reserve_binding(&store, request, &second).unwrap());
622 assert!(!reserve_binding(&store, request, &first).unwrap());
623 assert!(!reserve_binding(&store, request, &second).unwrap());
624 assert!(read_binding(&store, request).unwrap().as_ref() == Some(&second));
625 }
626
627 #[test]
628 fn startup_timeout_preserves_the_reserved_request() {
629 let home = tempfile::tempdir().unwrap();
630 let store = Talks::at(home.path().join("talks"));
631 let mut talk = seeded_for_test("owner", home.path().to_owned());
632 let text = "Observe the release";
633 talk.turns.push(operator_turn(text, Vec::new(), None));
634 let mut record: Request = serde_json::from_value(json!({
635 "request":"follow", "sender":"", "text":text,
636 "input_turn":0, "status":"accepted"
637 }))
638 .unwrap();
639 let id = "12345678-1234-4321-8234-123456789abc";
640 let dir = home.path().join("workers/jobs").join(id);
641 std::fs::create_dir_all(&dir).unwrap();
642 std::fs::write(
643 dir.join("job.json"),
644 json!({
645 "id":id, "kind":"chat", "key":"chat-external:owner:follow",
646 "payload":{"talk":talk.id,"external_request":"follow"},
647 "generation":"fixture", "status":"starting", "created_at":0
648 })
649 .to_string(),
650 )
651 .unwrap();
652 record_launch(
653 &mut record,
654 Err(crate::worker::StartupUnacknowledged { id: id.into() }.into()),
655 );
656 assert_eq!(
657 record.status, "accepted",
658 "the worker must still be admitted"
659 );
660 let queued = view(&store, &talk, &record, true);
661 assert_eq!(queued["status"], "queued");
662 assert_eq!(queued["worker"], id);
663 std::fs::remove_file(dir.join("job.json")).unwrap();
664 assert_eq!(view(&store, &talk, &record, true)["status"], "uncertain");
665 }
666}