@team-agent/installer 0.5.66 → 0.5.68

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

@@ -261,3 +261,307 @@ fn unsupported_provider_capability_error_message_shape() {
 // ═══════════════ P2 FIX-LOOP RED (复绿即对抗 cross-model findings) ═══════════════
 // Lock the CORRECT Python v0.2.11 behavior the strengthened contracts missed.
 // Golden re-probed via /tmp/probe_p2_provider.py vs team-agent-public @ 439bef8.
+
+// ═══════════════ 0.5.67 provider-adapter (Grok + CursorAgent) ═══════════════
+// 仿 claude build_command tests 结构 (见 build_command_includes_model_and_system_prompt)。
+// 不跑 cargo (禁 cargo 红线), 静态编码 + leader verify 时执行。
+
+#[test]
+fn test_grok_build_command_includes_rules_flag_when_system_prompt_set() {
+    let adapter = get_adapter(Provider::Grok);
+    let argv = adapter
+        .build_command(AuthMode::Subscription, None, Some("be helpful"), Some("grok-4"))
+        .expect("build_command ok");
+    assert!(
+        argv_contains_adjacent(&argv, &["--model", "grok-4"]),
+        "argv must contain `--model grok-4` adjacency: {argv:?}"
+    );
+    assert!(
+        argv_contains_adjacent(&argv, &["--rules", "be helpful"]),
+        "grok append-system-prompt must be `--rules 'be helpful'`: {argv:?}"
+    );
+}
+
+#[test]
+fn test_grok_build_command_bypass_flag_when_dangerous() {
+    let adapter = get_adapter(Provider::Grok);
+    let dangerous = adapter
+        .build_command_with_tools(
+            AuthMode::Subscription,
+            None,
+            None,
+            Some("grok-4"),
+            &["dangerous_auto_approve"],
+        )
+        .expect("dangerous build_command ok");
+    assert!(
+        argv_contains_adjacent(&dangerous, &["--always-approve"]),
+        "dangerous grok must include `--always-approve`: {dangerous:?}"
+    );
+    let safe = adapter
+        .build_command(AuthMode::Subscription, None, None, Some("grok-4"))
+        .expect("safe build_command ok");
+    assert!(
+        !safe.iter().any(|a| a == "--always-approve"),
+        "non-dangerous grok must not include --always-approve: {safe:?}"
+    );
+}
+
+#[test]
+fn test_grok_build_command_refuses_missing_model() {
+    let adapter = get_adapter(Provider::Grok);
+    let err = adapter
+        .build_command(AuthMode::Subscription, None, None, None)
+        .expect_err("grok must refuse to build argv without an explicit model");
+    let text = err.to_string();
+    assert!(
+        text.to_ascii_lowercase().contains("model"),
+        "error must name model; got {text}"
+    );
+    assert!(
+        text.to_ascii_lowercase().contains("built-in")
+            || text.to_ascii_lowercase().contains("builtin")
+            || text.contains("内建"),
+        "error must name the built-in default the framework would fill; got {text}"
+    );
+    assert!(
+        argv_contains_adjacent(
+            &adapter
+                .build_command(AuthMode::Subscription, None, None, Some("grok-4.6"))
+                .expect("explicit model must build"),
+            &["--model", "grok-4.6"]
+        ),
+        "explicit model must still become adjacent `--model grok-4.6`"
+    );
+}
+
+#[test]
+fn test_cursor_agent_build_command_includes_workspace_flag() {
+    let adapter = get_adapter(Provider::CursorAgent);
+    let argv = adapter
+        .build_command(AuthMode::Subscription, None, Some("be helpful"), Some("sonnet-4-thinking"))
+        .expect("build_command ok");
+    // system_prompt 不入 argv (方案 1 变体走 workspace rules 文件), argv 只带
+    // --workspace {workspace} placeholder (spawn 时 fill_spawn_placeholders 替换)。
+    assert!(
+        argv_contains_adjacent(&argv, &["--workspace", "{workspace}"]),
+        "cursor argv must carry `--workspace {{workspace}}`: {argv:?}"
+    );
+    assert!(
+        argv_contains_adjacent(&argv, &["--trust"]),
+        "cursor argv must carry documented --trust: {argv:?}"
+    );
+    assert!(
+        argv_contains_adjacent(&argv, &["--sandbox", "disabled"]),
+        "cursor argv must carry documented --sandbox disabled: {argv:?}"
+    );
+    assert!(
+        !argv.iter().any(|a| a == "--rules" || a == "--append-system-prompt"),
+        "cursor append-system-prompt must NOT go on argv (workspace rules file): {argv:?}"
+    );
+    assert!(
+        !argv.iter().any(|a| a == "--system-prompt" || a == "--allowed-tools"),
+        "undocumented flags must stay off the main path: {argv:?}"
+    );
+}
+
+#[test]
+fn test_cursor_agent_build_command_bypass_flag_when_dangerous() {
+    let adapter = get_adapter(Provider::CursorAgent);
+    let dangerous = adapter
+        .build_command_with_tools(
+            AuthMode::Subscription,
+            None,
+            None,
+            None,
+            &["dangerous_auto_approve"],
+        )
+        .expect("dangerous build_command ok");
+    assert!(
+        argv_contains_adjacent(&dangerous, &["--force"]),
+        "dangerous cursor must include `--force`: {dangerous:?}"
+    );
+    let safe = adapter
+        .build_command(AuthMode::Subscription, None, None, None)
+        .expect("safe build_command ok");
+    assert!(
+        !safe.iter().any(|a| a == "--force"),
+        "non-dangerous cursor must not include --force: {safe:?}"
+    );
+}
+
+#[test]
+fn test_cursor_agent_accepts_mcp_config_without_putting_it_on_argv() {
+    let adapter = get_adapter(Provider::CursorAgent);
+    let cfg = McpConfig {
+        raw: serde_json::json!({
+            "team_orchestrator": {
+                "command": "/bin/team-agent",
+                "args": ["mcp-server"]
+            }
+        }),
+    };
+    let argv = adapter
+        .build_command(AuthMode::Subscription, Some(&cfg), None, None)
+        .expect("cursor MCP is launch overlay, not an argv capability hole");
+    assert!(
+        !argv.iter().any(|a| a == "--mcp-config" || a.contains("mcp")),
+        "cursor has no --mcp-config flag; overlay writes .cursor/mcp.json: {argv:?}"
+    );
+    assert!(
+        argv_contains_adjacent(&argv, &["--workspace", "{workspace}"]),
+        "workspace flag must survive an mcp_config argument: {argv:?}"
+    );
+}
+
+#[test]
+fn test_cursor_agent_refuses_mcp_config_loudly() {
+    // 已废除的行为：旧实现收到 mcp_config 就返回 CapabilityUnsupported
+    // （「MCP is not implemented」），此断言证明它确实没了。
+    let adapter = get_adapter(Provider::CursorAgent);
+    let cfg = McpConfig {
+        raw: serde_json::json!({
+            "team_orchestrator": {
+                "command": "/bin/team-agent",
+                "args": ["mcp-server"]
+            }
+        }),
+    };
+    let result = adapter.build_command(AuthMode::Subscription, Some(&cfg), None, None);
+    assert!(
+        !matches!(result, Err(ProviderError::CapabilityUnsupported(_))),
+        "feeding mcp_config must not return CapabilityUnsupported; got {result:?}"
+    );
+}
+
+#[test]
+fn test_grok_build_command_plan_binds_expected_session_id_to_argv() {
+    let adapter = get_adapter(Provider::Grok);
+    let plan = adapter
+        .build_command_plan(ProviderCommandContext {
+            auth_mode: AuthMode::Subscription,
+            mcp_config: None,
+            system_prompt: None,
+            model: Some("grok-4.6"),
+            tools: &[],
+            profile_launch: None,
+            agent_id_hint: Some("w1"),
+            effort: None,
+        })
+        .expect("grok plan");
+    let sid = plan
+        .expected_session_id
+        .as_ref()
+        .map(|s| s.as_str())
+        .expect("grok fresh plan must carry expected_session_id");
+    assert!(
+        !sid.is_empty(),
+        "expected_session_id must be a non-empty uuid"
+    );
+    assert!(
+        argv_contains_adjacent(&plan.argv, &["--session-id", sid]),
+        "argv --session-id must match expected_session_id; argv={:?}",
+        plan.argv
+    );
+    assert!(
+        !plan.argv.iter().any(|a| a == "--resume"),
+        "fresh grok plan must not include --resume; argv={:?}",
+        plan.argv
+    );
+}
+
+#[test]
+fn test_cursor_auth_hint_subscription_is_unknown_not_present() {
+    let adapter = get_adapter(Provider::CursorAgent);
+    let hint = adapter.auth_hint(AuthMode::Subscription);
+    assert_ne!(
+        hint,
+        crate::provider::types::AuthHintStatus::Present,
+        "U-17 前不得把未观测写成 Present"
+    );
+    assert_ne!(hint, crate::provider::types::AuthHintStatus::PresentWeak);
+    assert_eq!(hint, crate::provider::types::AuthHintStatus::Unknown);
+}
+
+#[test]
+fn test_cursor_fresh_plan_has_no_session_id_and_no_resume() {
+    let adapter = get_adapter(Provider::CursorAgent);
+    let plan = adapter
+        .build_command_plan(ProviderCommandContext {
+            auth_mode: AuthMode::Subscription,
+            mcp_config: None,
+            system_prompt: None,
+            model: Some("sonnet-4-thinking"),
+            tools: &[],
+            profile_launch: None,
+            agent_id_hint: Some("w1"),
+            effort: None,
+        })
+        .expect("cursor plan");
+    assert!(
+        plan.expected_session_id.is_none(),
+        "U-01 未过不得造假 pending; got {:?}",
+        plan.expected_session_id
+    );
+    assert!(
+        !plan.argv.iter().any(|a| a == "--session-id" || a == "--resume" || a == "--continue"),
+        "fresh cursor argv must not invent session flags; argv={:?}",
+        plan.argv
+    );
+    assert!(
+        argv_contains_adjacent(&plan.argv, &["--trust"]),
+        "fresh cursor must keep --trust; argv={:?}",
+        plan.argv
+    );
+}
+
+#[test]
+fn test_cursor_resume_plan_requires_chat_id_and_never_emits_empty_resume() {
+    let adapter = get_adapter(Provider::CursorAgent);
+    let ctx = ProviderCommandContext {
+        auth_mode: AuthMode::Subscription,
+        mcp_config: None,
+        system_prompt: None,
+        model: Some("sonnet-4-thinking"),
+        tools: &[],
+        profile_launch: None,
+        agent_id_hint: Some("w1"),
+        effort: None,
+    };
+    let missing = adapter.build_resume_command_plan(None, ctx);
+    assert!(
+        matches!(missing, Err(ProviderError::ResumeUnavailable(_))),
+        "no chatId must not emit empty --resume; got {missing:?}"
+    );
+    let sid = SessionId::new("502896a1-72ba-4c53-9a86-b2da28780806");
+    let plan = adapter
+        .build_resume_command_plan(Some(&sid), ctx)
+        .expect("resume plan");
+    assert!(
+        argv_contains_adjacent(&plan.argv, &["--resume", sid.as_str()]),
+        "resume plan must hit CursorAgent --resume arm; argv={:?}",
+        plan.argv
+    );
+    assert!(
+        !plan.argv.iter().any(|a| a == "--session-id" || a == "--continue"),
+        "resume must not mint --session-id/--continue; argv={:?}",
+        plan.argv
+    );
+}
+
+#[test]
+fn test_grok_unknown_tool_mapping_is_explicitly_unsupported() {
+    use crate::provider::adapters::grok::{grok_tool_mapping, GrokToolMapping};
+    assert_eq!(
+        grok_tool_mapping("network"),
+        GrokToolMapping::Unsupported
+    );
+    assert_eq!(
+        grok_tool_mapping("not_a_real_tool"),
+        GrokToolMapping::Unsupported
+    );
+    assert!(
+        !matches!(grok_tool_mapping("execute_bash"), GrokToolMapping::Unsupported),
+        "known tools must stay mapped"
+    );
+}

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

@@ -353,8 +353,10 @@ pub struct ProviderCommandContext<'a> {
     /// framework passes no effort flag (provider default).
     ///   - Claude / ClaudeCode: low|medium|high|xhigh|max → `--effort <level>`
     ///   - Codex: low|medium|high|xhigh → `-c model_reasoning_effort=<level>`
-    ///   - Copilot / Gemini / Fake: ignored, warning event emitted at the
-    ///     caller (lifecycle/launch.rs / lifecycle/restart) before construct.
+    ///   - Grok: low|medium|high|xhigh (NOT max) → `--effort <level>`
+    ///   - Copilot / Gemini / CursorAgent / Fake: ignored, warning event
+    ///     emitted at the caller (lifecycle/launch.rs / lifecycle/restart)
+    ///     before construct.
     pub effort: Option<crate::model::enums::ProviderEffort>,
 }
 

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

@@ -34,6 +34,8 @@ pub(crate) fn provider_wire(provider: Provider) -> &'static str {
         Provider::Codex => "codex",
         Provider::Copilot => "copilot",
         Provider::GeminiCli => "gemini_cli",
+        Provider::Grok => "grok",
+        Provider::CursorAgent => "cursor_agent",
         Provider::Fake => "fake",
     }
 }
@@ -75,7 +77,12 @@ pub(crate) fn is_claude_family(provider: Provider) -> bool {
 pub(crate) fn requires_resume_backing(provider: Provider) -> bool {
     matches!(
         provider,
-        Provider::Codex | Provider::Claude | Provider::ClaudeCode | Provider::Copilot
+        Provider::Codex
+            | Provider::Claude
+            | Provider::ClaudeCode
+            | Provider::Copilot
+            | Provider::Grok
+            | Provider::CursorAgent
     )
 }
 
@@ -86,6 +93,8 @@ pub(crate) fn provider_model_keys(provider: Provider) -> &'static [&'static str]
         Provider::Codex => &["codex"],
         Provider::Copilot => &["copilot"],
         Provider::GeminiCli => &["gemini_cli"],
+        Provider::Grok => &["grok"],
+        Provider::CursorAgent => &["cursor_agent"],
         Provider::Fake => &["fake"],
     }
 }
@@ -94,6 +103,10 @@ pub(crate) fn builtin_provider_model(provider: Provider) -> Option<&'static str>
     match provider {
         Provider::Claude | Provider::ClaudeCode => Some("claude-sonnet-4-6"),
         Provider::Codex => Some("gpt-5.5"),
+        // grok: compiler 另有缺 model 硬闸，这里的 builtin 不再被 grok 角色吃到。
+        // cursor_agent: 禁止隐式默认（本机 shim 会剥 sonnet-4-thinking）；缺 model 编译失败。
+        Provider::Grok => Some("grok-4"),
+        Provider::CursorAgent => None,
         Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
     }
 }
@@ -112,6 +125,11 @@ pub(crate) fn aliases(provider: Provider) -> &'static [&'static str] {
         Provider::Codex => &["codex"],
         Provider::Copilot => &["copilot"],
         Provider::GeminiCli => &["gemini_cli"],
+        Provider::Grok => &["grok"],
+        // canonical wire form 恒为首项 (parse_provider round-trip 依赖); "agent"
+        // 是 exec 二进制名, 仅作 alias (不参与 command-text 子串匹配, 见
+        // leader/provider_attribution.rs TODO)。
+        Provider::CursorAgent => &["cursor_agent", "agent"],
         Provider::Fake => &["fake"],
     }
 }
@@ -126,6 +144,8 @@ pub(crate) fn command_name(provider: Provider) -> &'static str {
         Provider::Codex => "codex",
         Provider::Copilot => "copilot",
         Provider::GeminiCli => "gemini",
+        Provider::Grok => "grok",
+        Provider::CursorAgent => "agent",
         Provider::Fake => "team-agent",
     }
 }
@@ -136,6 +156,8 @@ const ALL_PROVIDERS: &[Provider] = &[
     Provider::Codex,
     Provider::Copilot,
     Provider::GeminiCli,
+    Provider::Grok,
+    Provider::CursorAgent,
     Provider::Fake,
 ];