@team-agent/installer 0.5.108 → 0.5.110

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;
 
@@ -548,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> {
@@ -568,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;
         }
@@ -620,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)]
@@ -1335,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)]

package/crates/team-agent/src/leader/start.rs

@@ -291,7 +291,7 @@ fn leader_start_plan_with_ambient_authority(
         ),
         _ => None,
     };
-    let provider_argv = if provider == Provider::Pi && mode != LeaderStartMode::AttachExisting {
+    let mut provider_argv = if provider == Provider::Pi && mode != LeaderStartMode::AttachExisting {
         let parsed = crate::lifecycle::launch::pi_mcp::parse_pi_leader_args(provider_args)
             .map_err(|error| LeaderError::Start(error.to_string()))?;
         let mcp_config = adapter
@@ -329,6 +329,10 @@ fn leader_start_plan_with_ambient_authority(
     } else {
         provider_command_argv(provider, provider_args)
     };
+    if mode != LeaderStartMode::AttachExisting {
+        crate::provider::argv_route::apply(provider, &mut provider_argv)
+            .map_err(|error| LeaderError::Start(error.to_string()))?;
+    }
     let argv = start_argv(
         mode,
         provider,

package/crates/team-agent/src/lifecycle/launch/spawn.rs

@@ -330,6 +330,8 @@ pub(super) fn spawn_agents(
             ensure_grok_login_and_folder_trust(workspace)?;
             apply_grok_mcp_overlay(workspace, &mcp_config)?;
         }
+        crate::provider::argv_route::apply(provider, &mut plan.argv)
+            .map_err(|error| LifecycleError::Provider(error.to_string()))?;
         let spawn_epoch = u64::try_from(started.len()).unwrap_or(u64::MAX);
         let spawned_at = spawn_timestamp_for_agent(u32::try_from(spawn_epoch).unwrap_or(u32::MAX));
         // E6 层1 实证3 + 诊断留痕:落最终 worker argv(spawn 前的真实形态)。

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -516,6 +516,8 @@ pub(super) fn spawn_agent_window(
     // Keep the launcher-known typed provider independent from inherited
     // LEADER_* identity. The tmux wrapper binds pane/socket at invocation time.
     crate::layout::worker_env::inject_current_caller_provider(&mut env, provider);
+    crate::provider::argv_route::apply(provider, &mut plan.argv)
+        .map_err(|error| LifecycleError::Provider(error.to_string()))?;
 
     // 0.4.6 Stage 2: write actual spawn plan event BEFORE invoking the
     // transport spawn. Mirrors `launch.rs:359-380` (the reference impl)