@team-agent/installer 0.5.42 → 0.5.44

package/crates/team-agent/src/platform/process.rs

@@ -53,9 +53,7 @@ pub enum TerminationOutcome {
     /// Windows downgraded `TerminateGraceful` to `TerminateProcess`
     /// (no grace period). Includes a machine-readable reason so
     /// callers can log it in the audit event.
-    ForceOnly {
-        reason: &'static str,
-    },
+    ForceOnly { reason: &'static str },
     /// The pid/group was already gone by the time the call resolved.
     /// Not an error.
     AlreadyGone,
@@ -101,6 +99,7 @@ mod unix_impl {
     //! `cli/mod.rs`, `coordinator/backoff.rs`, `mcp_server/wire.rs`,
     //! `lifecycle/restart/agent.rs`) with zero behavioral drift.
     use super::*;
+    use std::process::Command;
 
     pub fn current_parent_pid() -> Option<u32> {
         // Byte-equivalent to `mcp_server/wire.rs:319` and
@@ -152,8 +151,38 @@ mod unix_impl {
         Ok(Vec::new())
     }
 
-    pub fn process_tree(_root: u32) -> Result<Vec<u32>, io::Error> {
-        Ok(Vec::new())
+    pub fn process_tree(root: u32) -> Result<Vec<u32>, io::Error> {
+        let output = Command::new("ps").args(["-axo", "pid=,ppid="]).output()?;
+        if !output.status.success() {
+            return Err(io::Error::new(
+                io::ErrorKind::Other,
+                "ps_parent exited unsuccessfully",
+            ));
+        }
+        let pairs = String::from_utf8_lossy(&output.stdout)
+            .lines()
+            .filter_map(|line| {
+                let mut parts = line.split_whitespace();
+                let pid = parts.next()?.parse::<u32>().ok()?;
+                let ppid = parts.next()?.parse::<u32>().ok()?;
+                Some((pid, ppid))
+            })
+            .collect::<Vec<_>>();
+        let mut out = Vec::new();
+        collect_child_pids(root, &pairs, &mut out);
+        out.push(root);
+        out.sort_unstable();
+        out.dedup();
+        Ok(out)
+    }
+
+    fn collect_child_pids(parent: u32, pairs: &[(u32, u32)], out: &mut Vec<u32>) {
+        for (pid, ppid) in pairs {
+            if *ppid == parent && !out.contains(pid) {
+                out.push(*pid);
+                collect_child_pids(*pid, pairs, out);
+            }
+        }
     }
 
     /// Send a SIGTERM (`TerminateGraceful`) or SIGKILL
@@ -166,10 +195,7 @@ mod unix_impl {
     /// downgrade path); the `AlreadyGone` case is preserved when
     /// `kill()` returns ESRCH (the target was reaped between check
     /// and send).
-    pub fn terminate_pid(
-        pid: u32,
-        kind: SignalKind,
-    ) -> Result<TerminationOutcome, io::Error> {
+    pub fn terminate_pid(pid: u32, kind: SignalKind) -> Result<TerminationOutcome, io::Error> {
         let signal = match kind {
             SignalKind::TerminateGraceful => libc::SIGTERM,
             SignalKind::TerminateForce => libc::SIGKILL,
@@ -275,12 +301,16 @@ mod windows_impl {
         while result.is_ok() {
             if entry.th32ProcessID == my_pid {
                 let ppid = entry.th32ParentProcessID;
-                unsafe { let _ = windows::Win32::Foundation::CloseHandle(snapshot); };
+                unsafe {
+                    let _ = windows::Win32::Foundation::CloseHandle(snapshot);
+                };
                 return Some(ppid);
             }
             result = unsafe { Process32NextW(snapshot, &mut entry) };
         }
-        unsafe { let _ = windows::Win32::Foundation::CloseHandle(snapshot); };
+        unsafe {
+            let _ = windows::Win32::Foundation::CloseHandle(snapshot);
+        };
         None
     }
 
@@ -327,7 +357,9 @@ mod windows_impl {
         };
         let mut exit_code: u32 = 0;
         let result = unsafe { GetExitCodeProcess(handle, &mut exit_code) };
-        unsafe { let _ = CloseHandle(handle); };
+        unsafe {
+            let _ = CloseHandle(handle);
+        };
         result.map_err(|e| io::Error::from_raw_os_error(e.code().0 as i32))?;
         // `STILL_ACTIVE` (0x103) — the process is still running.
         if exit_code == STILL_ACTIVE.0 as u32 {
@@ -358,14 +390,9 @@ mod windows_impl {
         Ok(Vec::new())
     }
 
-    pub fn terminate_pid(
-        pid: u32,
-        kind: SignalKind,
-    ) -> Result<TerminationOutcome, io::Error> {
+    pub fn terminate_pid(pid: u32, kind: SignalKind) -> Result<TerminationOutcome, io::Error> {
         use windows::Win32::Foundation::CloseHandle;
-        use windows::Win32::System::Threading::{
-            OpenProcess, TerminateProcess, PROCESS_TERMINATE,
-        };
+        use windows::Win32::System::Threading::{OpenProcess, TerminateProcess, PROCESS_TERMINATE};
         // CR C-6 anchor: Windows has no SIGTERM analogue for a
         // non-console child. `TerminateGraceful` cannot be honored;
         // we still perform the physical `TerminateProcess` (design
@@ -394,7 +421,9 @@ mod windows_impl {
             }
         };
         let result = unsafe { TerminateProcess(handle, 1) };
-        unsafe { let _ = CloseHandle(handle); };
+        unsafe {
+            let _ = CloseHandle(handle);
+        };
         result.map_err(|e| io::Error::from_raw_os_error(e.code().0 as i32))?;
         Ok(match kind {
             SignalKind::TerminateGraceful => TerminationOutcome::ForceOnly {
@@ -444,7 +473,10 @@ mod tests {
         // Windows (Toolhelp32 snapshot) return the process's parent
         // pid. A `None` here on either platform is a regression.
         let ppid = current_parent_pid();
-        assert!(ppid.is_some(), "current_parent_pid must return Some on both unix and windows");
+        assert!(
+            ppid.is_some(),
+            "current_parent_pid must return Some on both unix and windows"
+        );
         assert!(ppid.unwrap() > 0);
     }
 
@@ -544,9 +576,7 @@ mod tests {
         // pattern-match without cfg.
         assert_ne!(SignalKind::TerminateGraceful, SignalKind::TerminateForce);
         let requested = TerminationOutcome::Requested;
-        let force_only = TerminationOutcome::ForceOnly {
-            reason: "test",
-        };
+        let force_only = TerminationOutcome::ForceOnly { reason: "test" };
         let already_gone = TerminationOutcome::AlreadyGone;
         assert_ne!(requested, force_only);
         assert_ne!(requested, already_gone);

package/crates/team-agent/src/provider/adapters/claude.rs

@@ -8,9 +8,7 @@
 //! helpers now live under `provider/session_scan/claude.rs`.
 
 use crate::model::enums::AuthMode;
-use crate::provider::adapter::{
-    next_session_token, prompt_needs_native_mcp, BasicProviderAdapter,
-};
+use crate::provider::adapter::{next_session_token, prompt_needs_native_mcp, BasicProviderAdapter};
 use crate::provider::{McpConfig, ProviderAdapter, ProviderError};
 
 pub(crate) fn claude_launch_command(

package/crates/team-agent/src/provider/approvals/parsing.rs

@@ -49,7 +49,11 @@ pub fn active_approval_control_index(lines: &[&str]) -> Option<usize> {
         .rev()
         .find(|(_, line)| is_control_line(&clean_line(line)))
         .map(|(idx, _)| idx)?;
-    if lines.iter().skip(idx + 1).any(|line| !clean_line(line).is_empty()) {
+    if lines
+        .iter()
+        .skip(idx + 1)
+        .any(|line| !clean_line(line).is_empty())
+    {
         return None;
     }
     Some(idx)
@@ -61,15 +65,39 @@ pub fn extract_approval_prompt(agent_id: &str, capture: &str) -> Option<Approval
 
     if let Some((matched_idx, prompt, server, tool)) = explicit_mcp_prompt(&lines, control_idx) {
         let choices = approval_choices_between(&lines, matched_idx, control_idx);
-        return Some(approval(agent_id, ApprovalKind::McpTool, prompt, choices, Some(server), Some(tool), None));
+        return Some(approval(
+            agent_id,
+            ApprovalKind::McpTool,
+            prompt,
+            choices,
+            Some(server),
+            Some(tool),
+            None,
+        ));
     }
     if let Some((matched_idx, prompt, server, tool)) = short_mcp_prompt(&lines, control_idx) {
         let choices = approval_choices_between(&lines, matched_idx, control_idx);
-        return Some(approval(agent_id, ApprovalKind::McpTool, prompt, choices, Some(server), Some(tool), None));
+        return Some(approval(
+            agent_id,
+            ApprovalKind::McpTool,
+            prompt,
+            choices,
+            Some(server),
+            Some(tool),
+            None,
+        ));
     }
     if let Some((matched_idx, prompt, command)) = command_prompt(&lines, control_idx) {
         let choices = approval_choices_between(&lines, matched_idx, control_idx);
-        return Some(approval(agent_id, ApprovalKind::Command, prompt, choices, None, None, Some(command)));
+        return Some(approval(
+            agent_id,
+            ApprovalKind::Command,
+            prompt,
+            choices,
+            None,
+            None,
+            Some(command),
+        ));
     }
     let choices = approval_choices_between(&lines, 0, control_idx);
     Some(approval(
@@ -84,7 +112,11 @@ pub fn extract_approval_prompt(agent_id: &str, capture: &str) -> Option<Approval
 }
 
 pub fn choose_internal_mcp_approval_choice(prompt: &ApprovalPrompt) -> String {
-    if prompt.choices.iter().any(|choice| choice == "Allow for this session") {
+    if prompt
+        .choices
+        .iter()
+        .any(|choice| choice == "Allow for this session")
+    {
         return "Allow for this session".to_string();
     }
     for choice in &prompt.choices {
@@ -100,8 +132,16 @@ pub fn choose_internal_mcp_approval_choice(prompt: &ApprovalPrompt) -> String {
     "Allow for this session".to_string()
 }
 
-pub fn approval_choice_keys(prompt: &ApprovalPrompt, capture: &str, target_choice: &str) -> Vec<String> {
-    let Some(target_index) = prompt.choices.iter().position(|choice| choice == target_choice) else {
+pub fn approval_choice_keys(
+    prompt: &ApprovalPrompt,
+    capture: &str,
+    target_choice: &str,
+) -> Vec<String> {
+    let Some(target_index) = prompt
+        .choices
+        .iter()
+        .position(|choice| choice == target_choice)
+    else {
         return vec!["Down".to_string(), "Enter".to_string()];
     };
     let Some(active) = active_choice_index(capture) else {
@@ -145,7 +185,10 @@ fn is_control_line(line: &str) -> bool {
         || (lower.contains("esc to cancel") && lower.contains("tab to amend"))
 }
 
-fn explicit_mcp_prompt(lines: &[&str], control_idx: usize) -> Option<(usize, String, String, String)> {
+fn explicit_mcp_prompt(
+    lines: &[&str],
+    control_idx: usize,
+) -> Option<(usize, String, String, String)> {
     for (idx, raw) in lines.iter().enumerate().take(control_idx).rev() {
         let line = clean_line(raw);
         let prefix = "Allow the ";
@@ -171,10 +214,20 @@ fn short_mcp_prompt(lines: &[&str], control_idx: usize) -> Option<(usize, String
             continue;
         }
         if let Some(tool) = team_orchestrator_tool(&line, '-') {
-            return Some((idx, format!("team_orchestrator - {tool}"), "team_orchestrator".to_string(), tool));
+            return Some((
+                idx,
+                format!("team_orchestrator - {tool}"),
+                "team_orchestrator".to_string(),
+                tool,
+            ));
         }
         if let Some(tool) = team_orchestrator_tool(&line, '.') {
-            return Some((idx, format!("team_orchestrator - {tool}"), "team_orchestrator".to_string(), tool));
+            return Some((
+                idx,
+                format!("team_orchestrator - {tool}"),
+                "team_orchestrator".to_string(),
+                tool,
+            ));
         }
     }
     None
@@ -192,7 +245,12 @@ fn team_orchestrator_tool(line: &str, separator: char) -> Option<String> {
         .chars()
         .take_while(|ch| ch.is_ascii_alphanumeric() || *ch == '_')
         .collect();
-    if tool.is_empty() || !tool.chars().next().is_some_and(|ch| ch.is_ascii_alphabetic() || ch == '_') {
+    if tool.is_empty()
+        || !tool
+            .chars()
+            .next()
+            .is_some_and(|ch| ch.is_ascii_alphabetic() || ch == '_')
+    {
         None
     } else {
         Some(tool)
@@ -300,7 +358,10 @@ mod tests {
         assert_eq!(prompt.kind, ApprovalKind::McpTool);
         assert_eq!(prompt.server.as_deref(), Some("team_orchestrator"));
         assert_eq!(prompt.tool.as_deref(), Some("send_message"));
-        assert_eq!(prompt.prompt, "Allow the team_orchestrator MCP server to run tool \"send_message\"?");
+        assert_eq!(
+            prompt.prompt,
+            "Allow the team_orchestrator MCP server to run tool \"send_message\"?"
+        );
         assert_eq!(prompt.choices, vec!["Allow for this session", "Deny"]);
     }
 
@@ -338,7 +399,10 @@ mod tests {
         .unwrap();
         assert_eq!(prompt.kind, ApprovalKind::Command);
         assert_eq!(prompt.command.as_deref(), Some("Bash(echo hi)"));
-        assert_eq!(prompt.prompt, "Would you like to run the following command?");
+        assert_eq!(
+            prompt.prompt,
+            "Would you like to run the following command?"
+        );
     }
 
     #[test]
@@ -348,7 +412,10 @@ mod tests {
             None
         );
         assert_eq!(
-            extract_approval_prompt("agent-x", "MCP tool: team_orchestrator - send_message requires approval\n  1. Allow\n"),
+            extract_approval_prompt(
+                "agent-x",
+                "MCP tool: team_orchestrator - send_message requires approval\n  1. Allow\n"
+            ),
             None
         );
     }
@@ -381,10 +448,20 @@ mod tests {
             None,
             None,
         );
-        assert_eq!(choose_internal_mcp_approval_choice(&prompt), "Allow for this session");
+        assert_eq!(
+            choose_internal_mcp_approval_choice(&prompt),
+            "Allow for this session"
+        );
         prompt.choices = vec!["Maybe".to_string()];
-        assert_eq!(choose_internal_mcp_approval_choice(&prompt), "Allow for this session");
-        prompt.choices = vec!["Maybe".to_string(), "Yes, and don't ask again for this command".to_string(), "Allow".to_string()];
+        assert_eq!(
+            choose_internal_mcp_approval_choice(&prompt),
+            "Allow for this session"
+        );
+        prompt.choices = vec![
+            "Maybe".to_string(),
+            "Yes, and don't ask again for this command".to_string(),
+            "Allow".to_string(),
+        ];
         assert_eq!(
             choose_internal_mcp_approval_choice(&prompt),
             "Yes, and don't ask again for this command"
@@ -402,11 +479,26 @@ mod tests {
             None,
             None,
         );
-        assert_eq!(approval_choice_keys(&prompt, "❯ 1. Allow\n", "Missing"), vec!["Down", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "  1. Allow\n  2. Deny\n", "Deny"), vec!["2", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Deny"), vec!["Down", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "  1. Allow\n❯ 2. Deny\n", "Allow"), vec!["Up", "Enter"]);
-        assert_eq!(approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Allow"), vec!["Enter"]);
+        assert_eq!(
+            approval_choice_keys(&prompt, "❯ 1. Allow\n", "Missing"),
+            vec!["Down", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "  1. Allow\n  2. Deny\n", "Deny"),
+            vec!["2", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Deny"),
+            vec!["Down", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "  1. Allow\n❯ 2. Deny\n", "Allow"),
+            vec!["Up", "Enter"]
+        );
+        assert_eq!(
+            approval_choice_keys(&prompt, "❯ 1. Allow\n  2. Deny\n", "Allow"),
+            vec!["Enter"]
+        );
     }
 
     #[test]
@@ -445,8 +537,16 @@ mod tests {
             None,
         )
         .to_ordered_value();
-        let keys: Vec<&str> = mcp.as_object().unwrap().keys().map(String::as_str).collect();
-        assert_eq!(keys, vec!["agent_id", "state", "kind", "tool", "prompt", "choices"]);
+        let keys: Vec<&str> = mcp
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        assert_eq!(
+            keys,
+            vec!["agent_id", "state", "kind", "tool", "prompt", "choices"]
+        );
 
         let command = approval(
             "agent-x",
@@ -458,8 +558,16 @@ mod tests {
             Some("Bash(echo hi)".to_string()),
         )
         .to_ordered_value();
-        let keys: Vec<&str> = command.as_object().unwrap().keys().map(String::as_str).collect();
-        assert_eq!(keys, vec!["agent_id", "state", "kind", "command", "prompt", "choices"]);
+        let keys: Vec<&str> = command
+            .as_object()
+            .unwrap()
+            .keys()
+            .map(String::as_str)
+            .collect();
+        assert_eq!(
+            keys,
+            vec!["agent_id", "state", "kind", "command", "prompt", "choices"]
+        );
     }
 
     #[test]

package/crates/team-agent/src/provider/approvals/runtime_prompts.rs

@@ -13,7 +13,10 @@ pub fn runtime_mcp_tool_allowlisted(tool: &str) -> bool {
 
 pub fn runtime_mcp_prompt_allowlisted(prompt: &ApprovalPrompt) -> bool {
     prompt.server.as_deref() == Some(RUNTIME_MCP_APPROVAL_SERVER)
-        && prompt.tool.as_deref().is_some_and(runtime_mcp_tool_allowlisted)
+        && prompt
+            .tool
+            .as_deref()
+            .is_some_and(runtime_mcp_tool_allowlisted)
 }
 
 /// Issue 1 (Round 3b gate review §6): Team-Agent control-plane MCP tools
@@ -126,7 +129,11 @@ pub fn awaiting_human_confirm_reason(
     }
 }
 
-pub fn approval_prompt_fingerprint(team: &str, agent_id: &str, prompt: &ApprovalPrompt) -> ApprovalFingerprint {
+pub fn approval_prompt_fingerprint(
+    team: &str,
+    agent_id: &str,
+    prompt: &ApprovalPrompt,
+) -> ApprovalFingerprint {
     let mut hasher = Sha256::new();
     hasher.update(team.as_bytes());
     hasher.update([0]);
@@ -161,7 +168,10 @@ pub fn awaiting_human_confirm_dedupe_key(
     agent_id: &str,
     fingerprint: &ApprovalFingerprint,
 ) -> String {
-    format!("awaiting_human_confirm:{team}:{agent_id}:{}", fingerprint.as_str())
+    format!(
+        "awaiting_human_confirm:{team}:{agent_id}:{}",
+        fingerprint.as_str()
+    )
 }
 
 pub fn awaiting_human_confirm_fact(