vinzenz/hyperhive
vinzenz/hyperhive
Watch
0
0
Fork
You've already forked hyperhive
 0
Code Activity

move the builder and claude login wire contracts into swarm-wire

Browse source
This commit is contained in:
atlas 2026-10-18 07:27:43 +02:00 • committed by mara
commit 0c3d128de1
23 changed files with 224 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

2
swarm-queue-client/src/archetypes.rs
View file

@ -4,7 +4,7 @@
//!
//! **swarm-controller is the only writer and the only reader.** The swarm
//! builder evaluates the source and answers on
//! [`crate::builder::ARCHETYPES_SUBJECT`]; the controller checks each
//! `swarm_wire::builder::ARCHETYPES_SUBJECT`; the controller checks each
//! archetype's settings the way `POST /api/agents` checks them and writes the
//! result here, so the create screen lists archetypes from a value that a
//! create would accept.

121
swarm-queue-client/src/builder.rs
View file

@ -1,121 +0,0 @@
//! The swarm builder's requests: the subjects swarm-controller sends a build
//! and an archetype evaluation on, and what travels each way.
//!
//! Three crates name these: the controller sends the requests, the builder
//! answers them, and the auth-callout responder grants the subjects to each.
use std::time::Duration;
use serde::{Deserialize, Serialize};
/// The subject every build goes to. The controller is its one publisher and
/// the builder its one subscriber; the builder answers on the request's reply
/// subject.
pub const SUBJECT: &str = "$SWARM.builder.build";
/// The queue group the builder subscribes in, so a second instance shares the
/// requests instead of running each one twice.
pub const QUEUE_GROUP: &str = "builder";
/// The longest one build may take before the builder stops it and answers
/// with a timeout.
pub const BUILD_DEADLINE: Duration = Duration::from_hours(1);
/// How long the controller waits for the reply, and the queue lets the
/// builder answer: the build at its deadline, plus a minute the builder spends
/// on a request's wait for the build slot, the forge token read before the
/// build and the reply's trip back.
pub const REPLY_DEADLINE: Duration = Duration::from_mins(61);
/// One build: an agent's config repo at one commit, on the builder's own
/// agent base.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct BuildAgent {
/// The agent, which is also its config repo's name.
pub agent: String,
/// The commit to build.
pub rev: String,
/// The PR the commit is the head of; its `refs/pull/<pr>/head` is the ref
/// the builder fetches the commit through.
pub pr: u64,
}
/// The builder's answer to one [`BuildAgent`].
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "state", rename_all = "kebab-case")]
pub enum Reply {
/// The config built; `out_path` is the system closure's store path.
Built { out_path: String },
/// The build did not finish: the last lines `nix` printed, or why the
/// builder could not start it.
Failed { error_tail: String },
}
/// The subject an archetype evaluation goes to: the controller asks, the
/// builder evaluates the `meta` of every `hyperhiveArchetypes` entry of its own
/// hyperhive source and answers on the request's reply subject.
pub const ARCHETYPES_SUBJECT: &str = "$SWARM.builder.archetypes";
/// The longest one archetype evaluation may take, and how long the controller
/// waits for its reply.
pub const ARCHETYPES_DEADLINE: Duration = Duration::from_mins(2);
/// One archetype evaluation. No field yet: the builder evaluates the hyperhive
/// source it was deployed with.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct EvalArchetypes {}
/// The builder's answer to one [`EvalArchetypes`].
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "state", rename_all = "kebab-case")]
pub enum ArchetypesReply {
/// `source` is the flake evaluated; `archetypes` maps each archetype's
/// name to its `meta`, as `nix eval --json` printed it and unchecked.
Evaluated {
source: String,
archetypes: serde_json::Map<String, serde_json::Value>,
},
/// The evaluation did not finish: the last lines `nix` printed, or why the
/// builder could not start it.
Failed { error_tail: String },
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_wire_tags_the_reply_by_state() {
let json = serde_json::to_value(Reply::Built {
out_path: "/nix/store/x".to_owned(),
})
.expect("encodes");
assert_eq!(json["state"], "built");
assert_eq!(json["out_path"], "/nix/store/x");
let json = serde_json::to_value(Reply::Failed {
error_tail: "e".to_owned(),
})
.expect("encodes");
assert_eq!(json["state"], "failed");
}
#[test]
fn the_reply_deadline_outlasts_the_build() {
assert!(REPLY_DEADLINE > BUILD_DEADLINE);
}
#[test]
fn the_archetypes_reply_is_tagged_by_state() {
let json = serde_json::to_value(ArchetypesReply::Evaluated {
source: "/nix/store/h".to_owned(),
archetypes: serde_json::Map::new(),
})
.expect("encodes");
assert_eq!(json["state"], "evaluated");
let json = serde_json::to_value(ArchetypesReply::Failed {
error_tail: "e".to_owned(),
})
.expect("encodes");
assert_eq!(json["state"], "failed");
}
}

93
swarm-queue-client/src/claude_login.rs
View file

@ -1,93 +0,0 @@
//! The claude login minter's requests: the subject swarm-controller sends an
//! operator's login steps on, and what travels each way.
//!
//! Three crates name these: the controller sends the requests, the minter
//! answers them, and the auth-callout responder grants the one subject to
//! each.
//!
//! A login is two requests for one agent:
//! [`Request::Start`](crate::claude_login::Request::Start) runs
//! `claude auth login` and answers with the URL it printed, and
//! [`Request::Code`](crate::claude_login::Request::Code) hands it the code the
//! operator pasted and answers once the credentials are in the agent's store
//! leaf. The running login lives in the minter's memory between the two, so
//! the swarm runs one minter.
use std::time::Duration;
use serde::{Deserialize, Serialize};
/// The subject every request goes to. The controller is its one publisher
/// and the minter its one subscriber; the minter answers on the request's
/// reply subject.
pub const SUBJECT: &str = "$SWARM.claude-login.request";
/// The longest the minter waits for `claude` to print the login URL, and
/// then for it to finish once the code is in.
pub const STEP_DEADLINE: Duration = Duration::from_mins(1);
/// How long the controller waits for a reply, and the queue lets the minter
/// answer: a step at its deadline, plus the store write.
pub const REPLY_DEADLINE: Duration = Duration::from_secs(90);
/// How long a started login waits for its code before the minter stops it
/// and deletes its scratch directory.
pub const SESSION_DEADLINE: Duration = Duration::from_mins(15);
/// One step of an operator's login of one agent.
///
/// No `Debug` derive: [`Request::Code`] carries the one-time code.
#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "step", rename_all = "kebab-case")]
pub enum Request {
/// Start a login for `agent`, replacing one already running for it.
Start {
agent: String,
/// The swarm UI user, as the gateway named them.
operator: String,
},
/// Hand the running login for `agent` the code the operator pasted.
Code { agent: String, code: String },
/// Stop the running login for `agent`, if any.
Cancel { agent: String },
}
/// The minter's answer to one [`Request`].
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "state", rename_all = "kebab-case")]
pub enum Reply {
/// The login is running; the operator opens `url` and pastes the code it
/// shows back.
Started { url: String },
/// The credentials are stored in the agent's leaf, as its newest
/// version.
Stored,
/// The running login, if there was one, is stopped.
Cancelled,
/// The step failed: why, with the last lines `claude` printed where it
/// printed any.
Failed { error: String },
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_wire_tags_the_request_by_step_and_the_reply_by_state() {
let json = serde_json::to_value(Request::Code {
agent: "atlas".to_owned(),
code: "c".to_owned(),
})
.expect("encodes");
assert_eq!(json["step"], "code");
assert_eq!(json["agent"], "atlas");
let json = serde_json::to_value(Reply::Stored).expect("encodes");
assert_eq!(json["state"], "stored");
}
#[test]
fn the_reply_deadline_outlasts_a_step() {
assert!(REPLY_DEADLINE > STEP_DEADLINE);
}
}

7
swarm-queue-client/src/lib.rs
View file

@ -494,13 +494,6 @@ pub mod review_classifier;
mod startup_read;
pub use startup_read::read_with_startup_retry;
/// The builder's build subject and the request and reply it carries.
pub mod builder;
/// The claude login minter's subject and the requests and replies it
/// carries.
pub mod claude_login;
/// Only the fields this needs; authelia returns several.
#[derive(serde::Deserialize)]
struct TokenResponse {