feat(maestro): daemon CatalogMirror + own∪peer HTTP responses (NAP-246)

New module crates/maestro-daemon/src/catalog_mirror.rs: in-memory mirror of
the global catalog (peer daemons + their sessions), updated from the
`DaemonInbound::CatalogEvent` frames the registry now fans out.

`local_api` consumes it: `GET /api/sessions` returns the union of the
daemon's own sessions and the mirrored peers; `GET /api/daemons` returns
self + connected peers. The web UI sees the same catalog from any home
daemon.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
2026-05-26 19:18:25 +00:00
co-authored by Claude Opus 4.7
parent 2e6b7ac356
commit 2bf6f95506
6 changed files with 290 additions and 21 deletions
+172
View File
@@ -0,0 +1,172 @@
//! Daemon-local mirror of the registry catalog (NAP-246).
//!
//! The registry fans out a stream of `RegistryEvent`s to each connected
//! daemon, filtered so each one only sees *peer* state. This module owns the
//! resulting in-memory copy and exposes read snapshots to the daemon's HTTP
//! handlers (`GET /api/sessions`, `GET /api/daemons`).
//!
//! The mirror does *not* include the daemon's own sessions — those come from
//! `SessionManager`. Combining the two for HTTP responses is the caller's
//! job (see `local_api.rs`).
use std::collections::{BTreeMap, HashMap};
use std::sync::Arc;
use maestro_protocol::{DaemonInfo, RegistryEvent, Session};
use tokio::sync::Mutex;
use uuid::Uuid;
#[derive(Debug, Default)]
struct State {
daemons: HashMap<String, DaemonInfo>,
/// `(daemon_id, session_id) -> Session` — mirrors the registry's catalog
/// keying so removals (which arrive as `(daemon_id, id)`) are O(1).
sessions: BTreeMap<(String, Uuid), Session>,
}
#[derive(Debug, Clone, Default)]
pub struct CatalogMirror {
inner: Arc<Mutex<State>>,
}
impl CatalogMirror {
pub fn new() -> Self {
Self::default()
}
/// Apply one delta. Snapshot events replace the mirror wholesale;
/// `Lagged` resets it on the assumption that the next full snapshot will
/// arrive later (today the registry doesn't re-send one — see follow-up
/// notes in `handler.rs`).
pub async fn apply(&self, event: RegistryEvent) {
let mut s = self.inner.lock().await;
match event {
RegistryEvent::Snapshot { daemons, sessions } => {
s.daemons.clear();
s.sessions.clear();
for d in daemons {
s.daemons.insert(d.daemon_id.clone(), d);
}
for sess in sessions {
s.sessions.insert((sess.daemon_id.clone(), sess.id), sess);
}
}
RegistryEvent::DaemonAdded { daemon } => {
s.daemons.insert(daemon.daemon_id.clone(), daemon);
}
RegistryEvent::DaemonRemoved { daemon_id } => {
s.daemons.remove(&daemon_id);
s.sessions.retain(|(d, _), _| d != &daemon_id);
}
RegistryEvent::SessionAdded { session } | RegistryEvent::SessionUpdated { session } => {
s.sessions
.insert((session.daemon_id.clone(), session.id), session);
}
RegistryEvent::SessionRemoved { daemon_id, id } => {
s.sessions.remove(&(daemon_id, id));
}
RegistryEvent::Lagged { skipped } => {
tracing::warn!(skipped, "catalog mirror lagged — local view may be stale");
}
}
}
/// Snapshot the peer daemons currently mirrored.
pub async fn daemons(&self) -> Vec<DaemonInfo> {
self.inner.lock().await.daemons.values().cloned().collect()
}
/// Snapshot every peer session currently mirrored.
pub async fn sessions(&self) -> Vec<Session> {
self.inner.lock().await.sessions.values().cloned().collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::Utc;
use maestro_protocol::SessionStatus;
use std::collections::HashMap as StdHashMap;
fn peer_session(daemon: &str, id_lo: u128) -> Session {
Session {
id: Uuid::from_u128(id_lo),
daemon_id: daemon.into(),
cwd: "/tmp".into(),
command: "bash".into(),
env: StdHashMap::new(),
metadata: StdHashMap::new(),
status: SessionStatus::Running,
created_at: Utc::now(),
}
}
fn peer_daemon(daemon_id: &str) -> DaemonInfo {
DaemonInfo {
daemon_id: daemon_id.into(),
hostname: format!("{daemon_id}-host"),
version: "0.1.0".into(),
daemon_url: format!("ws://{daemon_id}:7070"),
}
}
#[tokio::test]
async fn snapshot_replaces_state() {
let m = CatalogMirror::new();
m.apply(RegistryEvent::DaemonAdded {
daemon: peer_daemon("old"),
})
.await;
m.apply(RegistryEvent::Snapshot {
daemons: vec![peer_daemon("new")],
sessions: vec![peer_session("new", 1)],
})
.await;
let ds = m.daemons().await;
assert_eq!(ds.len(), 1);
assert_eq!(ds[0].daemon_id, "new");
assert_eq!(m.sessions().await.len(), 1);
}
#[tokio::test]
async fn daemon_removed_cascades_to_sessions() {
let m = CatalogMirror::new();
m.apply(RegistryEvent::DaemonAdded {
daemon: peer_daemon("konishi"),
})
.await;
m.apply(RegistryEvent::SessionAdded {
session: peer_session("konishi", 1),
})
.await;
m.apply(RegistryEvent::SessionAdded {
session: peer_session("konishi", 2),
})
.await;
assert_eq!(m.sessions().await.len(), 2);
m.apply(RegistryEvent::DaemonRemoved {
daemon_id: "konishi".into(),
})
.await;
assert!(m.daemons().await.is_empty());
assert!(m.sessions().await.is_empty());
}
#[tokio::test]
async fn session_update_replaces_in_place() {
let m = CatalogMirror::new();
m.apply(RegistryEvent::SessionAdded {
session: peer_session("konishi", 1),
})
.await;
let mut updated = peer_session("konishi", 1);
updated.status = SessionStatus::Dead;
m.apply(RegistryEvent::SessionUpdated { session: updated })
.await;
let after = m.sessions().await;
assert_eq!(after.len(), 1);
assert_eq!(after[0].status, SessionStatus::Dead);
}
}
+2
View File
@@ -7,6 +7,7 @@
#![deny(missing_debug_implementations)]
pub mod attach;
pub mod catalog_mirror;
pub mod config;
pub mod configure;
pub mod jwt;
@@ -18,6 +19,7 @@ pub mod sidecar;
pub mod tmux;
pub mod worktree;
pub use catalog_mirror::CatalogMirror;
pub use config::{default_config_path, default_state_dir, load_config, DaemonConfig, EnvOverrides};
pub use configure::{run as run_configure, ConfigureError, ConfigureInputs};
pub use jwt::{issue as issue_jwt, JwtError, JwtVerifier};
+14 -4
View File
@@ -32,6 +32,7 @@ use maestro_protocol::{CreateSessionRequest, DaemonInfo, ErrorInfo, Session, PRO
use serde::Serialize;
use uuid::Uuid;
use crate::catalog_mirror::CatalogMirror;
use crate::session::SessionManager;
/// Daemon identity returned by `GET /api/web/info`. Browsers render this in the
@@ -50,6 +51,9 @@ pub struct LocalApiState {
pub manager: SessionManager,
pub hostname: Arc<String>,
pub daemon_url: Arc<String>,
/// Peer-only mirror of the global catalog. Empty until the daemon's
/// registry client connects and receives the snapshot.
pub catalog: CatalogMirror,
}
pub fn router(state: LocalApiState) -> Router {
@@ -62,17 +66,21 @@ pub fn router(state: LocalApiState) -> Router {
}
async fn list_sessions(State(s): State<LocalApiState>) -> Json<Vec<Session>> {
Json(s.manager.snapshot().await)
let mut out = s.manager.snapshot().await;
out.extend(s.catalog.sessions().await);
Json(out)
}
async fn list_daemons(State(s): State<LocalApiState>) -> Json<Vec<DaemonInfo>> {
// v1: a daemon only knows about itself. NAP-246 populates peers.
Json(vec![DaemonInfo {
let self_info = DaemonInfo {
daemon_id: s.manager.daemon_id().to_string(),
hostname: (*s.hostname).clone(),
version: PROTOCOL_VERSION.into(),
daemon_url: (*s.daemon_url).clone(),
}])
};
let mut out = vec![self_info];
out.extend(s.catalog.daemons().await);
Json(out)
}
async fn web_info(State(s): State<LocalApiState>) -> Json<WebInfo> {
@@ -157,11 +165,13 @@ pub fn state_for(
manager: SessionManager,
hostname: impl Into<String>,
daemon_url: impl Into<String>,
catalog: CatalogMirror,
) -> LocalApiState {
LocalApiState {
manager,
hostname: Arc::new(hostname.into()),
daemon_url: Arc::new(daemon_url.into()),
catalog,
}
}
+17 -12
View File
@@ -133,19 +133,9 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
manager.start_liveness_watcher(DEFAULT_LIVENESS_INTERVAL);
let verifier = JwtVerifier::new(&config.token, &config.daemon_id);
let local_state = local_api::state_for(
manager.clone(),
config.hostname.clone(),
config.daemon_url.clone(),
);
let router = attach::router(manager.clone(), verifier)
.merge(local_api::router(local_state))
.merge(local_api::broker_router(manager.clone()));
let listener = TcpListener::bind(config.bind_addr).await?;
let bound = listener.local_addr()?;
tracing::info!(addr = %bound, "attach WS listening");
// Build the registry client first so we can hand its catalog mirror to
// the local-API state — both halves share the same Arc<Mutex<…>>.
let client = RegistryClient::new(
config.registry_url.clone(),
config.daemon_id.clone(),
@@ -155,6 +145,21 @@ async fn run(config_override: Option<PathBuf>) -> Result<(), Box<dyn Error>> {
manager.clone(),
)
.with_perimeter(config.perimeter_id.clone(), config.private_addr.clone());
let catalog = client.catalog();
let local_state = local_api::state_for(
manager.clone(),
config.hostname.clone(),
config.daemon_url.clone(),
catalog,
);
let router = attach::router(manager.clone(), verifier)
.merge(local_api::router(local_state))
.merge(local_api::broker_router(manager.clone()));
let listener = TcpListener::bind(config.bind_addr).await?;
let bound = listener.local_addr()?;
tracing::info!(addr = %bound, "attach WS listening");
tokio::spawn(async move { client.run().await });
@@ -17,6 +17,7 @@ use maestro_protocol::{DaemonInbound, DaemonOutbound, RpcResult, PROTOCOL_VERSIO
use tokio::sync::broadcast::error::RecvError;
use tokio_tungstenite::tungstenite::Message;
use crate::catalog_mirror::CatalogMirror;
use crate::session::{SessionEvent, SessionManager};
/// Per-message heartbeat interval. Less than the registry's 30s timeout, with
@@ -49,6 +50,10 @@ pub struct RegistryClient {
/// Daemon's reachable address on the declared perimeter.
private_addr: Option<String>,
manager: SessionManager,
/// Local mirror of the global catalog (peer daemons + peer sessions),
/// populated from `DaemonInbound::CatalogEvent` frames the registry
/// fans out.
catalog: CatalogMirror,
}
impl RegistryClient {
@@ -69,9 +74,16 @@ impl RegistryClient {
perimeter_id: None,
private_addr: None,
manager,
catalog: CatalogMirror::new(),
}
}
/// Cheap handle to the daemon's peer-catalog mirror. Clone freely;
/// internal state is `Arc<Mutex<…>>`.
pub fn catalog(&self) -> CatalogMirror {
self.catalog.clone()
}
/// Set the perimeter advertised in heartbeats. Pass both or neither —
/// a private address without a perimeter id is meaningless.
pub fn with_perimeter(
@@ -235,6 +247,10 @@ impl RegistryClient {
// emitting these messages don't crash older daemons on parse.
tracing::debug!("broker message received but unhandled (NAP-243 pending)");
}
DaemonInbound::CatalogEvent { event } => {
// NAP-246: peer-filtered catalog delta from the registry.
self.catalog.apply(event).await;
}
}
Ok(())
}
+69 -5
View File
@@ -11,8 +11,8 @@ use std::time::Duration;
use common::DaemonFixture;
use futures_util::{SinkExt, StreamExt};
use maestro_daemon::local_api;
use maestro_protocol::{CreateSessionRequest, DaemonInfo, Session};
use maestro_daemon::{local_api, CatalogMirror};
use maestro_protocol::{CreateSessionRequest, DaemonInfo, RegistryEvent, Session};
use tokio::net::TcpListener;
use tokio::sync::oneshot;
use tokio_tungstenite::tungstenite::Message as WsMessage;
@@ -24,6 +24,7 @@ type WsClient = WebSocketStream<MaybeTlsStream<tokio::net::TcpStream>>;
struct Harness {
addr: SocketAddr,
manager: maestro_daemon::SessionManager,
catalog: CatalogMirror,
_shutdown: oneshot::Sender<()>,
_fx: DaemonFixture,
}
@@ -31,7 +32,8 @@ struct Harness {
async fn spawn(daemon_id: &str, hostname: &str, daemon_url: &str) -> Harness {
let fx = DaemonFixture::new(daemon_id);
let manager = fx.manager.clone();
let state = local_api::state_for(manager.clone(), hostname, daemon_url);
let catalog = CatalogMirror::new();
let state = local_api::state_for(manager.clone(), hostname, daemon_url, catalog.clone());
let router = local_api::router(state).merge(local_api::broker_router(manager.clone()));
let listener = TcpListener::bind(SocketAddr::from((Ipv4Addr::LOCALHOST, 0)))
.await
@@ -48,6 +50,7 @@ async fn spawn(daemon_id: &str, hostname: &str, daemon_url: &str) -> Harness {
Harness {
addr,
manager,
catalog,
_shutdown: tx,
_fx: fx,
}
@@ -73,17 +76,78 @@ async fn web_info_returns_daemon_identity() {
}
#[tokio::test]
async fn list_daemons_returns_self_only() {
async fn list_daemons_includes_self_and_mirrored_peers() {
let h = spawn("laptop", "naps-laptop", "ws://10.0.0.1:7070").await;
// Before any catalog events arrive, the daemon only knows about itself.
let list: Vec<DaemonInfo> = reqwest::get(url(h.addr, "/api/daemons"))
.await
.unwrap()
.json()
.await
.unwrap();
// v1: no peer mirror, so a daemon only knows about itself.
assert_eq!(list.len(), 1);
assert_eq!(list[0].daemon_id, "laptop");
// Simulate the registry fanning out a peer addition.
h.catalog
.apply(RegistryEvent::DaemonAdded {
daemon: DaemonInfo {
daemon_id: "konishi".into(),
hostname: "konishi-host".into(),
version: "0.1.0".into(),
daemon_url: "ws://10.0.0.2:7070".into(),
},
})
.await;
let list: Vec<DaemonInfo> = reqwest::get(url(h.addr, "/api/daemons"))
.await
.unwrap()
.json()
.await
.unwrap();
assert_eq!(list.len(), 2);
let ids: Vec<&str> = list.iter().map(|d| d.daemon_id.as_str()).collect();
assert!(ids.contains(&"laptop"));
assert!(ids.contains(&"konishi"));
}
#[tokio::test]
async fn list_sessions_unions_own_and_peer() {
let h = spawn("laptop", "naps-laptop", "ws://10.0.0.1:7070").await;
// Create one local session.
let own = h
.manager
.create(CreateSessionRequest {
daemon_id: "laptop".into(),
cwd: "/tmp".into(),
command: "sleep 60".into(),
env: HashMap::new(),
metadata: HashMap::new(),
worktree: None,
})
.await
.unwrap();
// Inject a peer session via the mirror.
let mut peer = own.clone();
peer.id = Uuid::new_v4();
peer.daemon_id = "konishi".into();
h.catalog
.apply(RegistryEvent::SessionAdded {
session: peer.clone(),
})
.await;
let list: Vec<Session> = reqwest::get(url(h.addr, "/api/sessions"))
.await
.unwrap()
.json()
.await
.unwrap();
let ids: Vec<Uuid> = list.iter().map(|s| s.id).collect();
assert!(ids.contains(&own.id), "own session missing: {ids:?}");
assert!(ids.contains(&peer.id), "peer session missing: {ids:?}");
}
#[tokio::test]