7a826f9ee2
Six places in the tree hand-rolled the same connect / write one JSON line / read one JSON line back. Two of them — the harness serve loop's client and the MCP server's — were byte-identical apart from a six-line wrapper, ~145 lines of literal copy-paste. The other four each reimplemented a subset, and the subsets had drifted: some named the socket path in their errors and some did not, one classified transient against fatal failures and the rest retried nothing at all, two drained the response and two decoded it. That duplication was defended when the daemons were split out, on the grounds that a daemon's socket etiquette should stay visible in the crate that depends on it. The etiquette genuinely does differ. The code does not, and five copies is where "each daemon documents its own etiquette" stops paying for itself. `hive-sock-client` now owns the transport once, generic over the request and response types so it is protocol-agnostic: the host-served control socket and the harness's in-agent socket both use it with their own wire-type crates. The two real differences become values instead of forks. Retry is `Retry::RideOutRestart` (2/4/8/16/30s, sized to ride out a service restart) for callers with no natural retry of their own, or `Retry::None` for callers already inside a poll loop where the poll interval is the retry — and the reason each caller picked one is a comment at the call site rather than a reimplementation. The response is either decoded (`request`) or half-closed and drained (`notify`, where the drain exists so the server's write-back doesn't land on a closed socket). Whether a failure propagates or is logged and swallowed stays at the call site, because that is the caller's choice and not a property of the transport. Errors always name the socket path now, everywhere. That detail is load-bearing: a permission problem on a socket that reads as "is the daemon running?" sends the operator to fix the wrong thing. The transient-against-fatal enum is gone rather than moved. Serialising happens before the retry loop and deserialising after it, so only connect, I/O and short-read failures can reach the loop at all — a deterministic failure is now unretryable by construction instead of by classification. It is deliberately a new crate and not part of `hive-agent-sock`. The `*-sock` crates are pure wire types by convention — `hive-agent-sock` depends on serde and nothing else — and the two largest copies talk to the host socket, whose types live in a different crate entirely. A transport in either wire-type crate would drag tokio into it and point the wrong way besides. No wire-format change: same JSON line in, same line out.
46 lines
2.1 KiB
Rust
46 lines
2.1 KiB
Rust
//! `hive-forge-notify` binary — long-running per-agent Forgejo
|
|
//! notification poller. Polls the agent's unread notification list,
|
|
//! formats each thread into a short summary, and pushes it as a todo
|
|
//! (loose-ends v2) on the harness's in-agent socket so claude drives a
|
|
//! turn to handle it.
|
|
//!
|
|
//! Takes no arguments: everything comes from the environment the
|
|
//! per-agent systemd unit provides — `HIVE_FORGE_URL` (forwarded into
|
|
//! every container by the meta flake), `HYPERHIVE_STATE_DIR` (where the
|
|
//! agent's `forge-token` lives) and `HIVE_AGENT_SOCKET` (the harness's
|
|
//! todo socket). When the forge is not configured for this agent the
|
|
//! poller logs why and exits 0 — the unit is `Restart=on-failure`, so a
|
|
//! forge-less agent settles instead of restart-looping.
|
|
|
|
mod notify;
|
|
|
|
/// Retry policy for the harness's in-agent socket. Deliberately fail-fast:
|
|
/// both callers are inside the 30s poll loop and both treat a failed
|
|
/// request as "leave the thread unread and try again next tick", so the
|
|
/// poll interval *is* the retry — a second, in-request backoff would only
|
|
/// stack sleeps on top of it and delay the rest of the batch. That is the
|
|
/// opposite trade-off from the serve loop's client, which rides out a
|
|
/// hive-c0re restart because its callers have no natural retry of their own.
|
|
const TODO_SOCKET_RETRY: hive_sock_client::Retry = hive_sock_client::Retry::None;
|
|
|
|
#[tokio::main]
|
|
async fn main() {
|
|
tracing_subscriber::fmt()
|
|
.with_env_filter(
|
|
tracing_subscriber::EnvFilter::try_from_env("RUST_LOG")
|
|
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
|
|
)
|
|
.init();
|
|
|
|
let socket = std::env::var_os("HIVE_AGENT_SOCKET").map_or_else(
|
|
|| std::path::PathBuf::from(hive_agent_sock::DEFAULT_AGENT_SOCKET),
|
|
std::path::PathBuf::from,
|
|
);
|
|
|
|
tracing::info!(socket = %socket.display(), "hive-forge-notify starting");
|
|
|
|
// Returns only when the forge is not configured (or the token never
|
|
// arrives); otherwise loops forever. Either way there is nothing left
|
|
// for this process to do, so fall off the end and exit 0.
|
|
notify::run(socket).await;
|
|
}
|