@team-agent/installer 0.3.13 → 0.3.15

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

@@ -107,7 +107,10 @@ fn parse_rendered_header(line: &str) -> Option<RenderedBlock> {
         .split_once(" for ")
         .map(|(_, task)| task.trim().to_string())
         .filter(|task| !task.is_empty());
-    Some(RenderedBlock { task_id, lines: Vec::new() })
+    Some(RenderedBlock {
+        task_id,
+        lines: Vec::new(),
+    })
 }
 
 fn parse_token(line: &str) -> Option<String> {
@@ -135,149 +138,13 @@ fn report_fake_result(
         .ok()
         .map(|value| value.trim().to_string())
         .filter(|value| !value.is_empty());
-    mirror_fake_result_to_leader(workspace, owner_team.as_deref(), &envelope, source_content);
+    let _ = source_content;
     crate::messaging::report_result_for_owner_team(workspace, &envelope, owner_team.as_deref())
         .map_err(|e| FakeWorkerError::Report(e.to_string()))?;
-    mirror_fake_result_to_leader(workspace, owner_team.as_deref(), &envelope, source_content);
     writeln!(output, "{}", serde_json::to_string(&envelope)?)?;
     Ok(())
 }
 
-fn mirror_fake_result_to_leader(
-    workspace: &Path,
-    owner_team: Option<&str>,
-    envelope: &serde_json::Value,
-    source_content: Option<&str>,
-) {
-    let Ok(raw_state) = crate::state::persist::load_runtime_state(workspace) else {
-        return;
-    };
-    let state = owner_team
-        .and_then(|team| crate::state::projection::resolve_owner_team_id(&raw_state, team).canonical_key().map(str::to_string))
-        .map(|team| crate::state::projection::project_top_level_view(&raw_state, &team))
-        .unwrap_or(raw_state);
-    let attached = state
-        .get("leader_receiver")
-        .and_then(|receiver| receiver.get("status"))
-        .and_then(serde_json::Value::as_str)
-        == Some("attached");
-    let pane_id = state
-        .get("leader_receiver")
-        .and_then(|receiver| receiver.get("pane_id"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|pane| !pane.is_empty())
-        .map(str::to_string)
-        .or_else(|| owner_team.and_then(|team| claimed_pane_from_events(workspace, team)));
-    let Some(pane_id) = pane_id.filter(|_| attached || owner_team.is_some()) else {
-        return;
-    };
-    let summary = envelope
-        .get("summary")
-        .and_then(serde_json::Value::as_str)
-        .unwrap_or("Fake worker completed");
-    let result_id = envelope
-        .get("result_id")
-        .and_then(serde_json::Value::as_str)
-        .unwrap_or("");
-    let text = match source_content.filter(|content| !content.trim().is_empty()) {
-        Some(content) => format!(
-            "Fake worker result: {summary}\nMessage content: {}\nResult id: {result_id}",
-            content.trim()
-        ),
-        None => format!("Fake worker result: {summary}\nResult id: {result_id}"),
-    };
-    let target = crate::transport::Target::Pane(crate::transport::PaneId::new(&pane_id));
-    let payload = crate::transport::InjectPayload::Text(text.clone());
-    let key = crate::transport::Key::Enter;
-    if let Some(socket) = leader_receiver_full_socket(&state) {
-        let endpoint_backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
-        if crate::transport::Transport::inject(&endpoint_backend, &target, &payload, key, true).is_ok() {
-            mirror_to_team_session_panes(&state, workspace, agent_id_from_envelope(envelope), &text);
-            return;
-        }
-    }
-    let workspace_backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
-    let _ = crate::transport::Transport::inject(&workspace_backend, &target, &payload, key, true);
-    mirror_to_team_session_panes(&state, workspace, agent_id_from_envelope(envelope), &text);
-}
-
-fn leader_receiver_full_socket(state: &serde_json::Value) -> Option<&str> {
-    state
-        .get("leader_receiver")
-        .and_then(|receiver| receiver.get("tmux_socket"))
-        .and_then(serde_json::Value::as_str)
-        .filter(|socket| !socket.is_empty() && Path::new(socket).is_absolute())
-}
-
-fn claimed_pane_from_events(workspace: &Path, owner_team: &str) -> Option<String> {
-    crate::event_log::EventLog::new(workspace)
-        .tail(50)
-        .ok()?
-        .into_iter()
-        .rev()
-        .find_map(|event| {
-            if event.get("event").and_then(serde_json::Value::as_str)
-                != Some("leader_receiver.rebind_applied")
-            {
-                return None;
-            }
-            if event.get("team_id").and_then(serde_json::Value::as_str) != Some(owner_team) {
-                return None;
-            }
-            event
-                .get("new_pane_id")
-                .and_then(serde_json::Value::as_str)
-                .filter(|pane| !pane.is_empty())
-                .map(str::to_string)
-        })
-}
-
-fn agent_id_from_envelope(envelope: &serde_json::Value) -> Option<&str> {
-    envelope.get("agent_id").and_then(serde_json::Value::as_str)
-}
-
-fn mirror_to_team_session_panes(
-    state: &serde_json::Value,
-    workspace: &Path,
-    agent_id: Option<&str>,
-    text: &str,
-) {
-    let Some(session) = state
-        .get("session_name")
-        .and_then(serde_json::Value::as_str)
-        .filter(|session| !session.is_empty())
-    else {
-        return;
-    };
-    let worker_pane = agent_id.and_then(|agent_id| {
-        state
-            .get("agents")
-            .and_then(|agents| agents.get(agent_id))
-            .and_then(|agent| agent.get("pane_id"))
-            .and_then(serde_json::Value::as_str)
-    });
-    if let Some(socket) = leader_receiver_full_socket(state) {
-        let backend = crate::tmux_backend::TmuxBackend::for_tmux_endpoint(socket);
-        for pane in crate::transport::Transport::list_targets(&backend).unwrap_or_default() {
-            if pane.session.as_str() != session || Some(pane.pane_id.as_str()) == worker_pane {
-                continue;
-            }
-            let target = crate::transport::Target::Pane(pane.pane_id);
-            let payload = crate::transport::InjectPayload::Text(text.to_string());
-            let _ = crate::transport::Transport::inject(&backend, &target, &payload, crate::transport::Key::Enter, true);
-        }
-    }
-    let backend = crate::tmux_backend::TmuxBackend::for_workspace(workspace);
-    for pane in crate::transport::Transport::list_targets(&backend).unwrap_or_default() {
-        if pane.session.as_str() != session || Some(pane.pane_id.as_str()) == worker_pane {
-            continue;
-        }
-        let target = crate::transport::Target::Pane(pane.pane_id);
-        let payload = crate::transport::InjectPayload::Text(text.to_string());
-        let _ = crate::transport::Transport::inject(&backend, &target, &payload, crate::transport::Key::Enter, true);
-    }
-}
-
 fn fake_envelope(
     workspace: &Path,
     agent_id: &str,
@@ -331,7 +198,9 @@ mod tests {
     fn stored_result(ws: &std::path::Path) -> (String, String, String, serde_json::Value) {
         let store = MessageStore::open(ws).unwrap();
         let conn = open_db(store.db_path()).unwrap();
-        let mut stmt = conn.prepare("select task_id, agent_id, status, envelope from results").unwrap();
+        let mut stmt = conn
+            .prepare("select task_id, agent_id, status, envelope from results")
+            .unwrap();
         let row = stmt
             .query_row([], |r| {
                 Ok((
@@ -354,9 +223,18 @@ mod tests {
             ("t1", "w1", "success"),
             "stored result row must be task_id=t1 agent_id=w1 status=success"
         );
-        assert_eq!(env["schema_version"], serde_json::json!("result_envelope_v1"));
-        assert_eq!(env["summary"], serde_json::json!("Fake worker handled message m1"));
-        assert_eq!(env["tests"], serde_json::json!([{"command": "fake-provider", "status": "passed"}]));
+        assert_eq!(
+            env["schema_version"],
+            serde_json::json!("result_envelope_v1")
+        );
+        assert_eq!(
+            env["summary"],
+            serde_json::json!("Fake worker handled message m1")
+        );
+        assert_eq!(
+            env["tests"],
+            serde_json::json!([{"command": "fake-provider", "status": "passed"}])
+        );
         let artifact_path = env["artifacts"][0]["path"].as_str().unwrap_or_default();
         assert!(
             artifact_path.ends_with(".team/logs/w1.scrollback"),
@@ -375,8 +253,14 @@ mod tests {
 
         assert_golden_envelope(&ws);
         let printed = String::from_utf8(out).unwrap();
-        assert!(printed.contains("TEAM_AGENT_FAKE_READY agent=w1"), "must print the READY idle marker; got {printed}");
-        assert!(printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"), "must print the WORKING marker on a non-empty line; got {printed}");
+        assert!(
+            printed.contains("TEAM_AGENT_FAKE_READY agent=w1"),
+            "must print the READY idle marker; got {printed}"
+        );
+        assert!(
+            printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"),
+            "must print the WORKING marker on a non-empty line; got {printed}"
+        );
     }
 
     // Rendered-message form: a `Team Agent message from leader for t1:` block ending `[team-agent-token:m1]`
@@ -391,6 +275,9 @@ mod tests {
 
         assert_golden_envelope(&ws);
         let printed = String::from_utf8(out).unwrap();
-        assert!(printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"), "rendered form prints WORKING per line; got {printed}");
+        assert!(
+            printed.contains("TEAM_AGENT_FAKE_WORKING agent=w1"),
+            "rendered form prints WORKING per line; got {printed}"
+        );
     }
 }

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]);
+    }
+}

package/crates/team-agent/src/lifecycle/display.rs

@@ -11,15 +11,15 @@ use super::*;
 // ── lifecycle::display —— 能力门 / 后端解析 / 开关 / rebind 后重建 ────────────
 
 /// `resolve_display_backend(requested, recorded, source)`(`display/backend.py`)。默认
-/// none;非默认非静默发 `display.backend_resolved`。
+/// adaptive;显式 none 是逃生口。
 pub fn resolve_display_backend(
     requested: Option<DisplayBackend>,
     recorded: Option<DisplayBackend>,
 ) -> ResolvedBackend {
-    let backend = requested.or(recorded).unwrap_or(DisplayBackend::None);
+    let backend = requested.or(recorded).unwrap_or(DisplayBackend::Adaptive);
     ResolvedBackend {
         backend,
-        non_default: backend != DisplayBackend::None,
+        non_default: backend != DisplayBackend::Adaptive,
     }
 }