@team-agent/installer 0.3.12 → 0.3.14

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

@@ -0,0 +1,214 @@
+//! Positive provider attribution for leader panes.
+
+use std::collections::BTreeMap;
+use std::process::Command;
+
+use crate::provider::Provider;
+use crate::transport::PaneInfo;
+
+use super::helpers::{parse_provider, provider_wire};
+
+const PROVIDER_COMMANDS: &[(&str, Provider)] = &[
+    ("claude", Provider::ClaudeCode),
+    ("claude.exe", Provider::ClaudeCode),
+    ("codex", Provider::Codex),
+    ("copilot", Provider::Copilot),
+    ("gemini", Provider::GeminiCli),
+    ("fake", Provider::Fake),
+];
+
+pub(crate) fn attribute_pane_provider(pane: &PaneInfo) -> Option<Provider> {
+    attribute_pane_provider_with_process(pane, provider_from_pid_env, provider_from_pid_argv)
+}
+
+fn attribute_pane_provider_with_process(
+    pane: &PaneInfo,
+    provider_from_env_pid: impl Fn(u32) -> Option<Provider>,
+    provider_from_argv_pid: impl Fn(u32) -> Option<Provider>,
+) -> Option<Provider> {
+    provider_from_env(&pane.leader_env)
+        .or_else(|| pane.pane_pid.and_then(provider_from_env_pid))
+        .or_else(|| {
+            pane.current_command
+                .as_deref()
+                .and_then(attribute_command_provider)
+        })
+        .or_else(|| pane.pane_pid.and_then(provider_from_argv_pid))
+}
+
+pub(crate) fn attribute_command_provider(command: &str) -> Option<Provider> {
+    provider_from_text(command)
+}
+
+pub(crate) fn command_matches_provider(provider: Provider, command: &str) -> bool {
+    attribute_command_provider(command)
+        .is_some_and(|candidate| provider_matches(candidate, provider))
+}
+
+pub(crate) fn provider_wire_from_command(command: &str) -> Option<&'static str> {
+    attribute_command_provider(command).map(provider_wire_for_command_attribution)
+}
+
+fn provider_from_env(env: &BTreeMap<String, String>) -> Option<Provider> {
+    env.get("TEAM_AGENT_LEADER_PROVIDER")
+        .filter(|raw| !raw.is_empty())
+        .and_then(|raw| parse_provider(raw))
+}
+
+fn provider_from_pid_argv(pid: u32) -> Option<Provider> {
+    process_command_line(pid)
+        .as_deref()
+        .and_then(provider_from_text)
+}
+
+fn provider_from_pid_env(pid: u32) -> Option<Provider> {
+    process_environment(pid)
+        .as_deref()
+        .and_then(provider_from_env_text)
+}
+
+fn provider_from_text(text: &str) -> Option<Provider> {
+    let lower = text.to_ascii_lowercase();
+    PROVIDER_COMMANDS
+        .iter()
+        .find_map(|(needle, provider)| lower.contains(needle).then_some(*provider))
+}
+
+fn provider_from_env_text(text: &str) -> Option<Provider> {
+    text.split(|ch: char| ch == '\0' || ch.is_ascii_whitespace())
+        .find_map(|part| part.strip_prefix("TEAM_AGENT_LEADER_PROVIDER="))
+        .filter(|raw| !raw.is_empty())
+        .and_then(parse_provider)
+}
+
+pub(crate) fn provider_matches(candidate: Provider, expected: Provider) -> bool {
+    candidate == expected
+        || matches!(
+            (candidate, expected),
+            (Provider::Claude, Provider::ClaudeCode) | (Provider::ClaudeCode, Provider::Claude)
+        )
+}
+
+fn provider_wire_for_command_attribution(provider: Provider) -> &'static str {
+    match provider {
+        Provider::Claude | Provider::ClaudeCode => "claude",
+        other => provider_wire(other),
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn process_command_line(pid: u32) -> Option<String> {
+    let bytes = std::fs::read(format!("/proc/{pid}/cmdline")).ok()?;
+    let parts = bytes
+        .split(|byte| *byte == 0)
+        .filter(|part| !part.is_empty())
+        .map(|part| String::from_utf8_lossy(part).to_string())
+        .collect::<Vec<_>>();
+    (!parts.is_empty()).then(|| parts.join(" "))
+}
+
+#[cfg(target_os = "linux")]
+fn process_environment(pid: u32) -> Option<String> {
+    String::from_utf8(std::fs::read(format!("/proc/{pid}/environ")).ok()?).ok()
+}
+
+#[cfg(not(target_os = "linux"))]
+fn process_command_line(pid: u32) -> Option<String> {
+    let output = crate::os_probe::bounded_command_output_with_probe(
+        Command::new("ps")
+            .arg("-p")
+            .arg(pid.to_string())
+            .args(["-o", "command="]),
+        "provider_argv",
+        Some(pid),
+    )
+    .ok()?;
+    output
+        .status
+        .success()
+        .then(|| String::from_utf8_lossy(&output.stdout).trim().to_string())
+        .filter(|text| !text.is_empty())
+}
+
+#[cfg(not(target_os = "linux"))]
+fn process_environment(pid: u32) -> Option<String> {
+    let _ = pid;
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::transport::{PaneId, SessionName};
+    fn pane(command: &str, pid: Option<u32>) -> PaneInfo {
+        PaneInfo {
+            pane_id: PaneId::new("%1"),
+            session: SessionName::new("team-test"),
+            window_index: None,
+            window_name: None,
+            pane_index: None,
+            tty: None,
+            current_command: Some(command.to_string()),
+            current_path: None,
+            active: true,
+            pane_pid: pid,
+            leader_env: BTreeMap::new(),
+        }
+    }
+
+    #[test]
+    fn direct_command_form_recognizes_copilot() {
+        assert_eq!(
+            attribute_pane_provider(&pane("copilot --allow-all-tools", None)),
+            Some(Provider::Copilot)
+        );
+    }
+
+    #[test]
+    fn node_running_non_provider_stays_none() {
+        assert_eq!(attribute_pane_provider(&pane("node", None)), None);
+        assert_eq!(
+            attribute_command_provider("node /tmp/not-a-provider.js"),
+            None
+        );
+    }
+
+    #[test]
+    fn pane_env_provider_wins_over_command() {
+        let mut pane = pane("codex", None);
+        pane.leader_env.insert(
+            "TEAM_AGENT_LEADER_PROVIDER".to_string(),
+            "copilot".to_string(),
+        );
+
+        assert_eq!(attribute_pane_provider(&pane), Some(Provider::Copilot));
+    }
+
+    #[test]
+    fn node_form_copilot_is_attributed_from_process_argv() {
+        let pane = pane("node", Some(4242));
+
+        assert_eq!(
+            attribute_pane_provider_with_process(
+                &pane,
+                |_| None,
+                |pid| (pid == 4242).then_some(Provider::Copilot),
+            ),
+            Some(Provider::Copilot)
+        );
+    }
+
+    #[test]
+    fn process_env_provider_wins_for_node_form() {
+        let pane = pane("node /opt/homebrew/bin/copilot", Some(4242));
+
+        assert_eq!(
+            attribute_pane_provider_with_process(
+                &pane,
+                |pid| (pid == 4242).then_some(Provider::Copilot),
+                |_| Some(Provider::Codex),
+            ),
+            Some(Provider::Copilot)
+        );
+    }
+}

package/crates/team-agent/src/leader/rediscover/tests.rs

@@ -81,13 +81,13 @@ fn event_named(events: &[Value], name: &str) -> Value {
 }
 
 #[test]
-fn leader_command_provider_recognizes_copilot() {
+fn attribute_command_provider_recognizes_copilot() {
     assert_eq!(
-        leader_command_provider("copilot --allow-all-tools"),
+        super::super::attribute_command_provider("copilot --allow-all-tools"),
         Some(Provider::Copilot)
     );
     assert_eq!(
-        leader_command_provider("/usr/local/bin/copilot"),
+        super::super::attribute_command_provider("/usr/local/bin/copilot"),
         Some(Provider::Copilot)
     );
 }

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

@@ -383,6 +383,7 @@ struct LeaderTarget {
     current_command: Option<String>,
     current_path: Option<PathBuf>,
     active: bool,
+    pane_pid: Option<u32>,
     leader_env: BTreeMap<String, String>,
     provider: Option<Provider>,
     leader_session_uuid: Option<LeaderSessionUuid>,
@@ -394,7 +395,7 @@ impl LeaderTarget {
         if !info.active {
             return None;
         }
-        let provider = leader_command_provider(info.current_command.as_deref().unwrap_or(""));
+        let provider = super::attribute_pane_provider(info);
         let leader_session_uuid = info
             .leader_env
             .get("TEAM_AGENT_LEADER_SESSION_UUID")
@@ -411,6 +412,7 @@ impl LeaderTarget {
             current_command: info.current_command.clone(),
             current_path: info.current_path.clone(),
             active: info.active,
+            pane_pid: info.pane_pid,
             leader_env: info.leader_env.clone(),
             provider,
             leader_session_uuid,
@@ -508,8 +510,26 @@ impl OwnerIdentity {
 fn target_from_value(value: &Value) -> Option<LeaderTarget> {
     let pane_id = get_str(value, "pane_id").or_else(|| get_str(value, "pane"))?;
     let current_command = get_str(value, "pane_current_command").or_else(|| get_str(value, "current_command"));
-    let provider = current_command.as_deref().and_then(leader_command_provider);
     let leader_env = map_env(value.get("leader_env").or_else(|| value.get("env")));
+    let pane_pid = get_u32(value, "pane_pid");
+    let provider = super::attribute_pane_provider(&PaneInfo {
+        pane_id: PaneId::new(pane_id.clone()),
+        session: get_str(value, "session_name")
+            .or_else(|| get_str(value, "session"))
+            .map(SessionName::new)
+            .unwrap_or_else(|| SessionName::new("")),
+        window_index: get_u32(value, "window_index"),
+        window_name: get_str(value, "window_name").map(WindowName::new),
+        pane_index: get_u32(value, "pane_index"),
+        tty: get_str(value, "pane_tty").or_else(|| get_str(value, "tty")),
+        current_command: current_command.clone(),
+        current_path: get_str(value, "pane_current_path")
+            .or_else(|| get_str(value, "current_path"))
+            .map(PathBuf::from),
+        active: value.get("active").and_then(Value::as_bool).unwrap_or(true),
+        pane_pid,
+        leader_env: leader_env.clone(),
+    });
     let leader_session_uuid = get_str(value, "leader_session_uuid")
         .or_else(|| leader_env.get("TEAM_AGENT_LEADER_SESSION_UUID").cloned())
         .and_then(|raw| serde_json::from_value(Value::String(raw)).ok());
@@ -528,6 +548,7 @@ fn target_from_value(value: &Value) -> Option<LeaderTarget> {
             .or_else(|| get_str(value, "current_path"))
             .map(PathBuf::from),
         active: value.get("active").and_then(Value::as_bool).unwrap_or(true),
+        pane_pid,
         leader_env,
         provider,
         leader_session_uuid,
@@ -584,21 +605,6 @@ fn path_in_workspace(path: &Path, workspace: &Path) -> bool {
     cwd == root || cwd.starts_with(root)
 }
 
-fn leader_command_provider(command: &str) -> Option<Provider> {
-    let lower = command.to_ascii_lowercase();
-    if lower.contains("claude") {
-        Some(Provider::ClaudeCode)
-    } else if lower.contains("codex") {
-        Some(Provider::Codex)
-    } else if lower.contains("copilot") {
-        Some(Provider::Copilot)
-    } else if lower.contains("fake") {
-        Some(Provider::Fake)
-    } else {
-        None
-    }
-}
-
 fn target_matches_owner_identity(target: &LeaderTarget, identity: &OwnerIdentity) -> bool {
     identity
         .pane_id
@@ -624,6 +630,7 @@ fn pane_info_value(
         "pane_index": info.pane_index,
         "pane_tty": info.tty,
         "pane_current_command": info.current_command,
+        "pane_pid": info.pane_pid,
         "pane_current_path": info.current_path.as_ref().map(|path| path.to_string_lossy().to_string()),
         "fingerprint": info.leader_env.get("TEAM_AGENT_MACHINE_FINGERPRINT"),
         "provider": provider.map(provider_wire),
@@ -1100,5 +1107,15 @@ fn get_str(value: &Value, key: &str) -> Option<String> {
         .filter(|s| !s.is_empty())
 }
 
+fn get_u32(value: &Value, key: &str) -> Option<u32> {
+    value
+        .get(key)
+        .and_then(|raw| {
+            raw.as_u64()
+                .or_else(|| raw.as_i64().and_then(|n| u64::try_from(n).ok()))
+        })
+        .and_then(|n| u32::try_from(n).ok())
+}
+
 #[cfg(test)]
 mod tests;

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

@@ -2,12 +2,12 @@
 
 use std::collections::BTreeMap;
 use std::io::IsTerminal;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
 use crate::provider::{get_adapter, Provider};
 use crate::tmux_backend::TmuxBackend;
-use crate::transport::{SessionName, Transport};
+use crate::transport::{PaneId, SessionName, Target, Transport};
 
 use super::helpers::{
     provider_wire, resolve_workspace_for_hash, sanitize_session_folder, sha1_hex_prefix,
@@ -125,7 +125,10 @@ pub(crate) fn leader_env_for_identity(
         identity.team_id.as_str().to_string(),
     );
     if provider == Provider::Copilot {
-        leader_env.insert("COPILOT_DISABLE_TERMINAL_TITLE".to_string(), "1".to_string());
+        leader_env.insert(
+            "COPILOT_DISABLE_TERMINAL_TITLE".to_string(),
+            "1".to_string(),
+        );
     }
     leader_env
 }
@@ -171,7 +174,7 @@ pub fn execute_leader_plan(
     let detached = plan.mode == LeaderStartMode::NewTmuxSession
         && !std::io::stdin().is_terminal()
         && insert_detach_flag(&mut argv);
-    let status = run_leader_argv(&argv, &plan.leader_env)?;
+    let status = run_leader_argv(&argv, &plan.leader_env, plan, workspace)?;
     let code = status.code();
     if !status.success() {
         return Err(LeaderError::Start(format!(
@@ -294,6 +297,8 @@ fn insert_detach_flag(argv: &mut Vec<String>) -> bool {
 fn run_leader_argv(
     argv: &[String],
     env: &BTreeMap<String, String>,
+    plan: &LeaderStartPlan,
+    workspace: &Path,
 ) -> Result<std::process::ExitStatus, LeaderError> {
     let Some(program) = argv.first() else {
         return Err(LeaderError::Start(
@@ -307,9 +312,84 @@ fn run_leader_argv(
         .stdout(Stdio::inherit())
         .stderr(Stdio::inherit())
         .spawn()?;
+    if plan.mode == LeaderStartMode::ExecProvider {
+        spawn_exec_provider_startup_prompt_handler(plan.provider, workspace.to_path_buf());
+    }
     child.wait().map_err(LeaderError::Io)
 }
 
+fn spawn_exec_provider_startup_prompt_handler(provider: Provider, workspace: PathBuf) {
+    let Some(pane_id) = std::env::var("TMUX_PANE")
+        .ok()
+        .filter(|value| !value.trim().is_empty())
+    else {
+        write_leader_startup_prompt_event(
+            &workspace,
+            "leader.startup_prompt_skipped",
+            serde_json::json!({
+                "provider": provider_wire(provider),
+                "reason": "tmux_pane_missing",
+                "action": "skip",
+            }),
+        );
+        return;
+    };
+    std::thread::spawn(move || {
+        let transport = tmux_transport_for_current_pane();
+        let _ = handle_exec_provider_startup_prompts(
+            provider, &workspace, &pane_id, &transport, 30, 0.5,
+        );
+    });
+}
+
+fn tmux_transport_for_current_pane() -> TmuxBackend {
+    crate::tmux_backend::socket_name_from_tmux_env()
+        .map(|endpoint| TmuxBackend::for_tmux_endpoint(&endpoint))
+        .unwrap_or_else(TmuxBackend::new)
+}
+
+pub fn handle_exec_provider_startup_prompts(
+    provider: Provider,
+    workspace: &Path,
+    pane_id: &str,
+    transport: &dyn Transport,
+    checks: usize,
+    sleep_s: f64,
+) -> crate::provider::StartupPromptOutcome {
+    let target = Target::Pane(PaneId::new(pane_id.to_string()));
+    let outcome =
+        get_adapter(provider).handle_startup_prompts_outcome(transport, &target, checks, sleep_s);
+    for handled in &outcome.handled {
+        write_leader_startup_prompt_event(
+            workspace,
+            "leader.startup_prompt_handled",
+            serde_json::json!({
+                "provider": provider_wire(provider),
+                "pane_id": pane_id,
+                "prompt": handled.prompt,
+                "action": handled.action,
+            }),
+        );
+    }
+    if let Some(error) = &outcome.capture_error {
+        write_leader_startup_prompt_event(
+            workspace,
+            "leader.startup_prompt_capture_failed",
+            serde_json::json!({
+                "provider": provider_wire(provider),
+                "pane_id": pane_id,
+                "action": "capture",
+                "error": error,
+            }),
+        );
+    }
+    outcome
+}
+
+fn write_leader_startup_prompt_event(workspace: &Path, event: &str, fields: serde_json::Value) {
+    let _ = crate::event_log::EventLog::new(workspace).write(event, fields);
+}
+
 fn ensure_tmux_installed() -> Result<(), LeaderError> {
     match Command::new("tmux").arg("-V").output() {
         Ok(output) if output.status.success() => Ok(()),
@@ -388,3 +468,198 @@ fn shlex_quote(raw: &str) -> String {
         format!("'{}'", raw.replace('\'', "'\"'\"'"))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+    use std::path::Path;
+    use std::sync::Mutex;
+
+    use crate::model::enums::PaneLiveness;
+    use crate::provider::{Provider, COPILOT_READY_MARKER, COPILOT_TRUST_PROMPT_MARKER};
+    use crate::transport::{
+        AttachOutcome, BackendKind, CaptureRange, CapturedText, InjectPayload, InjectReport,
+        InjectStage, InjectVerification, Key, PaneField, PaneId, PaneInfo, SessionName,
+        SetEnvOutcome, SpawnResult, SubmitVerification, Target, Transport, TransportError,
+        TurnVerification, WindowName,
+    };
+
+    use super::handle_exec_provider_startup_prompts;
+
+    struct ScriptedTransport {
+        screens: Mutex<Vec<String>>,
+        sent: Mutex<Vec<(Target, Vec<Key>)>>,
+    }
+
+    impl ScriptedTransport {
+        fn new(screens: Vec<String>) -> Self {
+            Self {
+                screens: Mutex::new(screens),
+                sent: Mutex::new(Vec::new()),
+            }
+        }
+
+        fn sent(&self) -> Vec<(Target, Vec<Key>)> {
+            match self.sent.lock() {
+                Ok(guard) => guard.clone(),
+                Err(poisoned) => poisoned.into_inner().clone(),
+            }
+        }
+    }
+
+    impl Transport for ScriptedTransport {
+        fn kind(&self) -> BackendKind {
+            BackendKind::Tmux
+        }
+
+        fn spawn_first(
+            &self,
+            _session: &SessionName,
+            _window: &WindowName,
+            _argv: &[String],
+            _cwd: &Path,
+            _env: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
+            Err(TransportError::Io(std::io::Error::other(
+                "spawn_first not used by startup-prompt test",
+            )))
+        }
+
+        fn spawn_into(
+            &self,
+            _session: &SessionName,
+            _window: &WindowName,
+            _argv: &[String],
+            _cwd: &Path,
+            _env: &BTreeMap<String, String>,
+        ) -> Result<SpawnResult, TransportError> {
+            Err(TransportError::Io(std::io::Error::other(
+                "spawn_into not used by startup-prompt test",
+            )))
+        }
+
+        fn inject(
+            &self,
+            _target: &Target,
+            _payload: &InjectPayload,
+            _submit: Key,
+            _bracketed: bool,
+        ) -> Result<InjectReport, TransportError> {
+            Ok(InjectReport {
+                stage_reached: InjectStage::Submit,
+                inject_verification: InjectVerification::CaptureContainsToken,
+                submit_verification: SubmitVerification::EnterSentWithoutPlaceholderCheck,
+                turn_verification: TurnVerification::NotRequired,
+                attempts: 1,
+            })
+        }
+
+        fn send_keys(&self, target: &Target, keys: &[Key]) -> Result<(), TransportError> {
+            match self.sent.lock() {
+                Ok(mut guard) => guard.push((target.clone(), keys.to_vec())),
+                Err(poisoned) => poisoned.into_inner().push((target.clone(), keys.to_vec())),
+            }
+            Ok(())
+        }
+
+        fn capture(
+            &self,
+            _target: &Target,
+            range: CaptureRange,
+        ) -> Result<CapturedText, TransportError> {
+            let text = match self.screens.lock() {
+                Ok(mut guard) => {
+                    if guard.is_empty() {
+                        String::new()
+                    } else {
+                        guard.remove(0)
+                    }
+                }
+                Err(poisoned) => {
+                    let mut guard = poisoned.into_inner();
+                    if guard.is_empty() {
+                        String::new()
+                    } else {
+                        guard.remove(0)
+                    }
+                }
+            };
+            Ok(CapturedText { text, range })
+        }
+
+        fn query(
+            &self,
+            _target: &Target,
+            _field: PaneField,
+        ) -> Result<Option<String>, TransportError> {
+            Ok(None)
+        }
+
+        fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
+            Ok(PaneLiveness::Unknown)
+        }
+
+        fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
+            Ok(Vec::new())
+        }
+
+        fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
+            Ok(false)
+        }
+
+        fn list_windows(&self, _session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
+            Ok(Vec::new())
+        }
+
+        fn set_session_env(
+            &self,
+            _session: &SessionName,
+            _key: &str,
+            _value: &str,
+        ) -> Result<SetEnvOutcome, TransportError> {
+            Ok(SetEnvOutcome::Applied)
+        }
+
+        fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
+            Ok(())
+        }
+
+        fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
+            Ok(())
+        }
+
+        fn attach_session(&self, _session: &SessionName) -> Result<AttachOutcome, TransportError> {
+            Ok(AttachOutcome::Unsupported {
+                reason: "not used by startup-prompt test".to_string(),
+            })
+        }
+    }
+
+    #[test]
+    fn exec_provider_leader_startup_prompt_handler_reuses_copilot_adapter() {
+        let transport = ScriptedTransport::new(vec![
+            COPILOT_TRUST_PROMPT_MARKER.to_string(),
+            COPILOT_READY_MARKER.to_string(),
+        ]);
+        let workspace =
+            std::env::temp_dir().join(format!("ta_rs_red2_leader_startup_{}", std::process::id()));
+        let _ = std::fs::create_dir_all(&workspace);
+
+        let outcome = handle_exec_provider_startup_prompts(
+            Provider::Copilot,
+            &workspace,
+            "%0",
+            &transport,
+            5,
+            0.0,
+        );
+
+        assert_eq!(outcome.handled.len(), 1);
+        assert_eq!(outcome.handled[0].prompt, "copilot_workspace_trust");
+        assert_eq!(outcome.handled[0].action, "sent_enter_yes_session");
+        let sent = transport.sent();
+        assert_eq!(sent.len(), 1);
+        assert_eq!(sent[0].0, Target::Pane(PaneId::new("%0")));
+        assert_eq!(sent[0].1, vec![Key::Enter]);
+    }
+}