add a /clear-todos command that marks the agent's todos done
This commit is contained in:
parent
76882ec3b8
commit
dc0d08b7fb
1 changed files with 200 additions and 43 deletions
|
|
@ -12,14 +12,15 @@
|
|||
//! publish on the subject (`swarm-nats-auth`'s reader grant), and it names
|
||||
//! the sender from the swarm gateway's authelia answer.
|
||||
//!
|
||||
//! **Own credential only.** The queue grants subscribe on this subject to the
|
||||
//! agent's own credential alone.
|
||||
//! **Own credential only.** Subscribe on this subject is the agent's alone.
|
||||
//!
|
||||
//! **Core NATS, no reply to input.** A message sent while this task is not
|
||||
//! subscribed is gone; the controller sends it as a request so the operator
|
||||
//! gets a 503 for that instead. Input is not answered: the controller reads a
|
||||
//! request that times out as "a subscriber held it".
|
||||
//!
|
||||
//! **`/clear-todos` never reaches claude:** it marks every todo done instead.
|
||||
//!
|
||||
//! **Commands are a separate subject and are answered.** The swarm UI's
|
||||
//! cancel and `AGENTS.md` edits arrive on
|
||||
//! [`swarm_queue_client::agent_control_subject`], never on the input subject,
|
||||
|
|
@ -32,20 +33,25 @@ use futures_util::{Stream, StreamExt as _};
|
|||
use hive_sh4re::inbox::DeliveredMessage;
|
||||
use tokio::sync::mpsc::UnboundedSender;
|
||||
|
||||
use crate::events::Bus;
|
||||
use crate::events::{Bus, LiveEvent};
|
||||
use crate::todos::Todos;
|
||||
|
||||
/// The operator input that clears the agent's todos instead of reaching claude.
|
||||
const CLEAR_TODOS: &str = "/clear-todos";
|
||||
|
||||
/// Start the subscribers, if this agent has a label to name its subjects with.
|
||||
pub fn spawn(
|
||||
tx: UnboundedSender<DeliveredMessage>,
|
||||
bus: Bus,
|
||||
interrupted: std::sync::Arc<std::sync::atomic::AtomicBool>,
|
||||
todos: Option<std::sync::Arc<Todos>>,
|
||||
) {
|
||||
let agent = crate::identity::label();
|
||||
if agent.is_empty() {
|
||||
tracing::warn!("this agent has no label; not taking input from the swarm queue");
|
||||
return;
|
||||
}
|
||||
tokio::spawn(run(tx, agent.clone()));
|
||||
tokio::spawn(run(tx, agent.clone(), bus.clone(), todos));
|
||||
tokio::spawn(run_control(agent, bus, interrupted));
|
||||
}
|
||||
|
||||
|
|
@ -113,7 +119,12 @@ where
|
|||
Some(encoded.expect("a reply encodes"))
|
||||
}
|
||||
|
||||
async fn run(tx: UnboundedSender<DeliveredMessage>, agent: String) {
|
||||
async fn run(
|
||||
tx: UnboundedSender<DeliveredMessage>,
|
||||
agent: String,
|
||||
bus: Bus,
|
||||
todos: Option<std::sync::Arc<Todos>>,
|
||||
) {
|
||||
let client = crate::swarm_queue::client().await;
|
||||
let subject = swarm_queue_client::agent_input_subject(&agent);
|
||||
let subscriber = match client.subscribe(subject.clone()).await {
|
||||
|
|
@ -124,19 +135,43 @@ async fn run(tx: UnboundedSender<DeliveredMessage>, agent: String) {
|
|||
}
|
||||
};
|
||||
tracing::info!(subject, "taking operator input from the swarm queue");
|
||||
forward(subscriber.map(|msg| msg.payload), &tx).await;
|
||||
forward(subscriber.map(|msg| msg.payload), &tx, |body| {
|
||||
clear_todos(body, todos.as_deref(), &bus)
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
/// Push each decodable payload into `tx` until either end closes.
|
||||
/// Run `body` if it is the `/clear-todos` command: every open todo is marked
|
||||
/// done, and a note in the terminal says how many. Whether it was the command,
|
||||
/// in which case no turn is started for it.
|
||||
fn clear_todos(body: &str, todos: Option<&Todos>, bus: &Bus) -> bool {
|
||||
if body.trim() != CLEAR_TODOS {
|
||||
return false;
|
||||
}
|
||||
let text = match todos.map(Todos::mark_all_done) {
|
||||
Some(Ok(n)) => format!("operator: /clear-todos - marked {n} todo(s) done"),
|
||||
Some(Err(e)) => format!("operator: /clear-todos failed: {e}"),
|
||||
None => "operator: /clear-todos failed: the todo store is not open".to_owned(),
|
||||
};
|
||||
bus.emit(LiveEvent::Note { text });
|
||||
true
|
||||
}
|
||||
|
||||
/// Push each decodable payload into `tx` until either end closes, except one
|
||||
/// whose body `command` takes (and says so with `true`).
|
||||
async fn forward<P: AsRef<[u8]>>(
|
||||
payloads: impl Stream<Item = P>,
|
||||
tx: &UnboundedSender<DeliveredMessage>,
|
||||
command: impl Fn(&str) -> bool,
|
||||
) {
|
||||
let mut payloads = std::pin::pin!(payloads);
|
||||
while let Some(payload) = payloads.next().await {
|
||||
let Some(dm) = delivered(payload.as_ref()) else {
|
||||
continue;
|
||||
};
|
||||
if command(&dm.body) {
|
||||
continue;
|
||||
}
|
||||
if tx.send(dm).is_err() {
|
||||
// The serve loop is gone: the harness is shutting down.
|
||||
return;
|
||||
|
|
@ -167,7 +202,9 @@ fn delivered(payload: &[u8]) -> Option<DeliveredMessage> {
|
|||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{act, forward};
|
||||
use super::{act, clear_todos, forward};
|
||||
use crate::events::{Bus, BusEvent, LiveEvent};
|
||||
use crate::todos::Todos;
|
||||
use swarm_queue_client::agents_md::{Apply, ApplyReply};
|
||||
use swarm_queue_client::{AgentControl, AgentControlReply, AgentInput};
|
||||
|
||||
|
|
@ -187,7 +224,7 @@ mod tests {
|
|||
b"not json".to_vec(),
|
||||
payload("argus", "second"),
|
||||
];
|
||||
forward(futures_util::stream::iter(payloads), &tx).await;
|
||||
forward(futures_util::stream::iter(payloads), &tx, |_| false).await;
|
||||
drop(tx);
|
||||
|
||||
let mut got = Vec::new();
|
||||
|
|
@ -208,13 +245,74 @@ mod tests {
|
|||
assert!(got.iter().all(|dm| dm.id == 0 && dm.in_reply_to.is_none()));
|
||||
}
|
||||
|
||||
/// The command clears the todos, says so in the terminal and starts no
|
||||
/// turn; any other body, even one that merely mentions it, goes through.
|
||||
#[tokio::test]
|
||||
async fn clear_todos_takes_its_message_and_marks_every_todo_done() {
|
||||
let dir = tempfile::tempdir().expect("a dir");
|
||||
let todos = Todos::open(&dir.path().join("todos.sqlite")).expect("a store");
|
||||
todos.upsert("router", Some("a"), "a", None, true).unwrap();
|
||||
todos.upsert("matrix", None, "b", None, false).unwrap();
|
||||
let bus = Bus::new();
|
||||
let mut events = bus.subscribe();
|
||||
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let payloads = vec![
|
||||
payload("mara", "/clear-todos"),
|
||||
payload("mara", " /clear-todos \n"),
|
||||
payload("mara", "please /clear-todos"),
|
||||
];
|
||||
forward(futures_util::stream::iter(payloads), &tx, |body| {
|
||||
clear_todos(body, Some(&todos), &bus)
|
||||
})
|
||||
.await;
|
||||
drop(tx);
|
||||
|
||||
let mut got = Vec::new();
|
||||
while let Some(dm) = rx.recv().await {
|
||||
got.push(dm.body);
|
||||
}
|
||||
assert_eq!(got, ["please /clear-todos"]);
|
||||
assert!(!todos.has_any().unwrap());
|
||||
let mut notes = Vec::new();
|
||||
while let Ok(BusEvent {
|
||||
event: LiveEvent::Note { text },
|
||||
..
|
||||
}) = events.try_recv()
|
||||
{
|
||||
notes.push(text);
|
||||
}
|
||||
assert_eq!(
|
||||
notes,
|
||||
[
|
||||
"operator: /clear-todos - marked 2 todo(s) done",
|
||||
"operator: /clear-todos - marked 0 todo(s) done"
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn clear_todos_without_a_store_says_so() {
|
||||
let bus = Bus::new();
|
||||
let mut events = bus.subscribe();
|
||||
assert!(clear_todos("/clear-todos", None, &bus));
|
||||
let Ok(BusEvent {
|
||||
event: LiveEvent::Note { text },
|
||||
..
|
||||
}) = events.try_recv()
|
||||
else {
|
||||
panic!("no note");
|
||||
};
|
||||
assert!(text.contains("the todo store is not open"), "{text}");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_closed_serve_loop_stops_the_forwarder() {
|
||||
let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
drop(rx);
|
||||
// An endless stream: returning at all proves the closed channel ended it.
|
||||
let payloads = futures_util::stream::repeat(payload("mara", "hi"));
|
||||
forward(payloads, &tx).await;
|
||||
forward(payloads, &tx, |_| false).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
|
|
|
|||
Loading…
Reference in a new issue