vinzenz/hyperhive
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

manager: same agent loop, ManagerServer MCP surface

Browse source
This commit is contained in:
müde 2026-05-15 15:13:26 +02:00
parent accb1445e3
commit 09787659ab
6 changed files with 422 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

99
hive-ag3nt/src/bin/hive-ag3nt.rs
View file

@ -1,5 +1,4 @@
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::sync::{Arc, Mutex};
use std::time::Duration;
@ -7,10 +6,8 @@ use anyhow::{Result, bail};
use clap::{Parser, Subcommand};
use hive_ag3nt::events::{Bus, LiveEvent};
use hive_ag3nt::login::{self, LoginState};
use hive_ag3nt::{DEFAULT_SOCKET, DEFAULT_WEB_PORT, client, mcp, web_ui};
use hive_ag3nt::{DEFAULT_SOCKET, DEFAULT_WEB_PORT, client, mcp, turn, web_ui};
use hive_sh4re::{AgentRequest, AgentResponse};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::process::Command;
#[derive(Parser)]
#[command(name = "hive-ag3nt", about = "hyperhive sub-agent harness")]
@ -97,7 +94,7 @@ async fn main() -> Result<()> {
render(&resp)?;
check(&resp)
}
Cmd::Mcp => mcp::serve_stdio(cli.socket).await,
Cmd::Mcp => mcp::serve_agent_stdio(cli.socket).await,
}
}
@ -133,7 +130,7 @@ async fn serve(
) -> Result<()> {
tracing::info!(socket = %socket.display(), "hive-ag3nt serve");
let _ = state; // reserved for future state transitions (turn-loop -> needs-login)
let mcp_config = write_mcp_config(socket).await?;
let mcp_config = turn::write_mcp_config(socket).await?;
let label = std::env::var("HIVE_LABEL").unwrap_or_else(|_| "hive-ag3nt".into());
loop {
let recv: Result<AgentResponse> = client::request(socket, &AgentRequest::Recv).await;
@ -145,7 +142,8 @@ async fn serve(
body: body.clone(),
});
let prompt = format_wake_prompt(&label, &from, &body);
let outcome = run_turn(&prompt, &mcp_config, &bus).await;
let outcome =
turn::run_turn(&prompt, &mcp_config, &bus, mcp::Flavor::Agent).await;
match outcome {
Ok(()) => {
bus.emit(LiveEvent::TurnEnd {
@ -202,93 +200,6 @@ fn format_wake_prompt(label: &str, from: &str, body: &str) -> String {
)
}
/// Spawn `claude` for one turn and stream its `stream-json` stdout into
/// the live event bus. `--verbose` is required by claude-code when pairing
/// `--print` with `--output-format stream-json`. Each stdout line is one
/// JSON event; we broadcast the parsed value (or a `Note` fallback on
/// parse error so the UI doesn't silently lose information). The tool
/// whitelist is the same as before: omit WebFetch/WebSearch/Task; allow
/// the hyperhive MCP surface auto-approved. Bash pattern allow-list is on
/// the backlog (CLAUDE.md).
async fn run_turn(prompt: &str, mcp_config: &Path, bus: &Bus) -> Result<()> {
// Don't pass the prompt as a positional arg: `--allowedTools <tools...>`
// and `--tools <tools...>` are variadic in claude-code, and the
// trailing positional gets swallowed into one of them — claude then
// errors with "Input must be provided either through stdin or as a
// prompt argument when using --print". Pipe via stdin instead.
let mut child = Command::new("claude")
.arg("--print")
.arg("--verbose")
.arg("--output-format")
.arg("stream-json")
.arg("--model")
.arg("haiku")
.arg("--mcp-config")
.arg(mcp_config)
.arg("--tools")
.arg(mcp::builtin_tools_arg())
.arg("--allowedTools")
.arg(mcp::allowed_tools_arg())
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()?;
if let Some(mut stdin) = child.stdin.take() {
stdin.write_all(prompt.as_bytes()).await?;
stdin.shutdown().await.ok();
drop(stdin); // signal EOF to claude
}
let stdout = child.stdout.take().expect("piped stdout");
let stderr = child.stderr.take().expect("piped stderr");
let bus_out = bus.clone();
let bus_err = bus.clone();
let pump_stdout = tokio::spawn(async move {
let mut reader = BufReader::new(stdout).lines();
while let Ok(Some(line)) = reader.next_line().await {
match serde_json::from_str::<serde_json::Value>(&line) {
Ok(v) => bus_out.emit(LiveEvent::Stream(v)),
Err(_) => bus_out.emit(LiveEvent::Note(format!("(non-json) {line}"))),
}
}
});
let pump_stderr = tokio::spawn(async move {
let mut reader = BufReader::new(stderr).lines();
while let Ok(Some(line)) = reader.next_line().await {
bus_err.emit(LiveEvent::Note(format!("stderr: {line}")));
}
});
let status = child.wait().await?;
let _ = pump_stdout.await;
let _ = pump_stderr.await;
if !status.success() {
bail!("claude exited {status}");
}
Ok(())
}
/// Drop the per-agent MCP config on disk so the turn loop can hand its path
/// to `claude --mcp-config`. Lives under `/run/hive/` (the bind-mounted
/// per-agent runtime dir) so it's ephemeral and isolated per container.
/// Returns the config path.
async fn write_mcp_config(socket: &Path) -> Result<PathBuf> {
let parent = socket.parent().unwrap_or_else(|| Path::new("/run/hive"));
tokio::fs::create_dir_all(parent).await.ok();
let path = parent.join("claude-mcp-config.json");
// `/proc/self/exe` resolves to the running hive-ag3nt binary's nix store
// path, which the spawned child can re-invoke as the MCP server. Avoids
// needing claude-code's $PATH to contain hive-ag3nt.
let exe = std::env::current_exe()
.ok()
.map_or_else(|| "hive-ag3nt".into(), |p| p.display().to_string());
let body = mcp::render_claude_config(&exe, socket);
tokio::fs::write(&path, body).await?;
tracing::info!(path = %path.display(), "wrote claude MCP config");
Ok(path)
}
fn render(resp: &AgentResponse) -> Result<()> {
println!("{}", serde_json::to_string_pretty(resp)?);
Ok(())