142 lines
4.4 KiB
Rust
142 lines
4.4 KiB
Rust
use std::path::{Path, PathBuf};
|
|
use std::time::Duration;
|
|
|
|
use anyhow::{Result, bail};
|
|
use clap::{Parser, Subcommand};
|
|
use hive_ag3nt::{DEFAULT_SOCKET, client};
|
|
use hive_sh4re::{AgentRequest, AgentResponse};
|
|
use tokio::process::Command;
|
|
|
|
#[derive(Parser)]
|
|
#[command(name = "hive-ag3nt", about = "hyperhive sub-agent harness")]
|
|
struct Cli {
|
|
/// Path to the per-agent MCP socket (bind-mounted from the host).
|
|
#[arg(long, global = true, default_value = DEFAULT_SOCKET)]
|
|
socket: PathBuf,
|
|
|
|
#[command(subcommand)]
|
|
cmd: Cmd,
|
|
}
|
|
|
|
#[derive(Subcommand)]
|
|
enum Cmd {
|
|
/// Run the long-lived harness loop. Polls inbox; replies via `claude --print`
|
|
/// when available, falling back to a simple echo otherwise.
|
|
Serve {
|
|
/// Inbox poll interval in milliseconds.
|
|
#[arg(long, default_value_t = 1000)]
|
|
poll_ms: u64,
|
|
},
|
|
/// Send a message to another agent.
|
|
Send { to: String, body: String },
|
|
/// Pop one message from the inbox.
|
|
Recv,
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<()> {
|
|
tracing_subscriber::fmt()
|
|
.with_env_filter(
|
|
tracing_subscriber::EnvFilter::try_from_default_env()
|
|
.unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
|
|
)
|
|
.init();
|
|
|
|
let cli = Cli::parse();
|
|
match cli.cmd {
|
|
Cmd::Serve { poll_ms } => serve(&cli.socket, Duration::from_millis(poll_ms)).await,
|
|
Cmd::Send { to, body } => {
|
|
let resp: AgentResponse =
|
|
client::request(&cli.socket, &AgentRequest::Send { to, body }).await?;
|
|
render(&resp)?;
|
|
check(&resp)
|
|
}
|
|
Cmd::Recv => {
|
|
let resp: AgentResponse = client::request(&cli.socket, &AgentRequest::Recv).await?;
|
|
render(&resp)?;
|
|
check(&resp)
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn serve(socket: &Path, interval: Duration) -> Result<()> {
|
|
tracing::info!(socket = %socket.display(), "hive-ag3nt serve");
|
|
loop {
|
|
let recv: Result<AgentResponse> = client::request(socket, &AgentRequest::Recv).await;
|
|
match recv {
|
|
Ok(AgentResponse::Message { from, body }) => {
|
|
tracing::info!(%from, %body, "inbox");
|
|
// Don't auto-reply to echoes — prevents infinite ping-pong when
|
|
// both ends are falling back to echo. Real loop control is the
|
|
// manager's job (Phase 4+).
|
|
if !body.starts_with("echo: ") {
|
|
let reply = compute_reply(&body).await;
|
|
let send: Result<AgentResponse> = client::request(
|
|
socket,
|
|
&AgentRequest::Send {
|
|
to: from,
|
|
body: reply,
|
|
},
|
|
)
|
|
.await;
|
|
if let Err(e) = send {
|
|
tracing::warn!(error = ?e, "send reply failed");
|
|
}
|
|
}
|
|
}
|
|
Ok(AgentResponse::Empty) => {}
|
|
Ok(AgentResponse::Ok) => {
|
|
tracing::warn!("recv produced Ok (unexpected)");
|
|
}
|
|
Ok(AgentResponse::Err { message }) => {
|
|
tracing::warn!(%message, "recv error");
|
|
}
|
|
Err(e) => {
|
|
tracing::warn!(error = ?e, "recv failed; retrying");
|
|
}
|
|
}
|
|
tokio::time::sleep(interval).await;
|
|
}
|
|
}
|
|
|
|
async fn compute_reply(prompt: &str) -> String {
|
|
match invoke_claude(prompt).await {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
tracing::warn!(error = %format!("{e:#}"), "claude failed; falling back to echo");
|
|
format!("echo: {prompt}")
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn invoke_claude(prompt: &str) -> Result<String> {
|
|
let out = Command::new("claude")
|
|
.arg("--print")
|
|
.arg(prompt)
|
|
.output()
|
|
.await?;
|
|
if !out.status.success() {
|
|
bail!(
|
|
"claude exited {}: {}",
|
|
out.status,
|
|
String::from_utf8_lossy(&out.stderr).trim()
|
|
);
|
|
}
|
|
let text = String::from_utf8_lossy(&out.stdout).trim().to_owned();
|
|
if text.is_empty() {
|
|
bail!("claude produced empty output");
|
|
}
|
|
Ok(text)
|
|
}
|
|
|
|
fn render(resp: &AgentResponse) -> Result<()> {
|
|
println!("{}", serde_json::to_string_pretty(resp)?);
|
|
Ok(())
|
|
}
|
|
|
|
fn check(resp: &AgentResponse) -> Result<()> {
|
|
if let AgentResponse::Err { message } = resp {
|
|
bail!("{message}");
|
|
}
|
|
Ok(())
|
|
}
|