use std::io::{BufRead, BufReader, Write};
use std::os::unix::net::UnixStream;
use anyhow::{Context as _, Result, bail};
use serde::Deserialize;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EventKind {
PaneUpdated,
PaneFocused,
PaneCreated,
PaneClosed,
PaneExited,
PaneAgentDetected,
PaneAgentStatusChanged,
WorkspaceFocused,
}
impl EventKind {
pub fn subscription(self) -> &'static str {
match self {
Self::PaneUpdated => "pane.updated",
Self::PaneFocused => "pane.focused",
Self::PaneCreated => "pane.created",
Self::PaneClosed => "pane.closed",
Self::PaneExited => "pane.exited",
Self::PaneAgentDetected => "pane.agent_detected",
Self::PaneAgentStatusChanged => "pane.agent_status_changed",
Self::WorkspaceFocused => "workspace.focused",
}
}
pub fn wire(self) -> &'static str {
match self {
Self::PaneUpdated => "pane_updated",
Self::PaneFocused => "pane_focused",
Self::PaneCreated => "pane_created",
Self::PaneClosed => "pane_closed",
Self::PaneExited => "pane_exited",
Self::PaneAgentDetected => "pane_agent_detected",
Self::PaneAgentStatusChanged => "pane_agent_status_changed",
Self::WorkspaceFocused => "workspace_focused",
}
}
pub fn requires_pane_scope(self) -> bool {
matches!(self, Self::PaneAgentStatusChanged)
}
pub fn from_wire(value: &str) -> Option<Self> {
[
Self::PaneUpdated,
Self::PaneFocused,
Self::PaneCreated,
Self::PaneClosed,
Self::PaneExited,
Self::PaneAgentDetected,
Self::PaneAgentStatusChanged,
Self::WorkspaceFocused,
]
.into_iter()
.find(|kind| kind.wire() == value)
}
}
#[derive(Debug, Clone, Deserialize)]
pub struct Event {
pub event: String,
#[serde(default)]
pub data: serde_json::Value,
}
impl Event {
pub fn kind(&self) -> Option<EventKind> {
EventKind::from_wire(&self.event)
}
pub fn pane_id(&self) -> Option<&str> {
self.data
.get("pane")
.and_then(|pane| pane.get("pane_id"))
.or_else(|| self.data.get("pane_id"))
.and_then(serde_json::Value::as_str)
}
}
pub struct Events {
reader: BufReader<UnixStream>,
}
impl Events {
pub fn subscribe(kinds: &[EventKind]) -> Result<Self> {
if let Some(scoped) = kinds.iter().find(|kind| kind.requires_pane_scope()) {
bail!(
"{} is pane-scoped and cannot be subscribed session-wide",
scoped.subscription()
);
}
let path = std::env::var_os("HERDR_SOCKET_PATH")
.context("HERDR_SOCKET_PATH is unset — not running under Herdr")?;
let mut stream = UnixStream::connect(&path).context("connecting to Herdr socket")?;
let subscriptions: Vec<_> = kinds
.iter()
.map(|kind| serde_json::json!({ "type": kind.subscription() }))
.collect();
let request = serde_json::json!({
"id": "events",
"method": "events.subscribe",
"params": { "subscriptions": subscriptions },
});
writeln!(stream, "{request}")?;
stream.flush()?;
Ok(Self {
reader: BufReader::new(stream),
})
}
}
impl Iterator for Events {
type Item = Event;
fn next(&mut self) -> Option<Event> {
let mut line = String::new();
loop {
line.clear();
if self.reader.read_line(&mut line).ok()? == 0 {
return None;
}
if line.trim().is_empty() {
continue;
}
if let Ok(event) = serde_json::from_str::<Event>(&line)
&& event.kind().is_some()
{
return Some(event);
}
}
}
}