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};

#[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,
    /// Last OSC title the pane's application set, from `#{pane_title}`.
    pub pane_title: String,
    /// Working directory of the pane's foreground process.
    pub cwd: String,
    pub dead: bool,
    /// The user is looking at this pane's window: it is the current window
    /// of a session with an attached client. herdr marks every pane of the
    /// active tab seen (`mark_active_tab_seen`); a tmux window is a tab.
    pub attended: bool,
    pub agent: Option<Agent>,
    /// Pane options written by dingger (see the watcher module docs).
    pub written_state: String,
    pub written_agent: String,
    pub written_ack: String,
    pub written_since: String,
    pub written_hook: String,
    pub written_name: String,
    pub written_session: String,
    /// `@dingger_importance`: unset for normal.
    pub written_importance: String,
    pub written_extension: String,
    pub written_control: String,
}


/// The tmux binary. launchd starts dingger, and the menu bar app that runs
/// `dingger focus`, with PATH=/usr/bin:/bin:/usr/sbin:/sbin, where Homebrew's
/// tmux is not found: fall back to the usual install locations.
fn tmux_binary() -> &'static std::path::Path {
    static TMUX: std::sync::OnceLock<std::path::PathBuf> = std::sync::OnceLock::new();
    TMUX.get_or_init(|| {
        if let Some(path) = std::env::var_os("DINGGER_TMUX") {
            return path.into();
        }
        let on_path: Vec<std::path::PathBuf> = std::env::var_os("PATH")
            .map(|path| std::env::split_paths(&path).map(|dir| dir.join("tmux")).collect())
            .unwrap_or_default();
        let known = ["/opt/homebrew/bin/tmux", "/usr/local/bin/tmux", "/usr/bin/tmux"]
            .map(std::path::PathBuf::from);
        on_path
            .into_iter()
            .chain(known)
            .find(|candidate| candidate.is_file())
            .unwrap_or_else(|| "tmux".into())
    })
}

/// Run a tmux command against the server dingger watches.
pub fn run(args: &[&str]) -> Result<String, String> {
    run_tmux(args)
}

fn run_tmux(args: &[&str]) -> Result<String, String> {
    let mut command = Command::new(tmux_binary());
    // -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);
    }
    // The config a server started by dingger (restore) loads; tests use
    // /dev/null.
    if let Some(config) = std::env::var_os("DINGGER_TMUX_CONFIG") {
        command.arg("-f").arg(config);
    }
    let output = command
        .args(args)
        .output()
        .map_err(|err| format!("failed to run tmux ({}): {err}", tmux_binary().display()))?;
    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())
}

/// Every pane, once. A pane in several sessions (a session group, or a
/// linked window) keeps its first listing (tmux lists sessions by name),
/// and is attended if the user looks at it in any of them.
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",
        "#{@dingger_since}\t",
        "#{@dingger_hook}\t",
        "#{session_name}:#{window_name}\t",
        "#{window_panes}\t",
        "#{pane_index}\t",
        "#{pane_current_path}\t",
        "#{@agent_name}\t",
        "#{@agent_session}\t",
        "#{@dingger_importance}\t",
        "#{@dingger_extension}\t",
        "#{@dingger_control}",
    );
    let out = run_tmux(&["list-panes", "-a", "-F", format])?;
    let mut panes: Vec<Pane> = Vec::new();
    let mut process_tree = None;
    for line in out.lines() {
        let fields: Vec<&str> = line.split('\t').collect();
        if fields.len() < 22 {
            continue;
        }
        let attended = fields[4] == "1" && fields[5] != "0";
        if let Some(listed) = panes.iter_mut().find(|pane| pane.pane_id == fields[0]) {
            listed.attended |= attended;
            continue;
        }
        let current_command = fields[1];
        let start_command = fields[6];
        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.
        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[13].to_string();
        if fields[14].parse::<u32>().map(|n| n > 1).unwrap_or(false) {
            display_target.push('.');
            display_target.push_str(fields[15]);
        }
        panes.push(Pane {
            pane_id: fields[0].to_string(),
            display_target,
            pane_title: fields[2].to_string(),
            cwd: fields[16].to_string(),
            dead: fields[3] == "1",
            attended,
            agent,
            written_state: fields[8].to_string(),
            written_agent: fields[9].to_string(),
            written_ack: fields[10].to_string(),
            written_since: fields[11].to_string(),
            written_hook: fields[12].to_string(),
            written_name: fields[17].to_string(),
            written_session: fields[18].to_string(),
            written_importance: fields[19].to_string(),
            written_extension: fields[20].to_string(),
            written_control: fields[21].to_string(),
        });
    }
    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)
}

/// 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])
}

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

/// Set (`Some`) or unset (`None`) several pane options in one tmux command
/// list, applied as a unit.
pub fn set_pane_options(pane_id: &str, changes: &[(&str, Option<String>)]) -> Result<(), String> {
    let mut args: Vec<&str> = Vec::new();
    for (name, value) in changes {
        if !args.is_empty() {
            args.push(";");
        }
        match value {
            Some(value) => args.extend(["set-option", "-p", "-t", pane_id, name, value.as_str()]),
            None => args.extend(["set-option", "-p", "-u", "-t", pane_id, name]),
        }
    }
    if args.is_empty() {
        return Ok(());
    }
    run_tmux(&args).map(|_| ())
}

pub fn unset_pane_option(pane_id: &str, name: &str) -> Result<(), String> {
    run_tmux(&["set-option", "-p", "-u", "-t", pane_id, name]).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())
}

/// Expand a format in the context of a pane.
pub fn 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())
        .filter(|value| !value.is_empty())
}

/// Expand a format in the context of a client (its current pane/window).
pub fn client_format(client: &str, format: &str) -> Option<String> {
    // For a client that is gone, tmux answers for the current one instead:
    // the answer names its client, and must name this one.
    let out = run_tmux(&["display-message", "-p", "-c", client, &format!("#{{client_name}}\t{format}")]).ok()?;
    let (name, value) = out.trim_end_matches('\n').split_once('\t')?;
    let value = value.trim();
    (name == client && !value.is_empty()).then(|| value.to_string())
}

/// The sessions holding a pane's window (several: a session group, a linked
/// window).
pub fn sessions_with_pane(pane_id: &str) -> Vec<String> {
    run_tmux(&["list-panes", "-a", "-F", "#{session_id}\t#{pane_id}"])
        .unwrap_or_default()
        .lines()
        .filter_map(|line| line.split_once('\t').filter(|(_, pane)| *pane == pane_id).map(|(s, _)| s.to_string()))
        .collect()
}

/// Show a pane in a client: switch the client to the pane's window and make
/// the pane the active one.
///
/// `session`: the client's own session, when it holds the pane's window;
/// the client stays on it (a pane target alone lets tmux pick a session,
/// which in a session group may be another one).
pub fn show_pane(client: &str, pane_id: &str, session: Option<&str>) -> Result<(), String> {
    let target = match session {
        Some(session) => {
            let window = pane_format(pane_id, "#{window_id}").ok_or_else(|| format!("no pane {pane_id}"))?;
            format!("{session}:{window}")
        }
        None => pane_id.to_string(),
    };
    run_tmux(&["switch-client", "-c", client, "-t", &target])?;
    run_tmux(&["select-pane", "-t", pane_id]).map(|_| ())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_ps_tree() {
        let (children, comm) = fetch_process_tree();
        assert!(comm.contains_key(&1u32), "launchd should be present");
        assert!(!children.is_empty());
    }
}