Skip to content

Open source Grok Bot alternative, Bring your own agent and subscription: message Claude Code, Codex, Gemini CLI, Cursor, Copilot and 40+ AI agents as bots on your own computer, from iPhone, Mac, Windows, Linux or terminal. Agent-agnostic and free. Also a Muse and Dots alternative. Built in Rust.

fix(host): preserve network reply routing at delivery boundaries (#234)

Sean Ferguson9001df3c014d
diff --git a/host/crates/network/src/node/inbound.rs b/host/crates/network/src/node/inbound.rs
index 8d84c962..c5f376d4 100644
--- a/host/crates/network/src/node/inbound.rs
+++ b/host/crates/network/src/node/inbound.rs
@@ -121,12 +121,14 @@ impl Inner {
if let Err(reason) = locked(&self.guard).admit(pair.clone(), envelope.hops, said, Instant::now()) {
return refuse(reason);
}
- let (id, hops) = (envelope.id.clone(), envelope.hops);
// An answer that says how the request ended (`meta`) is the last one past the rules.
let ended = envelope.reply_to.clone().filter(|_| answers && envelope.meta.is_some());
- match self.hand_over(&reach, envelope.open(name(&peer))).await {
+ // A recipient can reply as soon as delivery wakes it, before the handoff returns.
+ // Keep this bounded metadata even on failure: a harness may already have seen the letter.
+ self.heard(&envelope.id, envelope.hops);
+ let handed_over = self.hand_over(&reach, envelope.open(name(&peer))).await;
+ match handed_over {
Ok(()) => {
- self.heard(&id, hops);
remember(&mut locked(&self.taken), key, TAKEN_MAX);
if let Some(request) = ended {
locked(&self.asked).retain(|(sent, to, _)| *sent != request || *to != peer);
@@ -186,3 +188,49 @@ impl Inner {
Ok(welcome)
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::node::Node;
+ use crate::types::{Connector, Letter, Sent};
+ use crate::wire::{Agent, AgentKind};
+ use std::sync::Mutex;
+ use std::task::{Context, Wake, Waker};
+
+ struct ObserveHops {
+ inner: Arc<Inner>,
+ letter: String,
+ observed: Mutex<Option<u8>>,
+ }
+
+ impl Wake for ObserveHops {
+ fn wake(self: Arc<Self>) {
+ *locked(&self.observed) = self.inner.hops_of(&self.letter);
+ }
+ }
+
+ #[tokio::test]
+ async fn reply_hops_are_available_when_delivery_wakes_the_recipient() {
+ let dir = std::env::temp_dir().join(format!("codync-network-hops-{}", wire::random_hex(8)));
+ let started = Node::start(&dir, &Connector::Private).await;
+ let (node, mut inbox) = started.expect("start an isolated node");
+ node.set_agents(["sender", "recipient"].map(|id| {
+ (Agent { id: id.into(), name: id.into(), about: String::new(), kind: AgentKind::Codync }, Reach::App)
+ }));
+ let recipient = node.resolve("recipient").expect("local recipient");
+ let letter = Letter::new("sender", recipient, "reply immediately").hops(3);
+ let observer =
+ Arc::new(ObserveHops { inner: node.inner.clone(), letter: letter.id.clone(), observed: Mutex::new(None) });
+ let waker = Waker::from(observer.clone());
+ let mut context = Context::from_waker(&waker);
+ assert!(inbox.poll_recv(&mut context).is_pending());
+
+ let sent = node.send(letter).await;
+ assert_eq!(sent.expect("deliver locally"), Sent::Delivered);
+ let delivered_hops = *locked(&observer.observed);
+ node.shutdown().await;
+ std::fs::remove_dir_all(dir).expect("remove isolated state");
+ assert_eq!(delivered_hops, Some(3), "an immediately woken reader must retain the reply chain");
+ }
+}
diff --git a/host/crates/network/src/roster.rs b/host/crates/network/src/roster.rs
index a340f58d..34fb44fe 100644
--- a/host/crates/network/src/roster.rs
+++ b/host/crates/network/src/roster.rs
@@ -462,7 +462,7 @@ fn distinct_names(
let mut held: BTreeMap<String, Option<u64>> = BTreeMap::new();
let mut names = BTreeMap::new();
for (at, id, name) in order {
- let free = |n: &str| held.get(&n.to_lowercase()).is_none_or(|until| until.is_some_and(|t| t <= at));
+ let free = |n: &str| held.get(&n.to_lowercase()).is_none_or(|until| until.is_some_and(|t| t < at));
let unique = std::iter::once(name.clone())
// One more number than there are names: one of them is free.
.chain((2..=held.len() + 2).map(|n| format!("{name}-{n}")))
diff --git a/host/crates/network/src/roster/tests.rs b/host/crates/network/src/roster/tests.rs
index a65a4f7a..7ca431ef 100644
--- a/host/crates/network/src/roster/tests.rs
+++ b/host/crates/network/src/roster/tests.rs
@@ -218,3 +218,25 @@ fn two_admins_naming_a_laptop_at_once_still_get_distinct_names() {
a.sign(&desk, 7, Change::Admit { id: new.public(), name: "laptop".into() }).unwrap();
assert_eq!(a.name(&new.public()), "laptop");
}
+
+#[test]
+fn removal_tied_with_another_admission_keeps_the_surviving_name() {
+ let (desk, server, laptop, other) = (key(), key(), key(), key());
+ let (mut a, _) = Roster::create(&desk, "desk".into(), addr(&desk), 1);
+ a.sign(&desk, 2, Change::Admit { id: server.public(), name: "server".into() }).unwrap();
+ a.sign(&desk, 3, Change::Promote { id: server.public() }).unwrap();
+ let mut b = a.clone();
+ a.sign(&desk, 4, Change::Admit { id: laptop.public(), name: "laptop".into() }).unwrap();
+ b.sign(&server, 5, Change::Admit { id: other.public(), name: "Laptop".into() }).unwrap();
+ a.merge(&b);
+ assert_eq!(a.name(&other.public()), "Laptop-2");
+
+ // Separate signers can produce an admission and removal in the same millisecond.
+ b.merge(&a);
+ b.sign(&desk, 5, Change::Remove { id: laptop.public(), cascade: false }).unwrap();
+ a.merge(&b);
+ b.merge(&a);
+ assert_eq!(a.members(), b.members());
+ assert_eq!(a.name(&other.public()), "Laptop-2");
+ assert_eq!(a.find("laptop-2"), Some(other.public()));
+}