swarm UI: log an agent into claude from its card; the credentials go to bao and the agent picks them up

A new swarm service, `swarm-claude-login`, in its own container on the host
that sets `deploy.claude-login.enable` (defaulted on by `allSwarmServices`
where the host has the minter's store leaf, like the review classifier).

- swarm-ui: an agent card showing "login needed" gets a "log in" button.
  Its dialog starts the login, shows the URL claude printed, and takes the
  pasted code.
- swarm-controller: `POST/DELETE /api/agents/{name}/claude-login` and
  `POST /api/agents/{name}/claude-login/code`, behind the swarm UI's
  authelia-gated `/api/`, relay the steps to the minter as requests on
  `$SWARM.claude-login.request`.
- swarm-claude-login: runs `claude auth login` over piped stdio with HOME
  and CLAUDE_CONFIG_DIR in a per-login scratch dir, scrapes the first
  https URL, writes the code to stdin, and stores the `.credentials.json`
  at `swarm/agents/<agent>/claude-credentials` with a KV v2 write, a new
  version over any earlier one. The scratch dir goes on every exit path; a
  login waits 15 minutes for its code.
- hive-agent: while parked in `wait_for_login`, reads that leaf every 30 s
  under the agent's own cert and installs it only when its KV version is
  newer than the one recorded in `<harness>/claude-credentials-version`.
  An equal or older version is never put back, because claude rotates the
  refresh token and the stored copy is stale after the first refresh.
- swarm-secret-client: `claude_login` paths and `SecretStore::read_versioned`.
- Credentials: a `claude-login` store leaf minted by glue-bao-tls, a
  `swarm-claude-login` policy (create/update on
  `swarm/agents/+/claude-credentials`, read on its own queue client
  secret), an authelia machine client, and a `--claude-login-client`
  grant in the queue's auth-callout responder. The unit runs as a static
  system user.

The hive's own web-UI login is unchanged.

Refs #5268

swarm-secret-client/Cargo.toml

@@ -13,12 +13,12 @@ reqwest.workspace = true
 rustify.workspace = true
 rustify_derive.workspace = true
 serde.workspace = true
+# `read_versioned` decodes the data half of the response vaultrs hands back as
+# a `serde_json::Value`.
+serde_json.workspace = true
 strum.workspace = true
 thiserror.workspace = true
 vaultrs.workspace = true
 
-[dev-dependencies]
-serde_json.workspace = true
-
 [lints]
 workspace = true

swarm-secret-client/src/claude_login.rs

@@ -0,0 +1,108 @@
+//! The claude login agreement: where an agent's claude credentials live in
+//! the store, what the object there holds, and where the minter's own queue
+//! client secret lives.
+//!
+//! The `swarm-claude-login` minter writes [`credentials_path`] under its own
+//! certificate, a new version on every login, and `hive-agent` reads it back
+//! under the agent's. Its write stanza in `swarm-bao.nix` names exactly this
+//! leaf under every agent.
+
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    Error,
+    path::{Kind, principal_prefix},
+};
+
+/// The path holding `agent`'s claude credentials.
+///
+/// A flat leaf under the agent's prefix, like
+/// [`crate::github::account_path`], so the agent's own read stanza
+/// ([`crate::policy::render_agent`]) already covers it.
+///
+/// # Errors
+/// [`Error::PathSegment`] when `agent` contains anything but `[A-Za-z0-9_-]`,
+/// which is what keeps one agent's name from addressing another agent's secret.
+pub fn credentials_path(agent: &str) -> Result<String, Error> {
+    let prefix = principal_prefix(Kind::Agent, agent)?;
+    Ok(format!("{prefix}/claude-credentials"))
+}
+
+/// What a [`credentials_path`] holds.
+///
+/// No `Debug` derive: `value` is a live claude session.
+#[derive(Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Credentials {
+    /// The `.credentials.json` `claude auth login` wrote, byte for byte.
+    pub value: String,
+}
+
+impl std::fmt::Debug for Credentials {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Credentials")
+            .field("value", &"<redacted>")
+            .finish()
+    }
+}
+
+/// The path holding the queue client secret of the minter's OIDC client
+/// `client_id`, where `swarm-secret-publisher.nix` puts every swarm service's.
+///
+/// # Errors
+/// [`Error::PathSegment`] when `client_id` is not a single path segment.
+pub fn client_secret_path(client_id: &str) -> Result<String, Error> {
+    crate::builder::client_secret_path(client_id)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn covered_by(policy: &str, path: &str) -> bool {
+        policy.lines().any(|line| {
+            line.strip_prefix("path \"")
+                .and_then(|rest| rest.split_once("\" {"))
+                .and_then(|(p, _)| p.strip_suffix('*'))
+                .is_some_and(|prefix| format!("secret/data/{path}").starts_with(prefix))
+        })
+    }
+
+    #[test]
+    fn the_credentials_land_under_the_agent_prefix() {
+        // Spelled out: `swarm-bao.nix`'s minter stanza spells the same leaf.
+        assert_eq!(
+            credentials_path("atlas").expect("a plain name is legal"),
+            "swarm/agents/atlas/claude-credentials"
+        );
+    }
+
+    #[test]
+    fn a_traversal_in_the_agent_name_is_refused() {
+        for bad in ["../argus", "a/b", "a.b", ""] {
+            let e = credentials_path(bad).expect_err("a traversal is not legal");
+            assert!(matches!(e, Error::PathSegment { kind: "agent", .. }), "{e}");
+        }
+        assert!(credentials_path("a-b_C9").is_ok());
+    }
+
+    #[test]
+    fn the_agents_own_read_grant_covers_the_path() {
+        let path = credentials_path("atlas").expect("legal");
+        let own = crate::policy::render_agent("atlas").expect("legal");
+        assert!(
+            covered_by(&own, &path),
+            "no stanza in\n{own}\ncovers {path}"
+        );
+        let other = crate::policy::render_agent("argus").expect("legal");
+        assert!(!covered_by(&other, &path), "argus's policy reaches {path}");
+    }
+
+    #[test]
+    fn debug_never_prints_the_value() {
+        let c = Credentials {
+            value: "0123456789abcdef".to_owned(),
+        };
+        let shown = format!("{c:?}");
+        assert!(!shown.contains("0123456789abcdef"), "{shown}");
+    }
+}

swarm-secret-client/src/client.rs

@@ -218,6 +218,34 @@ impl SecretStore {
         }
     }
 
+    /// The newest version of the object at `path` and its KV v2 version
+    /// number, or `None` when nothing is stored there.
+    ///
+    /// One read, so the number is the one the value was stored as. Every
+    /// [`write`][Self::write] makes a larger one.
+    ///
+    /// # Errors
+    /// As [`read_optional`][Self::read_optional].
+    pub async fn read_versioned<T: DeserializeOwned>(
+        &self,
+        path: &str,
+    ) -> Result<Option<(T, u64)>, Error> {
+        let endpoint = vaultrs::api::kv2::requests::ReadSecretRequest::builder()
+            .mount(MOUNT)
+            .path(path)
+            .build()
+            .map_err(|e| Error::Settings(e.to_string()))?;
+        match vaultrs::api::exec_with_result(&self.inner, endpoint).await {
+            Ok(res) => {
+                let value = serde_json::from_value(res.data)
+                    .map_err(|source| vaultrs::error::ClientError::JsonParseError { source })?;
+                Ok(Some((value, res.metadata.version)))
+            }
+            Err(vaultrs::error::ClientError::APIError { code: 404, .. }) => Ok(None),
+            Err(e) => Err(e.into()),
+        }
+    }
+
     /// The keys stored directly under `path`, or none when nothing is.
     ///
     /// A key ending in `/` is a directory below `path` rather than an object;

swarm-secret-client/src/lib.rs

@@ -6,8 +6,9 @@
 //! deployment's environment into a logged-in client ([`client`]), and, per kind
 //! of secret, the path it lives at together with the fields it holds
 //! ([`matrix`], [`queue`], [`mtls`], [`forge`], [`github`], [`acp`], [`ci`],
-//! [`review_classifier`], [`builder`]). Each of those is a thing the controller
-//! and a hive must say identically, so it is said once here.
+//! [`review_classifier`], [`builder`], [`claude_login`]). Each of those is a
+//! thing the controller and a hive must say identically, so it is said once
+//! here.
 //!
 //! [`policy`] is the same kind of agreement seen from the other side: which of
 //! those paths a given principal's own token may read — a hive's, and an
@@ -26,6 +27,7 @@
 pub mod acp;
 pub mod builder;
 pub mod ci;
+pub mod claude_login;
 pub mod client;
 pub mod forge;
 pub mod github;