path: root/crates/dinggerd/src/tmux.rs

//! tmux IPC wrapper. Everything dingger knows comes from these commands.

use std::process::Command;

use detect_core::{identify_agent, Agent, AgentState};

#[derive(Debug, Clone)]
pub struct Pane {
    /// Unique tmux pane id, e.g. `%3`. Stable for the pane's lifetime.
    pub pane_id: String,
    /// Human-readable target, e.g. `main:work` (`.pane` suffix when split).
    pub display_target: String,
    /// Foreground command name in the pane, from `#{pane_current_command}`.
    pub current_command: String,
    /// Last OSC title the pane's application set, from `#{pane_title}`.
    pub pane_title: String,
    pub dead: bool,
    /// The pane's window is the active window of its session.
    pub window_active: bool,
    /// The pane's session has at least one attached client.
    pub session_attached: bool,
    pub agent: Option<Agent>,
    /// The `@agent_state` user option previously written for this pane,
    /// read straight from the pane format.
    pub written_state: String,
    /// The `@agent` user option (agent label) previously written, if any.
    pub written_agent: String,
    /// The `@dingger_ack` user option: "1" when the user already jumped to
    /// this pane in its current ready episode.
    pub written_ack: String,
    /// The pane is the active pane of the active window.
    pub pane_active: bool,
}

impl Pane {
    /// Panes the user is actively looking at suppress finished notifications,
    /// mirroring herdr's active-tab suppression.
    pub fn suppresses_notifications(&self) -> bool {
        self.window_active && self.session_attached
    }

    /// The pane is fully focused: the user is looking at this exact pane.
    pub fn attended(&self) -> bool {
        self.pane_active && self.suppresses_notifications()
    }
}

fn run_tmux(args: &[&str]) -> Result<String, String> {
    let mut command = Command::new("tmux");
    // -u forces UTF-8 mode: without it, tmux mangles format output in
    // non-UTF-8 locales (launchd/cron default to the C locale, turning the
    // tab separators in our -F formats into underscores).
    command.arg("-u");
    // -L selects a named server socket; lets tests and multi-server setups
    // point dingger at a specific server.
    if let Some(socket) = std::env::var_os("DINGGER_TMUX_SOCKET") {
        command.arg("-L").arg(socket);
    }
    let output = command
        .args(args)
        .output()
        .map_err(|err| format!("failed to run tmux: {err}"))?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("tmux {} failed: {}", args.join(" "), stderr.trim()));
    }
    Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}

pub fn list_panes() -> Result<Vec<Pane>, String> {
    let format = concat!(
        "#{pane_id}\t",
        "#{pane_current_command}\t",
        "#{pane_title}\t",
        "#{pane_dead}\t",
        "#{window_active}\t",
        "#{session_attached}\t",
        "#{pane_start_command}\t",
        "#{pane_pid}\t",
        "#{@agent_state}\t",
        "#{@agent}\t",
        "#{@dingger_ack}\t",
        "#{pane_active}\t",
        "#{session_name}:#{window_name}\t",
        "#{window_panes}\t",
        "#{pane_index}",
    );
    let out = run_tmux(&["list-panes", "-a", "-F", format])?;
    let mut panes = Vec::new();
    for line in out.lines() {
        let fields: Vec<&str> = line.split('\t').collect();
        if fields.len() < 15 {
            continue;
        }
        let current_command = fields[1].to_string();
        let start_command = fields[6].to_string();
        let pane_pid: Option<u32> = fields[7].trim().parse().ok();
        // An agent may be started via a wrapper or still be initializing
        // behind the shell; `pane_start_command` covers launch-command cases.
        let mut agent =
            identify_agent(&current_command).or_else(|| identify_agent(&start_command));
        // Some agents rename their process (claude sets its title to the
        // version string), so `pane_current_command` alone is not enough.
        let mut process_tree = None;
        if agent.is_none() {
            let tree = process_tree.get_or_insert_with(fetch_process_tree);
            agent = resolve_agent_in_process_tree(pane_pid, tree);
        }
        // Display target: session:window-name, pane index only when split.
        let mut display_target = fields[12].to_string();
        if fields[13].parse::<u32>().map(|n| n > 1).unwrap_or(false) {
            display_target.push('.');
            display_target.push_str(fields[14]);
        }
        panes.push(Pane {
            pane_id: fields[0].to_string(),
            display_target,
            current_command,
            pane_title: fields[2].to_string(),
            dead: fields[3] == "1",
            window_active: fields[4] == "1",
            session_attached: fields[5] != "0",
            agent,
            written_state: fields[8].to_string(),
            written_agent: fields[9].to_string(),
            written_ack: fields[10].to_string(),
            pane_active: fields[11] == "1",
        });
    }
    Ok(panes)
}

type ProcessTree = (std::collections::HashMap<u32, Vec<u32>>, std::collections::HashMap<u32, String>);

/// Identify the pane's agent by walking its process tree. Some agents rename
/// their process (claude sets its title to the version string), so the kernel
/// name in `pane_current_command` is not enough; `ps` still shows the real
/// binary path. One `ps` call per `list_panes` covers all panes.
fn resolve_agent_in_process_tree(pane_pid: Option<u32>, tree: &ProcessTree) -> Option<Agent> {
    let pane_pid = pane_pid?;
    let (children, comm) = tree;

    // BFS from the pane's shell.
    let mut queue = std::collections::VecDeque::from([pane_pid]);
    while let Some(pid) = queue.pop_front() {
        if let Some(name) = comm.get(&pid) {
            if let Some(agent) = identify_agent(name) {
                return Some(agent);
            }
        }
        if let Some(child_ids) = children.get(&pid) {
            for child in child_ids {
                queue.push_back(*child);
            }
        }
    }
    None
}

fn fetch_process_tree() -> ProcessTree {
    let Ok(output) = Command::new("ps").args(["-axo", "pid=,ppid=,comm="]).output() else {
        return Default::default();
    };
    if !output.status.success() {
        return Default::default();
    }
    let mut children: std::collections::HashMap<u32, Vec<u32>> =
        std::collections::HashMap::new();
    let mut comm: std::collections::HashMap<u32, String> = std::collections::HashMap::new();
    for line in String::from_utf8_lossy(&output.stdout).lines() {
        // Columns are whitespace-aligned, so runs of spaces separate pid,
        // ppid, and the command path; the command itself may contain spaces.
        let Some((pid, rest)) = line.trim_start().split_once(char::is_whitespace) else {
            continue;
        };
        let Some((ppid, name)) = rest.trim_start().split_once(char::is_whitespace) else {
            continue;
        };
        let name = name.trim_start();
        let (Ok(pid), Ok(ppid)) = (pid.parse::<u32>(), ppid.parse::<u32>()) else {
            continue;
        };
        children.entry(ppid).or_default().push(pid);
        let basename = name.rsplit('/').next().unwrap_or(name);
        comm.insert(pid, basename.to_string());
    }
    (children, comm)
}

/// Run a tmux command whose effect is an action (e.g. switch-client), not
/// output to parse.
pub fn run_tmux_client(args: &[&str]) -> Result<(), String> {
    run_tmux(args).map(|_| ())
}

/// Read a format expansion for one pane.
pub fn show_pane_format(pane_id: &str, format: &str) -> Option<String> {
    run_tmux(&["display-message", "-p", "-t", pane_id, format])
        .ok()
        .map(|value| value.trim().to_string())
}

/// Capture the pane's visible screen as plain text — the exact input shape
/// the detection manifests expect.
pub fn capture_pane(pane_id: &str) -> Result<String, String> {
    run_tmux(&["capture-pane", "-p", "-q", "-t", pane_id])
}

/// Write the pane's display status (herdr's vocabulary: done/idle/...).
pub fn set_agent_state(pane_id: &str, label: &str) -> Result<(), String> {
    run_tmux(&["set-option", "-p", "-t", pane_id, "@agent_state", label]).map(|_| ())
}

/// Label the pane with the agent running in it, for tmux status-line and
/// menu-bar rendering; clears the label when the pane stops running one.
pub fn set_agent(pane_id: &str, agent: Option<Agent>) -> Result<(), String> {
        let label = agent.map(detect_core::agent_label).unwrap_or("");
        run_tmux(&["set-option", "-p", "-t", pane_id, "@agent", label]).map(|_| ())
}

/// Write a server-global option (readable from any client and from formats).
pub fn set_global(name: &str, value: &str) -> Result<(), String> {
    run_tmux(&["set-option", "-g", name, value]).map(|_| ())
}

pub fn show_global(name: &str) -> Option<String> {
    run_tmux(&["show-option", "-gv", name])
        .ok()
        .map(|value| value.trim().to_string())
        .filter(|value| !value.is_empty())
}

/// Mark a pane as seen by the user after `dingger focus`: taken out of the
/// ready queue until its next state transition.
pub fn ack(pane_id: &str) -> Result<(), String> {
    run_tmux(&["set-option", "-p", "-t", pane_id, "@dingger_ack", "1"]).map(|_| ())
}

pub fn clear_ack(pane_id: &str) -> Result<(), String> {
    run_tmux(&["set-option", "-p", "-t", pane_id, "-u", "@dingger_ack"]).map(|_| ())
}