@team-agent/installer 0.5.120 → 0.5.122

package/crates/team-agent/src/messaging/tests/dup_inject.rs

@@ -28,6 +28,68 @@ use crate::transport::{
     TurnVerification, WindowName,
 };
 
+#[test]
+#[cfg(unix)]
+fn eager_mcp_waits_without_spending_input_attempts_then_delivers_the_same_message() {
+    let mut case = WorkerCase::new("mcp-handshake", "cursor_agent");
+    let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+    let config = case.workspace.join(".team/runtime/mcp/w1.json");
+    std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+    std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
+        "mcpServers": {"team_orchestrator": {
+            "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+            "env": {"TEAM_AGENT_WORKSPACE": case.workspace, "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": "dup-team"}
+        }}
+    })).unwrap()).unwrap();
+    case.state["team_key"] = serde_json::json!("dup-team");
+    case.state["agents"]["w1"]["mcp_config"] = serde_json::json!(config);
+    case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
+    case.state["agents"]["w1"]["spawned_at"] = serde_json::json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
+    case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
+    crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+    let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
+    let message_id = case.store.create_message(None, "leader", "w1", "handshake canary", None, false, Some("dup-team")).unwrap();
+    for _ in 0..3 {
+        let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
+            &message_id, &case.event_log, &case.state).unwrap();
+        assert!(!outcome.ok);
+        assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_"));
+        assert_eq!(transport.inject_count(), 0);
+    }
+    let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
+    let attempts: i64 = connection.query_row("select delivery_attempts from messages where message_id=?1", [&message_id], |row| row.get(0)).unwrap();
+    assert_eq!(attempts, 0, "waiting is not a physical delivery attempt");
+    crate::mcp_server::readiness::publish(&case.workspace, "dup-team", "w1", chrono::Utc::now()).unwrap();
+    let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
+        &message_id, &case.event_log, &case.state).unwrap();
+    assert_eq!(outcome.message_id.as_deref(), Some(message_id.as_str()));
+    assert_eq!(transport.inject_count(), 1, "same queued row proceeds after the real receipt");
+}
+
+#[test]
+#[cfg(unix)]
+fn issue345_missing_eager_config_defers_without_input_or_attempts() {
+    let mut case = WorkerCase::new("missing-mcp-config", "cursor_agent");
+    let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+    case.state["team_key"] = serde_json::json!("dup-team");
+    case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
+    case.state["agents"]["w1"]["spawned_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
+    case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
+    crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+    let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
+    let message_id = case.store.create_message(None, "leader", "w1", "missing config canary", None, false, Some("dup-team")).unwrap();
+    for _ in 0..3 {
+        let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
+            &message_id, &case.event_log, &case.state).unwrap();
+        assert!(!outcome.ok);
+        assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_"));
+        assert_eq!(transport.inject_count(), 0, "missing metadata must never reach input");
+    }
+    let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
+    let attempts: i64 = connection.query_row("select delivery_attempts from messages where message_id=?1", [&message_id], |row| row.get(0)).unwrap();
+    assert_eq!(attempts, 0, "metadata wait is not an input attempt");
+}
+
 #[test]
 fn error_retry_claim_is_single_winner_across_two_delivers() {
     let case = WorkerCase::new("claim-gate", "fake");
@@ -103,10 +165,30 @@ fn observer_state_save_failure_after_enter_does_not_return_err() {
 
 #[test]
 fn pane_token_refuses_second_inject_for_claude_grok_cursor() {
-    for provider in ["claude", "grok", "cursor"] {
-        let case = WorkerCase::new(&format!("token-{provider}"), provider);
-        let transport = RecordingTransport::new("");
-        let message_id = case.seed_leader_to_worker(&format!("{provider} canary"));
+    for provider in ["claude", "grok", "cursor_agent"] {
+        let mut case = WorkerCase::new(&format!("token-{provider}"), provider);
+        #[cfg(unix)]
+        let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+        #[cfg(not(unix))]
+        let carrier = std::process::id();
+        let config = case.workspace.join(".team/runtime/mcp/w1.json");
+        std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+        std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
+            "mcpServers": {"team_orchestrator": {
+                "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+                "env": {"TEAM_AGENT_WORKSPACE": case.workspace, "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": "dup-team"}
+            }}
+        })).unwrap()).unwrap();
+        case.state["team_key"] = serde_json::json!("dup-team");
+        case.state["agents"]["w1"]["mcp_config"] = serde_json::json!(config);
+        case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
+        case.state["agents"]["w1"]["spawned_at"] = serde_json::json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
+        case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
+        crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
+        #[cfg(unix)]
+        crate::mcp_server::readiness::publish(&case.workspace, "dup-team", "w1", chrono::Utc::now()).unwrap();
+        let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
+        let message_id = case.store.create_message(None, "leader", "w1", &format!("{provider} canary"), None, false, Some("dup-team")).unwrap();
         let first = deliver_pending_message(
             &case.workspace,
             &case.store,
@@ -273,6 +355,7 @@ fn poison_state_file(workspace: &Path) {
 struct RecordingTransport {
     injects: Arc<AtomicUsize>,
     capture: Arc<Mutex<String>>,
+    carrier: Option<u32>,
 }
 
 impl RecordingTransport {
@@ -280,6 +363,7 @@ impl RecordingTransport {
         Self {
             injects: Arc::new(AtomicUsize::new(0)),
             capture: Arc::new(Mutex::new(capture.to_string())),
+            carrier: None,
         }
     }
 
@@ -370,7 +454,7 @@ impl Transport for RecordingTransport {
             current_command: Some("sleep".to_string()),
             current_path: None,
             active: true,
-            pane_pid: None,
+            pane_pid: self.carrier,
             leader_env: BTreeMap::new(),
         }])
     }

package/crates/team-agent/src/messaging/tests/spine.rs

@@ -169,7 +169,10 @@ fn p2_scheduler_unknown_kind_surfaces_error() {
 
 /// A delivery transport whose `inject` RECORDS-and-succeeds (the real deliver loop legitimately
 /// injects; the §84-guard NoopTransport panics). Only `inject` is reached by deliver_pending_message.
-struct DeliverOkTransport;
+#[derive(Default)]
+struct DeliverOkTransport {
+    targets: Vec<PaneInfo>,
+}
 impl Transport for DeliverOkTransport {
     fn kind(&self) -> BackendKind {
         BackendKind::Tmux
@@ -232,7 +235,7 @@ impl Transport for DeliverOkTransport {
         Ok(PaneLiveness::Unknown)
     }
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
-        Ok(Vec::new())
+        Ok(self.targets.clone())
     }
     fn has_session(&self, _s: &SessionName) -> Result<bool, TransportError> {
         Ok(true)
@@ -333,9 +336,9 @@ fn spine_delivery_skips_queued_statuses() {
         .unwrap();
     set_message_status(&store, &qidle, "queued_until_idle");
     set_message_status(&store, &qstart, "queued_until_start");
-    let state = serde_json::json!({"agents": {"w1": {}}});
+    let state = serde_json::json!({"agents": {"w1": {"provider": "fake"}}});
 
-    let _ = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
+    let _ = deliver_pending_messages(&ws, &state, &DeliverOkTransport::default(), &log).unwrap();
 
     assert_eq!(
         message_status_of(&store, &qidle),
@@ -359,9 +362,9 @@ fn spine_delivery_busy_recipient_is_injected_without_idle_deferral() {
     let mid = store
         .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
         .unwrap();
-    let state = serde_json::json!({"agents": {"w1": {"status": "busy"}}});
+    let state = serde_json::json!({"agents": {"w1": {"provider": "fake", "status": "busy"}}});
 
-    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
+    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport::default(), &log).unwrap();
 
     assert!(delivered.contains(&mid));
     assert_eq!(message_status_of(&store, &mid), "delivered");
@@ -380,11 +383,39 @@ fn spine_delivery_pi_cursor_uses_v113_direct_input_without_idle_scope() {
         let store = store_for(&ws);
         let log = EventLog::new(&ws);
         let mid = store
-            .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
+            .create_message(Some("t"), "leader", "w1", "hi", None, true, Some("spine-team"))
             .unwrap();
-        let state = serde_json::json!({"agents": {"w1": {"provider": provider, "status": "running"}}});
-        let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
-        assert!(delivered.contains(&mid), "{provider}");
+        #[cfg(unix)]
+        let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
+        #[cfg(not(unix))]
+        let carrier = std::process::id();
+        let config = ws.join(".team/runtime/mcp/w1.json");
+        std::fs::create_dir_all(config.parent().unwrap()).unwrap();
+        std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
+            "mcpServers": {"team_orchestrator": {
+                "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
+                "env": {"TEAM_AGENT_WORKSPACE": ws, "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": "spine-team"}
+            }}
+        })).unwrap()).unwrap();
+        let mut state = serde_json::json!({"team_key": "spine-team", "active_team_key": "spine-team", "session_name": "spine", "agents": {"w1": {
+            "provider": provider, "status": "running", "window": "w1", "mcp_config": config,
+            "spawned_at": (chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339(),
+            "pane_id": "%spine", "pane_pid": carrier
+        }}});
+        state["teams"] = serde_json::json!({"spine-team": state.clone()});
+        crate::state::persist::save_runtime_state(&ws, &state).unwrap();
+        #[cfg(unix)]
+        if provider == "cursor_agent" {
+            crate::mcp_server::readiness::publish(&ws, "spine-team", "w1", chrono::Utc::now()).unwrap();
+        }
+        let transport = DeliverOkTransport { targets: vec![PaneInfo {
+            pane_id: PaneId::new("%spine"), session: SessionName::new("spine"),
+            window_index: None, window_name: Some(WindowName::new("w1")), pane_index: None, tty: None,
+            current_command: None, current_path: None, active: true,
+            pane_pid: Some(carrier), leader_env: BTreeMap::new(),
+        }] };
+        let delivered = deliver_pending_messages(&ws, &state, &transport, &log).unwrap();
+        assert!(delivered.contains(&mid), "{provider}: {:?}", read_event_log(&ws));
         assert_eq!(message_status_of(&store, &mid), "delivered");
     }
 }
@@ -405,9 +436,9 @@ fn contract_alive_worker_with_working_health_is_deliverable_not_deferred() {
         .create_message(Some("t"), "leader", "w1", "hi", None, true, None)
         .unwrap();
     seed_agent_health(&store, "w1", "WORKING"); // turn-level state — must NOT gate delivery
-    let state = serde_json::json!({"agents": {"w1": {"status": "running"}}}); // lifecycle: alive
+    let state = serde_json::json!({"agents": {"w1": {"provider": "fake", "status": "running"}}}); // lifecycle: alive
 
-    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport, &log).unwrap();
+    let delivered = deliver_pending_messages(&ws, &state, &DeliverOkTransport::default(), &log).unwrap();
 
     let events = read_event_log(&ws);
     let deferred: Vec<_> = events
@@ -530,7 +561,7 @@ fn spine_delivery_injects_resolvable_target_not_bare_agent_pane() {
     // in-team, non-busy agent -> deliver proceeds; the session-qualified resolution uses session_name + window.
     let state = serde_json::json!({
         "session_name": "team-x",
-        "agents": {"w1": {"status": "idle", "window": "w1"}}
+        "agents": {"w1": {"provider": "fake", "status": "idle", "window": "w1"}}
     });
     let transport = OfflineTransport::new();
 
@@ -585,7 +616,7 @@ fn spine_delivery_injects_rendered_protocol_block_not_raw_content() {
         .unwrap();
     let state = serde_json::json!({
         "session_name": "team-x",
-        "agents": {"w1": {"status": "idle", "window": "w1"}}
+        "agents": {"w1": {"provider": "fake", "status": "idle", "window": "w1"}}
     });
     let transport = OfflineTransport::new();
 

package/crates/team-agent/src/provider/adapter.rs

@@ -214,6 +214,13 @@ pub trait ProviderAdapter {
     /// compatible_api 走 `ensure_compatible_claude_mcp_config`)。
     fn mcp_config(&self, auth_mode: AuthMode) -> Result<McpConfig, ProviderError>;
 
+    /// Eager stdio clients must publish their initial MCP handshake before input.
+    /// Pi owns admission in its runtime registry hooks; Fake has no MCP client.
+    /// The process-stamp receipt port is currently POSIX-only, not a Windows claim.
+    fn requires_worker_mcp_handshake(&self) -> bool {
+        cfg!(unix) && !matches!(self.provider(), Provider::Fake | Provider::Pi)
+    }
+
     /// 安装 MCP server。gemini 写全局 `~/.gemini/settings.json` 并备份/还原
     /// (`gemini.py:40-78`)——有副作用 I/O,失败可还原 → Result。
     fn install_mcp(&self, config: &McpConfig) -> Result<(), ProviderError>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.120",
+  "version": "0.5.122",
   "description": "npx installer for Team Agent",
   "keywords": [
     "codex",
@@ -20,9 +20,9 @@
     "team-agent-installer": "npm/install.mjs"
   },
   "optionalDependencies": {
-    "@team-agent/cli-darwin-arm64": "0.5.120",
-    "@team-agent/cli-darwin-x64": "0.5.120",
-    "@team-agent/cli-linux-x64": "0.5.120"
+    "@team-agent/cli-darwin-arm64": "0.5.122",
+    "@team-agent/cli-darwin-x64": "0.5.122",
+    "@team-agent/cli-linux-x64": "0.5.122"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",