Phase 4: hive-m1nd harness + manager nixos template; devshell sqlite

hive-ag3nt/src/bin/hive-m1nd.rs

@@ -1,5 +1,91 @@
-fn main() {
-    // Phase 4 — manager tool surface. For now, a placeholder so the binary
-    // exists and can be referenced from the manager nixos-container template.
-    println!("hive-m1nd placeholder");
+//! Manager harness. Talks to the manager socket (bind-mounted from the host
+//! at `/run/hive/mcp.sock` inside the `hm1nd` container) using the privileged
+//! tool surface. Phase 4 minimum: a CLI to exercise the verbs from a shell,
+//! plus a `serve` loop that logs the manager's inbox.
+
+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::{ManagerRequest, ManagerResponse};
+
+#[derive(Parser)]
+#[command(name = "hive-m1nd", about = "hyperhive manager harness")]
+struct Cli {
+    /// Path to the manager 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 {
+    /// Long-lived loop polling the manager inbox.
+    Serve {
+        #[arg(long, default_value_t = 1000)]
+        poll_ms: u64,
+    },
+    /// Send a message to a sub-agent (or anywhere — the broker doesn't validate).
+    Send { to: String, body: String },
+    /// Pop one message from the manager's inbox.
+    Recv,
+    /// Spawn a sub-agent.
+    Spawn { name: String },
+    /// Kill a sub-agent.
+    Kill { name: String },
+}
+
+#[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 } => one_shot(&cli.socket, ManagerRequest::Send { to, body }).await,
+        Cmd::Recv => one_shot(&cli.socket, ManagerRequest::Recv).await,
+        Cmd::Spawn { name } => one_shot(&cli.socket, ManagerRequest::Spawn { name }).await,
+        Cmd::Kill { name } => one_shot(&cli.socket, ManagerRequest::Kill { name }).await,
+    }
+}
+
+async fn one_shot(socket: &Path, req: ManagerRequest) -> Result<()> {
+    let resp: ManagerResponse = client::request(socket, &req).await?;
+    println!("{}", serde_json::to_string_pretty(&resp)?);
+    if let ManagerResponse::Err { message } = resp {
+        bail!("{message}");
+    }
+    Ok(())
+}
+
+async fn serve(socket: &Path, interval: Duration) -> Result<()> {
+    tracing::info!(socket = %socket.display(), "hive-m1nd serve");
+    loop {
+        let recv: Result<ManagerResponse> = client::request(socket, &ManagerRequest::Recv).await;
+        match recv {
+            Ok(ManagerResponse::Message { from, body }) => {
+                tracing::info!(%from, %body, "manager inbox");
+            }
+            Ok(ManagerResponse::Empty) => {}
+            Ok(ManagerResponse::Ok) => {
+                tracing::warn!("recv produced Ok (unexpected)");
+            }
+            Ok(ManagerResponse::Err { message }) => {
+                tracing::warn!(%message, "recv error");
+            }
+            Err(e) => {
+                tracing::warn!(error = ?e, "recv failed; retrying");
+            }
+        }
+        tokio::time::sleep(interval).await;
+    }
 }