@team-agent/installer 0.5.107 → 0.5.109

package/crates/team-agent/src/cli/status_port/brief.rs

@@ -5,7 +5,7 @@
 //! status brief contract.
 
 use serde_json::{json, Map, Value};
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 use std::path::Path;
 use std::process::Command;
 
@@ -117,6 +117,14 @@ struct BriefNode {
     tmux_command: Option<String>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct AttachContext {
+    endpoint: String,
+    session: String,
+    window: String,
+    pane: String,
+}
+
 #[derive(Debug)]
 struct ProbeResult {
     nodes: Vec<ProbeNode>,
@@ -150,34 +158,45 @@ pub(crate) fn status_brief_scoped(
     state: &Value,
     agent: Option<&str>,
 ) -> Value {
-    let registered = registered_nodes(state, agent);
-    let probes = probe_registered_endpoints(&registered);
-    let nodes = registered
-        .iter()
-        .map(|node| project_node(node, probes.get(node.endpoint.as_deref().unwrap_or(""))))
-        .collect::<Vec<_>>();
+    let nodes = project_status_nodes(state, agent);
     json!({
-        "nodes": nodes.into_iter().map(BriefNode::into_json).collect::<Vec<_>>()
+        "nodes": nodes
+            .into_iter()
+            .map(|(node, _)| node.into_json())
+            .collect::<Vec<_>>()
     })
 }
 
-/// Human output is the exact same nine-field projection as JSON, rendered in
-/// stable field order. Null values remain explicit rather than becoming a
-/// diagnostic or an inferred value.
+/// Human output keeps the legacy single-node form and groups shared attach
+/// context only when multiple nodes make that repetition useful.
 pub(crate) fn format_status_brief(
-    workspace: &Path,
+    _workspace: &Path,
     state: &Value,
     agent: Option<&str>,
 ) -> String {
-    let value = status_brief_scoped(workspace, state, agent);
-    value
-        .get("nodes")
-        .and_then(Value::as_array)
-        .into_iter()
-        .flatten()
-        .filter_map(format_brief_node)
-        .collect::<Vec<_>>()
-        .join("\n")
+    let nodes = project_status_nodes(state, agent);
+    if nodes.len() <= 1 {
+        return nodes
+            .into_iter()
+            .filter_map(|(node, _)| format_brief_node(&node.into_json()))
+            .collect::<Vec<_>>()
+            .join("\n");
+    }
+    format_multi_node_brief(nodes)
+}
+
+fn project_status_nodes(
+    state: &Value,
+    agent: Option<&str>,
+) -> Vec<(BriefNode, Option<AttachContext>)> {
+    let registered = registered_nodes(state, agent);
+    let probes = probe_registered_endpoints(&registered);
+    registered
+        .iter()
+        .map(|node| {
+            project_node_with_attach(node, probes.get(node.endpoint.as_deref().unwrap_or("")))
+        })
+        .collect()
 }
 
 pub(crate) fn registered_agent_exists(state: &Value, agent: &str) -> bool {
@@ -322,6 +341,86 @@ fn format_brief_node(value: &Value) -> Option<String> {
     ))
 }
 
+fn format_multi_node_brief(nodes: Vec<(BriefNode, Option<AttachContext>)>) -> String {
+    let mut groups = Vec::<(String, String)>::new();
+    for (_, context) in &nodes {
+        let Some(context) = context else { continue };
+        if !groups.iter().any(|(endpoint, session)| {
+            endpoint == &context.endpoint && session == &context.session
+        }) {
+            groups.push((context.endpoint.clone(), context.session.clone()));
+        }
+    }
+
+    let mut lines = groups
+        .iter()
+        .enumerate()
+        .map(|(index, (endpoint, session))| {
+            format_attach_template(index + 1, endpoint, session)
+        })
+        .collect::<Vec<_>>();
+    if !groups.is_empty() {
+        lines.push(
+            "TMUX templates: replace <target> with the window.pane part of the matching ATTACH value."
+                .to_string(),
+        );
+    }
+    lines.push(
+        "NAME\tPROVIDER\tMODEL\tEFFORT\tRUNTIME_STATUS\tACTIVITY\tHEALTH\tSESSION_NAME\tATTACH"
+            .to_string(),
+    );
+    for (node, context) in nodes {
+        let attach = context
+            .as_ref()
+            .and_then(|context| {
+                groups
+                    .iter()
+                    .position(|(endpoint, session)| {
+                        endpoint == &context.endpoint && session == &context.session
+                    })
+                    .map(|index| format!("{}:{}.{}", index + 1, context.window, context.pane))
+            })
+            .unwrap_or_else(|| "null".to_string());
+        lines.push(
+            [
+                escape_human_cell(&node.name),
+                escape_human_cell(&node.provider),
+                escape_human_cell(node.model.as_deref().unwrap_or("null")),
+                escape_human_cell(node.effort.as_deref().unwrap_or("null")),
+                escape_human_cell(&node.runtime_status),
+                escape_human_cell(&node.activity),
+                escape_human_cell(&node.health),
+                escape_human_cell(node.session_name.as_deref().unwrap_or("null")),
+                escape_human_cell(&attach),
+            ]
+            .join("\t"),
+        );
+    }
+    lines.join("\n")
+}
+
+fn format_attach_template(group: usize, endpoint: &str, session: &str) -> String {
+    let flag = if Path::new(endpoint).is_absolute() {
+        "-S"
+    } else {
+        "-L"
+    };
+    let target = format!("{session}:<target>");
+    format!(
+        "TMUX[{group}] tmux {flag} {} attach -t {}",
+        shell_quote(endpoint),
+        shell_quote(&target)
+    )
+}
+
+fn escape_human_cell(value: &str) -> String {
+    value
+        .replace('\\', "\\\\")
+        .replace('\t', "\\t")
+        .replace('\n', "\\n")
+        .replace('\r', "\\r")
+}
+
 fn display_optional(value: &Value) -> String {
     value
         .as_str()
@@ -449,11 +548,37 @@ fn sample_native_endpoint(
     registered: &[RegisteredNode],
 ) -> Option<ProbeResult> {
     let output = run_native_tmux_list_panes(endpoint)?;
-    let nodes = output
-        .lines()
-        .filter_map(|line| parse_native_pane(line, endpoint, registered))
-        .collect::<Vec<_>>();
-    Some(ProbeResult { nodes })
+    Some(sample_native_panes(&output, endpoint, registered, process_snapshots))
+}
+
+fn sample_native_panes(
+    output: &str,
+    endpoint: &str,
+    registered: &[RegisteredNode],
+    snapshots: impl FnOnce(&BTreeSet<u32>) -> BTreeMap<u32, ProcessSnapshot>,
+) -> ProbeResult {
+    let panes = output.lines().filter_map(native_pane_fields).collect::<Vec<_>>();
+    let pids = panes.iter().filter_map(|fields| native_pane_pid(fields[3])).collect::<BTreeSet<_>>();
+    let processes = if pids.is_empty() { BTreeMap::new() } else { snapshots(&pids) };
+    let nodes = panes.into_iter()
+        .filter_map(|fields| parse_native_pane(fields, endpoint, registered, &processes))
+        .collect();
+    ProbeResult { nodes }
+}
+
+fn native_pane_fields(line: &str) -> Option<[&str; 5]> {
+    let mut fields = line.split('\t');
+    let session = fields.next()?;
+    let window = fields.next()?;
+    let pane = fields.next()?;
+    let pid = fields.next().unwrap_or_default();
+    let command = fields.next().unwrap_or_default();
+    if session.is_empty() || window.is_empty() || pane.is_empty() { return None; }
+    Some([session, window, pane, pid, command])
+}
+
+fn native_pane_pid(pid: &str) -> Option<u32> {
+    pid.parse::<u32>().ok().filter(|pid| *pid > 0 && *pid <= i32::MAX as u32)
 }
 
 fn run_native_tmux_list_panes(endpoint: &str) -> Option<String> {
@@ -469,27 +594,23 @@ fn run_native_tmux_list_panes(endpoint: &str) -> Option<String> {
 }
 
 fn parse_native_pane(
-    line: &str,
+    fields: [&str; 5],
     endpoint: &str,
     registered: &[RegisteredNode],
+    processes: &BTreeMap<u32, ProcessSnapshot>,
 ) -> Option<ProbeNode> {
-    let mut fields = line.split('\t');
-    let session = fields.next()?.to_string();
-    let window = fields.next()?.to_string();
-    let pane = fields.next()?.to_string();
-    let pid = fields.next().filter(|value| !value.is_empty());
-    let command = fields.next().unwrap_or_default();
-    if session.is_empty() || window.is_empty() || pane.is_empty() {
-        return None;
-    }
+    let [session, window, pane, pid, command] = fields;
+    let session = session.to_string();
+    let window = window.to_string();
+    let pane = pane.to_string();
     let matched = registered.iter().find(|node| {
         node.endpoint.as_deref() == Some(endpoint)
             && node.session.as_deref() == Some(session.as_str())
             && node.window.as_deref().is_none_or(|value| value == window)
             && node.pane.as_deref() == Some(pane.as_str())
     });
-    if let Some(pid) = pid {
-        let snapshot = process_snapshot(pid)?;
+    if !pid.is_empty() {
+        let snapshot = processes.get(&native_pane_pid(pid)?)?;
         if snapshot.zombie {
             return None;
         }
@@ -521,22 +642,35 @@ struct ProcessSnapshot {
     zombie: bool,
 }
 
-fn process_snapshot(pid: &str) -> Option<ProcessSnapshot> {
-    let output = Command::new("ps")
-        .args(["-o", "pid=,ppid=,stat=,comm=", "-p", pid])
-        .output()
-        .ok()?;
-    if !output.status.success() || String::from_utf8_lossy(&output.stdout).trim().is_empty() {
-        return None;
+fn process_snapshot_command(pids: &BTreeSet<u32>) -> Command {
+    let pids = pids.iter().map(u32::to_string).collect::<Vec<_>>().join(",");
+    let mut command = Command::new("ps");
+    command.args(["-o", "pid=,ppid=,stat=,comm=", "-p", &pids]);
+    command
+}
+
+fn process_snapshots(pids: &BTreeSet<u32>) -> BTreeMap<u32, ProcessSnapshot> {
+    if pids.is_empty() { return BTreeMap::new(); }
+    let Ok(output) = process_snapshot_command(pids).output() else { return BTreeMap::new(); };
+    if !output.status.success() { return BTreeMap::new(); }
+    parse_process_snapshots(&output.stdout, pids)
+}
+
+fn parse_process_snapshots(bytes: &[u8], requested: &BTreeSet<u32>) -> BTreeMap<u32, ProcessSnapshot> {
+    let mut snapshots = BTreeMap::<u32, ProcessSnapshot>::new();
+    let output = String::from_utf8_lossy(bytes);
+    for line in output.lines() {
+        let mut fields = line.split_whitespace();
+        let Some(pid) = fields.next().and_then(native_pane_pid) else { continue; };
+        if !requested.contains(&pid) { continue; }
+        let Some(_ppid) = fields.next() else { continue; };
+        let Some(stat) = fields.next() else { continue; };
+        let zombie = stat.contains('Z');
+        snapshots.entry(pid)
+            .and_modify(|snapshot| snapshot.zombie |= zombie)
+            .or_insert(ProcessSnapshot { zombie });
     }
-    let output_text = String::from_utf8_lossy(&output.stdout);
-    let stat = output_text
-        .split_whitespace()
-        .nth(2)
-        .unwrap_or_default();
-    Some(ProcessSnapshot {
-        zombie: stat.contains('Z'),
-    })
+    snapshots
 }
 
 #[cfg(test)]
@@ -1051,14 +1185,22 @@ fn non_empty(value: &Value, key: &str) -> Option<String> {
         .map(str::to_string)
 }
 
+#[cfg(test)]
 fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> BriefNode {
+    project_node_with_attach(node, probe).0
+}
+
+fn project_node_with_attach(
+    node: &RegisteredNode,
+    probe: Option<&Option<ProbeResult>>,
+) -> (BriefNode, Option<AttachContext>) {
     let stopped = matches!(
         node.lifecycle.as_deref(),
         Some("stopped" | "done" | "failed" | "error" | "terminated")
     );
     let matched = match_result(node, probe);
     if stopped {
-        return match matched {
+        let projected = match matched {
             MatchResult::Missing => BriefNode {
                 name: node.name.clone(),
                 provider: node.provider.clone(),
@@ -1072,14 +1214,15 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
             },
             MatchResult::Unique(_) | MatchResult::Ambiguous => BriefNode::unknown(node),
         };
+        return (projected, None);
     }
     let MatchResult::Unique(observed) = matched else {
-        return BriefNode::unknown(node);
+        return (BriefNode::unknown(node), None);
     };
     if !node.provider.eq_ignore_ascii_case("unknown")
         && !node.provider.eq_ignore_ascii_case(&observed.provider)
     {
-        return BriefNode::unknown(node);
+        return (BriefNode::unknown(node), None);
     }
     let pi_channel = observed.provider.eq_ignore_ascii_case("pi")
         && observed.evidence_method.as_deref() == Some("pi_activity_channel");
@@ -1097,21 +1240,31 @@ fn project_node(node: &RegisteredNode, probe: Option<&Option<ProbeResult>>) -> B
     } else {
         valid_health(&observed.health)
     };
-    BriefNode {
-        name: node.name.clone(),
-        provider: if node.provider.eq_ignore_ascii_case("unknown") {
-            observed.provider.clone()
-        } else {
-            node.provider.clone()
+    let tmux_command = tmux_command(node, observed);
+    let attach = tmux_command.as_ref().map(|_| AttachContext {
+        endpoint: observed.socket.clone(),
+        session: observed.session.clone(),
+        window: observed.window.clone(),
+        pane: observed.pane.clone(),
+    });
+    (
+        BriefNode {
+            name: node.name.clone(),
+            provider: if node.provider.eq_ignore_ascii_case("unknown") {
+                observed.provider.clone()
+            } else {
+                node.provider.clone()
+            },
+            model: node.model.clone(),
+            effort: node.effort.clone(),
+            runtime_status: "running".to_string(),
+            activity: activity.to_string(),
+            health: health.to_string(),
+            session_name: observed.session_name.clone(),
+            tmux_command,
         },
-        model: node.model.clone(),
-        effort: node.effort.clone(),
-        runtime_status: "running".to_string(),
-        activity: activity.to_string(),
-        health: health.to_string(),
-        session_name: observed.session_name.clone(),
-        tmux_command: tmux_command(node, observed),
-    }
+        attach,
+    )
 }
 
 fn match_result<'a>(
@@ -1217,6 +1370,162 @@ impl BriefNode {
     }
 }
 
+#[cfg(test)]
+mod native_ps_batch_regressions {
+    #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+    use super::*;
+
+    fn registered(endpoint: &str, pane: &str) -> RegisteredNode {
+        RegisteredNode {
+            name: format!("{endpoint}-{pane}"),
+            provider: "pi".into(),
+            model: Some("fixture-model".into()),
+            effort: Some("high".into()),
+            endpoint: Some(endpoint.into()),
+            session: Some("hp".into()),
+            window: Some("w".into()),
+            pane: Some(pane.into()),
+            lifecycle: None,
+        }
+    }
+
+    #[test]
+    fn eight_panes_use_one_endpoint_query() {
+        let registered = (0..8).map(|i| registered("e1", &format!("%{i}"))).collect::<Vec<_>>();
+        let panes = (0..8).map(|i| format!("hp\tw\t%{i}\t{}\tpi\n", 100 + i)).collect::<String>();
+        let rows = (0..8).map(|i| format!("{} 1 S pi\n", 100 + i)).collect::<String>();
+        let mut calls = Vec::new();
+        let result = sample_native_panes(&panes, "e1", &registered, |pids| {
+            calls.push(pids.iter().copied().collect::<Vec<_>>());
+            parse_process_snapshots(rows.as_bytes(), pids)
+        });
+        assert_eq!(calls, vec![(100..108).collect::<Vec<_>>()]);
+        assert_eq!(result.nodes.len(), 8);
+        assert!(result.nodes.iter().all(|node| node.provider == "pi" && node.activity == "working" && node.health == "normal"));
+    }
+
+    #[test]
+    fn pid_deduplication_and_command_preserve_the_privacy_whitelist() {
+        let mut calls = Vec::new();
+        let result = sample_native_panes("hp\tw\t%1\t11\tsh\nhp\tw\t%2\t011\tsh\n", "e1", &[], |pids| {
+            calls.push(pids.iter().copied().collect::<Vec<_>>());
+            parse_process_snapshots(b"11 1 S sh\n", pids)
+        });
+        assert_eq!(calls, vec![vec![11]]);
+        assert_eq!(result.nodes.len(), 2);
+        let pids = BTreeSet::from([22, 11]);
+        let command = process_snapshot_command(&pids);
+        assert_eq!(command.get_program(), "ps");
+        assert_eq!(
+            command.get_args().map(|arg| arg.to_string_lossy().into_owned()).collect::<Vec<_>>(),
+            vec!["-o", "pid=,ppid=,stat=,comm=", "-p", "11,22"]
+        );
+        let command = process_snapshot_command(&BTreeSet::from([11]));
+        assert_eq!(command.get_args().last().unwrap(), "11");
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn native_ps_partial_selection_preserves_a_live_pid() {
+        let pid = std::process::id();
+        let requested = BTreeSet::from([pid, i32::MAX as u32]);
+        let command = process_snapshot_command(&requested);
+        // Absolute ps avoids unrelated PATH-fixture mutation in parallel unit tests.
+        let output = Command::new("/bin/ps").args(command.get_args()).output().unwrap();
+        assert!(output.status.success(), "partial PID selection must not poison the live row");
+        let snapshots = parse_process_snapshots(&output.stdout, &requested);
+        assert!(!snapshots.get(&pid).unwrap().zombie);
+        assert!(!snapshots.contains_key(&(i32::MAX as u32)));
+    }
+
+    #[test]
+    fn single_pane_keeps_its_native_health_and_activity() {
+        let registered = vec![registered("e1", "%1")];
+        let result = sample_native_panes("hp\tw\t%1\t11\tsh\n", "e1", &registered, |pids| {
+            assert_eq!(pids, &BTreeSet::from([11]));
+            parse_process_snapshots(b"11 1 S sh\n", pids)
+        });
+        assert_eq!(result.nodes.len(), 1);
+        assert_eq!(result.nodes[0].provider, "pi");
+        assert_eq!(result.nodes[0].activity, "idle");
+        assert_eq!(result.nodes[0].health, "normal");
+    }
+
+    #[test]
+    fn missing_rows_and_zombies_omit_only_their_panes() {
+        let panes = "hp\tw\t%1\t11\tsh\nhp\tw\t%2\t22\tpi\nhp\tw\t%3\t33\tpi\nhp\tw\t%4\t\tsh\n";
+        let result = sample_native_panes(panes, "e1", &[], |pids| {
+            parse_process_snapshots(b"22 1 Z+ dead\n11 1 S sh\n999 1 S unrelated\n33 1\n", pids)
+        });
+        assert_eq!(result.nodes.iter().map(|node| node.pane.as_str()).collect::<Vec<_>>(), vec!["%1", "%4"]);
+        assert!(result.nodes.iter().all(|node| node.activity == "idle" && node.health == "normal"));
+    }
+
+    #[test]
+    fn empty_or_invalid_pid_sets_do_not_run_ps() {
+        let panes = "hp\tw\t%1\t\tsh\nhp\tw\t%2\t0\tsh\nhp\tw\t%3\t1,2\tsh\nhp\tw\t%4\t4294967295\tsh\n\tw\t%5\t99\tsh\n";
+        let result = sample_native_panes(panes, "e1", &[], |_| panic!("no valid PID means no ps query"));
+        assert_eq!(result.nodes.len(), 1);
+        assert_eq!(result.nodes[0].pane, "%1");
+        assert_eq!(result.nodes[0].health, "normal");
+    }
+
+    #[test]
+    fn snapshot_failure_and_endpoint_results_are_not_shared() {
+        let registered = vec![registered("e1", "%1"), registered("e2", "%1")];
+        let mut calls = Vec::new();
+        let first = sample_native_panes("hp\tw\t%1\t88\tsh\n", "e1", &registered, |pids| {
+            calls.push(("e1", pids.iter().copied().collect::<Vec<_>>()));
+            BTreeMap::new()
+        });
+        let second = sample_native_panes("hp\tw\t%1\t88\tsh\n", "e2", &registered, |pids| {
+            calls.push(("e2", pids.iter().copied().collect::<Vec<_>>()));
+            parse_process_snapshots(b"88 1 S sh\n", pids)
+        });
+        assert_eq!(calls, vec![("e1", vec![88]), ("e2", vec![88])]);
+        assert!(first.nodes.is_empty());
+        assert_eq!(second.nodes.len(), 1);
+        let failed = Some(first);
+        assert_eq!(project_node_with_attach(&registered[0], Some(&failed)).0.health, "unknown");
+        let live = Some(second);
+        assert_eq!(project_node_with_attach(&registered[1], Some(&live)).0.health, "normal");
+    }
+
+    #[test]
+    fn duplicate_process_rows_cannot_hide_a_zombie() {
+        let requested = BTreeSet::from([11]);
+        for rows in [b"11 1 Z dead\n11 1 S sh\n".as_slice(), b"11 1 S sh\n11 1 Z dead\n".as_slice()] {
+            assert!(parse_process_snapshots(rows, &requested).get(&11).unwrap().zombie);
+        }
+        assert!(parse_process_snapshots(b"not a process row\n", &requested).is_empty());
+    }
+
+    #[test]
+    fn json_and_human_keep_nine_fields_without_ps_details() {
+        let registered = vec![registered("e1", "%1"), registered("e1", "%2")];
+        let probe = Some(sample_native_panes(
+            "hp\tw\t%1\t11\tsh\nhp\tw\t%2\t22\tpi\n", "e1", &registered,
+            |pids| parse_process_snapshots(b"22 1 R PRIVATE_COMMAND_DETAIL\n11 1 S PRIVATE_COMMAND_DETAIL\n", pids),
+        ));
+        let projected = registered.iter().map(|node| project_node_with_attach(node, Some(&probe))).collect::<Vec<_>>();
+        let keys = BTreeSet::from(["name", "provider", "model", "effort", "runtime_status", "activity", "health", "session_name", "tmux_command"]);
+        for (node, _) in &projected {
+            let json = node.clone().into_json();
+            assert_eq!(json.as_object().unwrap().keys().map(String::as_str).collect::<BTreeSet<_>>(), keys);
+            assert_eq!(json["model"], "fixture-model");
+            assert_eq!(json["effort"], "high");
+            assert_eq!(json["runtime_status"], "running");
+            assert_eq!(json["health"], "normal");
+            assert!(!json.to_string().contains("PRIVATE_COMMAND_DETAIL"));
+        }
+        let human = format_multi_node_brief(projected);
+        let mut lines = human.lines().skip_while(|line| !line.starts_with("NAME\t"));
+        assert_eq!(lines.next().unwrap().split('\t').count(), 9);
+        assert!(lines.all(|line| line.split('\t').count() == 9));
+        assert!(!human.contains("PRIVATE_COMMAND_DETAIL"));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]