use std::io::{BufRead, BufReader, Write};
use std::os::unix::net::UnixStream;
use std::path::PathBuf;
use anyhow::{Context as _, Result, anyhow, bail};
use serde::Deserialize;
use serde::de::DeserializeOwned;
pub mod cwd;
pub mod events;
pub mod model;
pub mod subagents;
pub use cwd::{Cwd, CwdSource};
pub use events::{Event, EventKind, Events};
pub use model::{Agent, AgentSession, Pane, PluginContext};
pub use subagents::{Subagent, SubagentRoster, SubagentStatus};
fn socket_path() -> Result<PathBuf> {
std::env::var_os("HERDR_SOCKET_PATH")
.map(PathBuf::from)
.context("HERDR_SOCKET_PATH is unset — not running under Herdr")
}
pub struct Client {
path: PathBuf,
seq: u64,
}
#[derive(Deserialize)]
struct Envelope {
id: Option<String>,
result: Option<serde_json::Value>,
error: Option<ErrorBody>,
}
#[derive(Deserialize)]
struct ErrorBody {
message: Option<String>,
}
impl Client {
pub fn connect() -> Result<Self> {
let path = socket_path()?;
UnixStream::connect(&path)
.with_context(|| format!("connecting to Herdr socket at {}", path.display()))?;
Ok(Self { path, seq: 0 })
}
pub fn call<T: DeserializeOwned>(
&mut self,
method: &str,
params: serde_json::Value,
) -> Result<T> {
let mut stream = UnixStream::connect(&self.path)
.with_context(|| format!("connecting to Herdr socket for {method}"))?;
let mut reader = BufReader::new(stream.try_clone()?);
self.seq += 1;
let id = self.seq.to_string();
let request = serde_json::json!({ "id": &id, "method": method, "params": params });
writeln!(stream, "{request}").with_context(|| format!("sending {method}"))?;
stream.flush()?;
let mut line = String::new();
loop {
line.clear();
if reader.read_line(&mut line)? == 0 {
bail!("{method}: connection closed with no response — params rejected");
}
if line.trim().is_empty() {
continue;
}
let envelope: Envelope = serde_json::from_str(&line)
.with_context(|| format!("decoding response to {method}"))?;
if envelope.id.as_deref() != Some(id.as_str()) {
continue;
}
if let Some(error) = envelope.error {
return Err(anyhow!(
"{method}: {}",
error.message.unwrap_or_else(|| "request failed".into())
));
}
let result = envelope.result.unwrap_or(serde_json::Value::Null);
return serde_json::from_value(result)
.with_context(|| format!("decoding result of {method}"));
}
}
}
pub fn notify(method: &str, params: serde_json::Value) -> Result<()> {
let path = socket_path()?;
let mut stream = UnixStream::connect(&path)
.with_context(|| format!("connecting to Herdr socket at {}", path.display()))?;
let request = serde_json::json!({ "id": "1", "method": method, "params": params });
writeln!(stream, "{request}").with_context(|| format!("sending {method}"))?;
stream.flush().with_context(|| format!("flushing {method}"))
}
pub fn plugin_context() -> PluginContext {
std::env::var("HERDR_PLUGIN_CONTEXT_JSON")
.ok()
.and_then(|raw| serde_json::from_str(&raw).ok())
.unwrap_or_default()
}
pub fn herdr_bin() -> Result<PathBuf> {
std::env::var_os("HERDR_BIN_PATH")
.map(PathBuf::from)
.context("HERDR_BIN_PATH is unset — not running under Herdr")
}