@team-agent/installer 0.5.84 → 0.5.85

package/Cargo.lock

@@ -581,7 +581,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.5.84"
+version = "0.5.85"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent", "crates/win-conpty-phase0", "crates/conpty-trans
 
 [workspace.package]
 edition = "2021"
-version = "0.5.84"
+version = "0.5.85"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/profile.rs

@@ -222,18 +222,10 @@ fn set_owner_only_permissions(path: &Path) -> Result<(), CliError> {
 
 fn read_profile_env(path: &Path) -> Result<Map<String, Value>, CliError> {
     let raw = std::fs::read_to_string(path)?;
-    let mut values = Map::new();
-    for line in raw.lines() {
-        let trimmed = line.trim();
-        if trimmed.is_empty() || trimmed.starts_with('#') {
-            continue;
-        }
-        let Some((key, value)) = trimmed.split_once('=') else {
-            continue;
-        };
-        values.insert(key.to_string(), Value::String(value.to_string()));
-    }
-    Ok(values)
+    Ok(crate::lifecycle::profile_launch::parse_env_text(&raw)
+        .into_iter()
+        .map(|(key, value)| (key, Value::String(value)))
+        .collect())
 }
 
 fn redacted_values(values: &Map<String, Value>) -> Value {

package/crates/team-agent/src/cli/tests/verb_profile.rs

@@ -322,3 +322,69 @@ fn profile_show_routes_and_preserves_redacted_secret_contract() {
     );
     let _ = std::fs::remove_dir_all(&ws);
 }
+
+#[test]
+fn config_authority_t04_show_doctor_and_runtime_parse_the_same_profile_bytes() {
+    let ws = tmp_workspace();
+    let runtime_dir = ws.join(".team/runtime");
+    std::fs::remove_dir(&runtime_dir).unwrap();
+    assert!(
+        !runtime_dir.exists(),
+        "T04 fixture must start without a runtime directory"
+    );
+    let dir = profiles_dir(&ws);
+    std::fs::create_dir_all(&dir).unwrap();
+    let body = "# synthetic fixture\nexport AUTH_MODE = 'compatible_api'\nPROXY_MODE=inherit\nexport PROXY_MODE = \"direct\"\nMODEL = 'synthetic-model'\nBASE_URL = \"http://127.0.0.1:9/v1\"\nexport API_KEY = 'synthetic-secret-placeholder'\nPLAIN=plain\nBAD-KEY=ignored\n1BAD=ignored\nMISSING_EQUALS\n";
+    std::fs::write(dir.join("syntax.env"), body).unwrap();
+    let runtime = crate::lifecycle::profile_launch::load_profile(&ws, "syntax", None).unwrap();
+    assert!(
+        !runtime_dir.exists(),
+        "load_profile must not create the runtime directory"
+    );
+    for (key, value) in [
+        ("AUTH_MODE", "compatible_api"),
+        ("PROXY_MODE", "direct"),
+        ("MODEL", "synthetic-model"),
+        ("PLAIN", "plain"),
+    ] {
+        assert_eq!(runtime.values.get(key).map(String::as_str), Some(value));
+    }
+    assert!(!runtime.values.contains_key("BAD-KEY"));
+    assert!(!runtime.values.contains_key("1BAD"));
+    for command in ["show", "doctor"] {
+        let result = cmd_profile(&ProfileArgs {
+            command: command.into(),
+            name: "syntax".into(),
+            workspace: ws.clone(),
+            team: None,
+            auth_mode: None,
+            proxy_mode: None,
+            json: true,
+        })
+        .unwrap();
+        let CmdOutput::Json(output) = result.output else {
+            panic!("expected JSON")
+        };
+        assert!(
+            !runtime_dir.exists(),
+            "profile {command} must not create the runtime directory"
+        );
+        assert_eq!(output["auth_mode"], runtime.values["AUTH_MODE"]);
+        assert_eq!(output["proxy_mode"], runtime.values["PROXY_MODE"]);
+        assert_eq!(output["credential_present"], true);
+        assert_eq!(output["secret_values_printed"], false);
+        assert!(!output.to_string().contains("synthetic-secret-placeholder"));
+        assert!(!output.to_string().contains("BAD-KEY"));
+        if command == "show" {
+            assert_eq!(output["values"]["MODEL"]["value"], "synthetic-model");
+            assert_eq!(output["values"]["API_KEY"]["redacted"], true);
+            assert_eq!(output["missing_common"], serde_json::json!([]));
+        }
+    }
+    assert_eq!(
+        std::fs::read_to_string(dir.join("syntax.env")).unwrap(),
+        body
+    );
+    assert!(!dir.join("syntax.example.env").exists());
+    assert!(!ws.join(".team/runtime").exists());
+}

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

@@ -135,7 +135,7 @@ pub(crate) fn write_worker_mcp_config_for_provider(
             .map_err(|e| LifecycleError::StatePersist(format!("{}: {e}", parent.display())))?;
     }
     let raw = if matches!(provider, Some(Provider::Copilot)) {
-        copilot_translate_mcp_servers(&config.raw)
+        crate::provider::adapters::copilot::copilot_translate_mcp_config(&config.raw)
     } else {
         config.raw.clone()
     };
@@ -610,36 +610,6 @@ fn upsert_toml_table_prefixes(existing: &str, tables: &[&str], stanza: &str) ->
     }
 }
 
-/// ---
-/// purpose: 把 MCP 配置里每个 server 的 type 字段名换成 transport
-/// returns: 同结构的新值，其余字段全部保留；非对象原样返回
-/// ---
-/// C-3-4 cr verdict v2 — McpConfig.raw 是 `{name: {type, command, args, env}}` 形;
-/// copilot mcp add schema 取 `transport` 替 `type`(stdio|http|sse 同值)。仅
-/// 字段名变换,其余字段全保留。
-pub(super) fn copilot_translate_mcp_servers(raw: &serde_json::Value) -> serde_json::Value {
-    let Some(servers) = raw.as_object() else {
-        return raw.clone();
-    };
-    let mut translated = serde_json::Map::new();
-    for (name, server) in servers {
-        let Some(obj) = server.as_object() else {
-            translated.insert(name.clone(), server.clone());
-            continue;
-        };
-        let mut out = serde_json::Map::new();
-        for (key, value) in obj {
-            if key == "type" {
-                out.insert("transport".to_string(), value.clone());
-            } else {
-                out.insert(key.clone(), value.clone());
-            }
-        }
-        translated.insert(name.clone(), serde_json::Value::Object(out));
-    }
-    serde_json::Value::Object(translated)
-}
-
 /// ---
 /// purpose: 把 argv 里 provider 原生的 MCP 配置参数改指到已落盘的文件
 /// params:

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

@@ -333,7 +333,7 @@ fn push_unique_path(paths: &mut Vec<PathBuf>, path: PathBuf) {
     }
 }
 
-fn parse_env_text(text: &str) -> BTreeMap<String, String> {
+pub(crate) fn parse_env_text(text: &str) -> BTreeMap<String, String> {
     let mut values = BTreeMap::new();
     for raw in text.lines() {
         let mut line = raw.trim();

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

@@ -343,10 +343,11 @@ pub(super) fn spawn_agent_window(
     let mcp_config_path = if provider == crate::provider::Provider::Pi {
         None
     } else {
-        Some(crate::lifecycle::launch::write_worker_mcp_config(
+        Some(crate::lifecycle::launch::write_worker_mcp_config_for_provider(
             workspace,
             agent_id.as_str(),
             &mcp_config,
+            Some(provider),
         )?)
     };
     let profile_launch =

package/crates/team-agent/src/lifecycle/tests/copilot_provider_red.rs

@@ -993,6 +993,145 @@ fn copilot_mcp_config_uses_copilot_field_name() {
     );
 }
 
+fn assert_rules_t02_final_mcp(argv: &[String], ws: &Path, agent_id: &str, team: &str) {
+    let argument = flag_value(argv, "--additional-mcp-config").expect("final MCP flag");
+    let path = argument
+        .strip_prefix('@')
+        .expect("final plan references a file");
+    let config: serde_json::Value =
+        serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap();
+    let server = &config["mcpServers"]["team_orchestrator"];
+    assert_eq!(server["transport"], "stdio", "{config}");
+    assert!(server.get("type").is_none(), "{config}");
+    assert!(Path::new(server["command"].as_str().unwrap()).is_absolute());
+    assert_eq!(
+        server["args"],
+        serde_json::json!(["mcp-server", "--workspace", ws])
+    );
+    assert_eq!(
+        server["env"]["TEAM_AGENT_WORKSPACE"],
+        ws.to_string_lossy().as_ref()
+    );
+    assert_eq!(server["env"]["TEAM_AGENT_ID"], agent_id);
+    assert_eq!(server["env"]["TEAM_AGENT_OWNER_TEAM_ID"], team);
+    eprintln!("T02 final MCP: agent={agent_id} team={team} argv={argv:?} config={config}");
+}
+
+#[test]
+#[serial(env)]
+fn rules_t02_final_mcp_across_fresh_start_restart_and_add() {
+    let hermetic = enter_hermetic("rules-t02-final-mcp");
+    let _guard = EnvGuard::set(&[(ANCESTRY_KEY, NEUTRAL_ANCESTRY)]);
+    let ws = hermetic.workspace("mcp");
+    let team_dir = write_copilot_team(&ws, "cp-resume", &["mcp_team"], false);
+    seed_healthy_coordinator(&ws);
+    let health = team_agent::coordinator::coordinator_health(
+        &team_agent::coordinator::WorkspacePath::new(ws.clone()),
+    );
+    assert!(
+        health.ok,
+        "seeded coordinator must prevent daemon spawn: {health:?}"
+    );
+    let fresh = RecordingTransport::new();
+    quick_start_with_transport_in_workspace(&ws, &team_dir, None, true, Some("cpresume"), &fresh)
+        .expect("fresh entry");
+    let argv = fresh.single_spawn().argv;
+    assert_rules_t02_final_mcp(&argv, &ws, "worker_a", "cpresume");
+    assert!(flag_value(&argv, "--session-id").is_some());
+    assert!(flag_value(&argv, "--resume").is_none());
+
+    seed_running_resumable(&ws, "worker_a");
+    seed_copilot_session_store(hermetic.home(), "99999999-aaaa-4bbb-8ccc-dddddddddddd");
+    for single in [true, false] {
+        // A previous file is an output, never the authority for the next spawn.
+        std::fs::write(ws.join(".team/runtime/mcp/worker_a.json"),
+            r#"{"mcpServers":{"team_orchestrator":{"type":"stdio","env":{"TEAM_AGENT_ID":"foreign"}}}}"#,
+        ).unwrap();
+        let transport = RecordingTransport::new();
+        if single {
+            team_agent::lifecycle::start_agent_with_transport(
+                &ws,
+                &team_agent::model::ids::AgentId::new("worker_a"),
+                true,
+                false,
+                false,
+                Some("cpresume"),
+                &transport,
+            )
+            .expect("single start entry");
+        } else {
+            team_agent::lifecycle::restart_with_transport(&ws, true, Some("cpresume"), &transport)
+                .expect("team restart entry");
+        }
+        let argv = transport.single_spawn().argv;
+        assert_rules_t02_final_mcp(&argv, &ws, "worker_a", "cpresume");
+        assert_eq!(
+            flag_value(&argv, "--resume").as_deref(),
+            Some("99999999-aaaa-4bbb-8ccc-dddddddddddd")
+        );
+        assert!(flag_value(&argv, "--session-id").is_none());
+    }
+
+    let role_file = ws.join("worker_b.md");
+    let role = std::fs::read_to_string(team_dir.join("agents/worker_a.md")).unwrap();
+    std::fs::write(&role_file, role.replace("worker_a", "worker_b")).unwrap();
+    let added = RecordingTransport::with_session_present();
+    team_agent::lifecycle::add_agent_with_transport(
+        &team_dir,
+        &team_agent::model::ids::AgentId::new("worker_b"),
+        &role_file,
+        false,
+        Some("cpresume"),
+        &added,
+    )
+    .expect("add entry");
+    assert_rules_t02_final_mcp(&added.single_spawn().argv, &ws, "worker_b", "cpresume");
+}
+
+#[test]
+fn rules_t02_inline_server_map_preserves_unknown_and_non_object_values() {
+    use team_agent::provider::adapters::copilot::copilot_translate_mcp_config;
+    let raw = serde_json::json!({
+        "stdio": {"type": "stdio", "command": "synthetic", "unknown": {"type": "nested"}},
+        "http": {"type": "http", "url": "https://example.invalid"},
+        "opaque": 7,
+    });
+    let translated = copilot_translate_mcp_config(&raw);
+    assert_eq!(
+        translated,
+        serde_json::json!({
+            "stdio": {"transport": "stdio", "command": "synthetic", "unknown": {"type": "nested"}},
+            "http": {"transport": "http", "url": "https://example.invalid"},
+            "opaque": 7,
+        })
+    );
+    assert!(translated.get("mcpServers").is_none());
+    for raw in [serde_json::json!(null), serde_json::json!([1, "opaque"])] {
+        assert_eq!(copilot_translate_mcp_config(&raw), raw);
+    }
+}
+
+#[test]
+#[serial(env)]
+fn rules_t02_non_copilot_writer_keeps_canonical_schema() {
+    let hermetic = enter_hermetic("rules-t02-canonical");
+    let ws = hermetic.workspace("canonical");
+    let config = team_agent::provider::get_adapter(Provider::ClaudeCode)
+        .mcp_config(team_agent::provider::AuthMode::Subscription)
+        .unwrap();
+    let path = team_agent::lifecycle::launch::write_worker_mcp_config_for_provider(
+        &ws,
+        "synthetic",
+        &config,
+        Some(Provider::ClaudeCode),
+    )
+    .unwrap();
+    let written: serde_json::Value =
+        serde_json::from_str(&std::fs::read_to_string(path).unwrap()).unwrap();
+    assert_eq!(written["mcpServers"], config.raw);
+    assert_eq!(written["mcpServers"]["team_orchestrator"]["type"], "stdio");
+}
+
 /// C-7-3 / RC-24: a resume command line must not carry `--session-id` and `--resume`
 /// together (conflicting session semantics). Driven through the real restart path so
 /// the public resume builder is exercised end to end.
@@ -1436,11 +1575,7 @@ fn write_copilot_team(ws: &Path, name: &str, tools: &[&str], dangerous: bool) ->
     let team = ws.join(name);
     std::fs::create_dir_all(team.join("agents")).unwrap();
     // 0.5.66 bypass 单源:bypass 由角色字段驱动,不再是 TEAM.md dangerous_auto_approve。
-    let role_bypass = if dangerous {
-        "true"
-    } else {
-        "false"
-    };
+    let role_bypass = if dangerous { "true" } else { "false" };
     std::fs::write(
         team.join("TEAM.md"),
         format!(
@@ -1637,6 +1772,7 @@ struct RecordedSpawn {
 struct RecordingTransport {
     spawns: Mutex<Vec<RecordedSpawn>>,
     session_present: Mutex<bool>,
+    panes: Mutex<Vec<PaneInfo>>,
 }
 
 impl RecordingTransport {
@@ -1681,8 +1817,22 @@ impl Transport for RecordingTransport {
             window: window.as_str().to_string(),
         });
         *self.session_present.lock().unwrap() = true;
+        let pane_id = PaneId::new(format!("%{}", spawns.len()));
+        self.panes.lock().unwrap().push(PaneInfo {
+            pane_id: pane_id.clone(),
+            session: session.clone(),
+            window_index: None,
+            window_name: Some(window.clone()),
+            pane_index: None,
+            tty: None,
+            current_command: None,
+            current_path: None,
+            active: false,
+            pane_pid: Some(30_000 + spawns.len() as u32),
+            leader_env: BTreeMap::new(),
+        });
         Ok(SpawnResult {
-            pane_id: PaneId::new(format!("%{}", spawns.len())),
+            pane_id,
             session: session.clone(),
             window: window.clone(),
             child_pid: Some(30_000 + spawns.len() as u32),
@@ -1747,7 +1897,7 @@ impl Transport for RecordingTransport {
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        Ok(self.panes.lock().unwrap().clone())
     }
 
     fn has_session(&self, _session: &SessionName) -> Result<bool, TransportError> {
@@ -1769,10 +1919,20 @@ impl Transport for RecordingTransport {
 
     fn kill_session(&self, _session: &SessionName) -> Result<(), TransportError> {
         *self.session_present.lock().unwrap() = false;
+        self.panes
+            .lock()
+            .unwrap()
+            .retain(|pane| &pane.session != _session);
         Ok(())
     }
 
-    fn kill_window(&self, _target: &Target) -> Result<(), TransportError> {
+    fn kill_window(&self, target: &Target) -> Result<(), TransportError> {
+        self.panes.lock().unwrap().retain(|pane| match target {
+            Target::Pane(id) => &pane.pane_id != id,
+            Target::SessionWindow { session, window } => {
+                &pane.session != session || pane.window_name.as_ref() != Some(window)
+            }
+        });
         Ok(())
     }
 
@@ -1796,6 +1956,17 @@ fn copilot_empty_mcp_list_shim(tag: &str) -> TempWorkspace {
     #[cfg(unix)]
     {
         use std::os::unix::fs::PermissionsExt;
+        // coordinator health needs the seeded test PID's real non-zombie status.
+        // Keep PATH isolated and refuse any broader process inspection.
+        std::fs::write(
+            bin.join("ps"),
+            format!(
+                "#!/bin/sh\nif [ \"$#\" = 4 ] && [ \"$1\" = -p ] && [ \"$2\" = {} ] && [ \"$3\" = -o ] && [ \"$4\" = stat= ]; then\n  exec /bin/ps \"$@\"\nfi\nexit 1\n",
+                std::process::id(),
+            ),
+        )
+        .unwrap();
+        std::fs::set_permissions(bin.join("ps"), std::fs::Permissions::from_mode(0o755)).unwrap();
         std::fs::set_permissions(bin.join("copilot"), std::fs::Permissions::from_mode(0o755))
             .unwrap();
     }