@team-agent/installer 0.5.52 → 0.5.54

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

@@ -1,7 +1,7 @@
 //! leader::start — leader_start_plan / start_leader / leader_session_name(派生 tmux session 名)。
 
 use std::collections::BTreeMap;
-use std::io::IsTerminal;
+use std::io::{IsTerminal, Read, Write};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
@@ -243,14 +243,10 @@ pub fn execute_leader_plan(
     } else if plan.is_external_leader {
         persist_external_leader_topology_marker(plan, workspace)?;
     }
-    let status = run_leader_argv(&argv, &plan.leader_env, plan, workspace)?;
-    let code = status.code();
-    if !status.success() {
-        return Err(LeaderError::Start(format!(
-            "leader launcher exited with status {}",
-            code.map(|c| c.to_string())
-                .unwrap_or_else(|| "signal".to_string())
-        )));
+    let process = run_leader_argv(&argv, &plan.leader_env, plan, workspace)?;
+    let code = process.status.code();
+    if !process.status.success() {
+        return Err(LeaderError::Start(leader_launcher_failure(&process)));
     }
     if detached {
         Ok(LeaderLaunchOutcome {
@@ -471,14 +467,10 @@ fn execute_managed_leader_plan(
         workspace.to_path_buf(),
         spawned.pane_id.as_str().to_string(),
     );
-    let status = run_leader_argv(&plan.argv, &BTreeMap::new(), plan, workspace)?;
-    let code = status.code();
-    if !status.success() {
-        return Err(LeaderError::Start(format!(
-            "leader launcher exited with status {}",
-            code.map(|c| c.to_string())
-                .unwrap_or_else(|| "signal".to_string())
-        )));
+    let process = run_leader_argv(&plan.argv, &BTreeMap::new(), plan, workspace)?;
+    let code = process.status.code();
+    if !process.status.success() {
+        return Err(LeaderError::Start(leader_launcher_failure(&process)));
     }
     ensure_managed_provider_live_after_attach(&transport, &spawned)?;
     Ok(LeaderLaunchOutcome {
@@ -1213,7 +1205,7 @@ fn run_leader_argv(
     env: &BTreeMap<String, String>,
     plan: &LeaderStartPlan,
     workspace: &Path,
-) -> Result<std::process::ExitStatus, LeaderError> {
+) -> Result<LeaderProcessExit, LeaderError> {
     let Some(program) = argv.first() else {
         return Err(LeaderError::Start(
             "leader launch argv is empty".to_string(),
@@ -1234,8 +1226,13 @@ fn run_leader_argv(
     command
         .args(argv.iter().skip(1))
         .stdin(Stdio::inherit())
-        .stdout(Stdio::inherit())
-        .stderr(Stdio::inherit());
+        .stdout(Stdio::inherit());
+    let capture_stderr = plan.mode != LeaderStartMode::ExecProvider;
+    command.stderr(if capture_stderr {
+        Stdio::piped()
+    } else {
+        Stdio::inherit()
+    });
     // 0.4.x order fix: env_remove MUST run AFTER envs(). The `env` map comes
     // from `merged_exec_env` which seeds with `std::env::vars().collect()` —
     // calling `.envs(env)` re-adds every inherited CLAUDE_CODE_* the launching
@@ -1248,10 +1245,109 @@ fn run_leader_argv(
         command.env_remove(key);
     }
     let mut child = command.spawn()?;
+    let stderr_reader = child.stderr.take().map(|mut child_stderr| {
+        std::thread::spawn(move || {
+            let mut captured = Vec::new();
+            let mut buf = [0_u8; 4096];
+            loop {
+                let Ok(read) = child_stderr.read(&mut buf) else {
+                    break;
+                };
+                if read == 0 {
+                    break;
+                }
+                let _ = std::io::stderr().write_all(&buf[..read]);
+                push_bounded_stderr(&mut captured, &buf[..read]);
+            }
+            captured
+        })
+    });
     if plan.mode == LeaderStartMode::ExecProvider {
         spawn_exec_provider_startup_prompt_handler(plan.provider, workspace.to_path_buf());
     }
-    child.wait().map_err(LeaderError::Io)
+    let status = child.wait().map_err(LeaderError::Io)?;
+    let stderr = match stderr_reader {
+        Some(reader) => match reader.join() {
+            Ok(bytes) => String::from_utf8_lossy(&bytes).into_owned(),
+            Err(_) => String::new(),
+        },
+        None => String::new(),
+    };
+    Ok(LeaderProcessExit { status, stderr })
+}
+
+const LEADER_STDERR_LIMIT: usize = 8192;
+
+struct LeaderProcessExit {
+    status: std::process::ExitStatus,
+    stderr: String,
+}
+
+fn push_bounded_stderr(captured: &mut Vec<u8>, chunk: &[u8]) {
+    if chunk.len() >= LEADER_STDERR_LIMIT {
+        captured.clear();
+        captured.extend_from_slice(&chunk[chunk.len() - LEADER_STDERR_LIMIT..]);
+        return;
+    }
+    let excess = captured
+        .len()
+        .saturating_add(chunk.len())
+        .saturating_sub(LEADER_STDERR_LIMIT);
+    if excess > 0 {
+        captured.drain(..excess);
+    }
+    captured.extend_from_slice(chunk);
+}
+
+fn leader_launcher_failure(process: &LeaderProcessExit) -> String {
+    let status = process
+        .status
+        .code()
+        .map(|code| code.to_string())
+        .unwrap_or_else(|| "signal".to_string());
+    format_launcher_failure(&status, process.status.code().is_none(), &process.stderr)
+}
+
+fn format_launcher_failure(status: &str, signaled: bool, raw_stderr: &str) -> String {
+    let stderr_class = classify_launcher_stderr(raw_stderr, signaled);
+    let stderr = bounded_stderr_text(crate::redaction::redact_external_text(raw_stderr.trim()));
+    let stderr = if stderr.is_empty() {
+        "<empty>".to_string()
+    } else {
+        stderr
+    };
+    format!(
+        "leader launcher exited with status {status}; stderr_class={stderr_class}; stderr_excerpt={stderr}"
+    )
+}
+
+fn bounded_stderr_text(stderr: String) -> String {
+    if stderr.len() <= LEADER_STDERR_LIMIT {
+        return stderr;
+    }
+    let mut start = stderr.len() - LEADER_STDERR_LIMIT;
+    while !stderr.is_char_boundary(start) {
+        start += 1;
+    }
+    stderr[start..].to_string()
+}
+
+fn classify_launcher_stderr(stderr: &str, signaled: bool) -> &'static str {
+    let stderr = stderr.to_ascii_lowercase();
+    if stderr.contains("server exited") {
+        "server_exited"
+    } else if stderr.contains("no server running") || stderr.contains("failed to connect to server")
+    {
+        "no_server"
+    } else if stderr.contains("not a terminal") {
+        "not_a_terminal"
+    } else if stderr.contains("can't find session") || stderr.contains("no sessions") {
+        "target_missing"
+    } else if signaled {
+        "signal"
+    } else {
+        "non_zero"
+    }
 }
 
 fn spawn_exec_provider_startup_prompt_handler(provider: Provider, workspace: PathBuf) {
@@ -1447,8 +1543,9 @@ mod tests {
     };
 
     use super::{
-        ensure_managed_provider_live_after_attach, execute_leader_plan,
-        handle_exec_provider_startup_prompts, shlex_quote,
+        ensure_managed_provider_live_after_attach, execute_leader_plan, format_launcher_failure,
+        handle_exec_provider_startup_prompts, push_bounded_stderr, shlex_quote,
+        LEADER_STDERR_LIMIT,
     };
 
     struct ScriptedTransport {
@@ -1981,4 +2078,28 @@ mod tests {
              external/attach paths; body excerpt: {body}"
         );
     }
+
+    #[test]
+    fn launcher_failure_redacts_credentials_before_persistence() {
+        let failure = format_launcher_failure(
+            "1",
+            false,
+            "open terminal failed: not a terminal API_TOKEN=secret-value \
+             Authorization: Bearer abcdefghijklmnopqrstuvwxyz",
+        );
+
+        assert!(failure.contains("stderr_class=not_a_terminal"));
+        assert!(failure.contains("[REDACTED]"));
+        assert!(!failure.contains("secret-value"));
+        assert!(!failure.contains("abcdefghijklmnopqrstuvwxyz"));
+    }
+
+    #[test]
+    fn launcher_stderr_capture_is_bounded_to_tail() {
+        let mut captured = vec![b'a'; LEADER_STDERR_LIMIT - 2];
+        push_bounded_stderr(&mut captured, b"XYZ");
+
+        assert_eq!(captured.len(), LEADER_STDERR_LIMIT);
+        assert!(captured.ends_with(b"XYZ"));
+    }
 }

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

@@ -226,6 +226,9 @@ fn leader_receiver_struct_serializes_with_python_field_names() {
         pane_tty: Some("/dev/ttys001".into()),
         pane_current_command: Some("claude".into()),
         tmux_socket: None,
+        scope_authority: None,
+        authorized_team_workspace: None,
+        binding_nonce: None,
         fingerprint: Some("fp".into()),
         leader_session_uuid: Some(uuid("fp", "/ws", "u", "default")),
         owner_epoch: Some(OwnerEpoch(3)),

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

@@ -263,6 +263,12 @@ pub struct LeaderReceiver {
     pub pane_current_command: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tmux_socket: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub scope_authority: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub authorized_team_workspace: Option<PathBuf>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub binding_nonce: Option<String>,
     /// `_target_fingerprint(pane_info)`。
     #[serde(skip_serializing_if = "Option::is_none")]
     pub fingerprint: Option<String>,

package/crates/team-agent/src/lib.rs

@@ -42,6 +42,7 @@ pub mod db;
 
 // step 4 (event_log) — events.jsonl 唯一审计流(append/tail/rotation + 稳定事件名)。
 pub mod event_log;
+pub(crate) mod kill_audit;
 
 // step 5 (state) — state.json 持久化/identity/owner-gate/projection(bug-084 韧性)。
 pub mod state;

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

@@ -376,7 +376,7 @@ pub(super) fn add_agent_with_transport_at_paths(
     }
     let started = match crate::lifecycle::restart::start_agent_at_paths(
         run_workspace,
-        team_dir,
+        spec_path.parent().unwrap_or(team_dir),
         agent_id,
         false,
         open_display,

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

@@ -28,6 +28,11 @@ pub(super) fn rollback_add_agent_atomic(
     agent_id: &AgentId,
     reason: &str,
 ) {
+    let _ = std::fs::remove_dir_all(
+        run_workspace
+            .join(".team/runtime/copilot-instructions")
+            .join(agent_id.as_str()),
+    );
     let spec_restored = if let Some(text) = pre_spec_text {
         std::fs::write(spec_path, text).is_ok()
     } else {

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

@@ -93,6 +93,10 @@ pub(super) fn running_agent_state(
         "attribution_confidence".to_string(),
         serde_json::Value::Null,
     );
+    state.insert(
+        "capture_state".to_string(),
+        serde_json::json!("pending_first_turn"),
+    );
     if let Some(started_agent) = started_agent {
         persist_started_agent_plan_state(&mut state, started_agent);
         if let Some(layout_window) = started_agent.layout_window.as_ref() {

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

@@ -0,0 +1,106 @@
+use crate::lifecycle::*;
+use crate::model::ids::AgentId;
+use crate::provider::SessionId;
+use std::path::Path;
+
+use super::*;
+
+pub fn clone_agent(
+    workspace: &Path,
+    source_agent_id: &AgentId,
+    as_agent_id: &AgentId,
+    label: Option<&str>,
+    open_display: bool,
+    team: Option<&str>,
+) -> Result<CloneAgentReport, LifecycleError> {
+    let selected = crate::state::selector::resolve_active_team(
+        workspace,
+        team,
+        crate::state::selector::SelectorMode::RequireSpec,
+    )
+    .map_err(|error| LifecycleError::TeamSelect(error.to_string()))?;
+    ensure_owner_allowed_for_state(&selected.state, Some(source_agent_id))?;
+    let source_agent = selected
+        .state
+        .get("agents")
+        .and_then(|agents| agents.get(source_agent_id.as_str()))
+        .ok_or_else(|| {
+            LifecycleError::RequirementUnmet(format!("unknown worker agent id: {source_agent_id}"))
+        })?;
+    let source_session_id = source_agent
+        .get("session_id")
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(SessionId::new);
+    let mut materialized = materialize_latest_role(
+        &selected.run_workspace,
+        &selected.team_dir,
+        &selected.state,
+        source_agent_id,
+        as_agent_id,
+        label,
+    )?;
+    let spec_path = selected
+        .spec_path
+        .as_ref()
+        .ok_or_else(|| LifecycleError::TeamSelect("active team spec not found".to_string()))?;
+    let spec = crate::model::yaml::loads(
+        &std::fs::read_to_string(spec_path)
+            .map_err(|error| LifecycleError::Compile(error.to_string()))?,
+    )
+    .map_err(|error| LifecycleError::Compile(error.to_string()))?;
+    clamp_materialized_role_to_leader(materialized.path(), &spec)?;
+    let added = add_agent(
+        &selected.run_workspace,
+        as_agent_id,
+        materialized.path(),
+        open_display,
+        Some(selected.team_key.as_str()),
+    )?;
+    let verified = read_agent_session(
+        &selected.run_workspace,
+        selected.team_key.as_str(),
+        as_agent_id,
+        source_session_id.as_ref(),
+    );
+    let (session_id, backing_path, backing_state) = match verified {
+        Some((session_id, backing_path)) => (
+            Some(session_id),
+            Some(backing_path),
+            CloneBackingState::Verified,
+        ),
+        None => (None, None, CloneBackingState::PendingFirstTurn),
+    };
+    materialized.keep();
+    Ok(CloneAgentReport {
+        source_agent_id: source_agent_id.clone(),
+        new_agent_id: as_agent_id.clone(),
+        env: added.env,
+        session_id,
+        backing_path,
+        backing_state,
+    })
+}
+
+fn read_agent_session(
+    workspace: &Path,
+    team_key: &str,
+    agent_id: &AgentId,
+    source_session_id: Option<&SessionId>,
+) -> Option<(SessionId, std::path::PathBuf)> {
+    let state = crate::state::projection::select_runtime_state(workspace, Some(team_key)).ok()?;
+    let agent = state
+        .get("agents")
+        .and_then(|agents| agents.get(agent_id.as_str()))?;
+    let session = agent
+        .get("session_id")
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())?;
+    let backing = agent
+        .get("rollout_path")
+        .and_then(serde_json::Value::as_str)
+        .filter(|value| !value.is_empty())
+        .map(std::path::PathBuf::from)?;
+    let distinct = source_session_id.is_none_or(|source| source.as_str() != session);
+    (distinct && backing.is_file()).then(|| (SessionId::new(session), backing))
+}