@team-agent/installer 0.5.112 → 0.5.113

package/crates/team-agent/src/provider/adapters/cursor_agent.rs

@@ -3,7 +3,7 @@
 //! contract:
 //!   provides:
 //!     - name: cursor_agent_base_command
-//!       what: 只组已实测文档化 flag；mcp_config 不入 argv，由 launch overlay 写盘
+//!       what: 只组已实测文档化 flag；MCP 由 launch overlay 写盘
 //! boundary:
 //!   - 不调未文档化 flag（--system-prompt / --allowed-tools）
 //!   - 不写 grok 那种 cwd 独占闸
@@ -22,60 +22,23 @@
 //! 随时可能消失。可以在注释里记录，代码里不许调。
 //! `--allowed-tools` 正反行为未验证，不写「支持工具白名单」。
 
-use crate::model::enums::AuthMode;
-use crate::provider::adapter::BasicProviderAdapter;
-use crate::provider::{McpConfig, ProviderError};
-
-pub(crate) fn cursor_agent_launch_command(
-    adapter: &BasicProviderAdapter,
-    auth_mode: AuthMode,
-    mcp_config: Option<&McpConfig>,
-    system_prompt: Option<&str>,
-    model: Option<&str>,
-    dangerously_skip_permissions: bool,
-) -> Result<Vec<String>, ProviderError> {
-    cursor_agent_base_command(
-        adapter,
-        auth_mode,
-        mcp_config,
-        system_prompt,
-        model,
-        dangerously_skip_permissions,
-        false,
-        None,
-    )
-}
+use crate::provider::ProviderError;
+use crate::provider::command_helpers::{append_opt_pair, append_pair};
 
 pub(crate) fn cursor_agent_base_command(
-    adapter: &BasicProviderAdapter,
-    auth_mode: AuthMode,
-    mcp_config: Option<&McpConfig>,
-    system_prompt: Option<&str>,
     model: Option<&str>,
     dangerously_skip_permissions: bool,
-    managed_mcp_config: bool,
-    effort: Option<crate::model::enums::ProviderEffort>,
 ) -> Result<Vec<String>, ProviderError> {
     let mut argv = vec!["agent".to_string()];
     if dangerously_skip_permissions {
         // Explicit bypass also opts into Cursor's trusted, unsandboxed launch.
         argv.push("--trust".to_string());
-        argv.push("--sandbox".to_string());
-        argv.push("disabled".to_string());
+        append_pair(&mut argv, "--sandbox", "disabled");
         argv.push("--force".to_string());
     }
-    if let Some(model) = model {
-        argv.push("--model".to_string());
-        argv.push(model.to_string());
-    }
-    // Cursor `--effort` flag 不存在；框架在调用方丢掉 effort。绝不发明 flag。
-    let _ = effort;
-    // system_prompt 不入 argv（help 无 --rules / --append-system-prompt）。
-    // launch 写 `<workspace>/.cursor/rules/team-agent-role-<agent_id>.mdc`。
-    // mcp_config 也不入 argv（无 --mcp-config）。launch 写 `.cursor/mcp.json`
-    // 并 `agent mcp enable team_orchestrator`。这里收下以免静默丢弃。
-    let _ = (adapter, auth_mode, mcp_config, managed_mcp_config, system_prompt);
-    argv.push("--workspace".to_string());
-    argv.push("{workspace}".to_string());
+    append_opt_pair(&mut argv, "--model", model);
+    // Cursor has no `--effort`, system-prompt, or MCP config flag.
+    // Launch materializes role rules and the `.cursor/mcp.json` overlay.
+    append_pair(&mut argv, "--workspace", "{workspace}");
     Ok(argv)
 }

package/crates/team-agent/src/provider/adapters/grok.rs

@@ -30,62 +30,38 @@
 //! → `native_mcp_config: false`; MCP reaches the worker via launch-path
 //! `<cwd>/.grok/config.toml` (`apply_grok_mcp_overlay`).
 
-use crate::model::enums::AuthMode;
-use crate::provider::adapter::{next_session_token, BasicProviderAdapter};
-use crate::provider::{McpConfig, ProviderError};
+use crate::provider::adapter::next_session_token;
+use crate::provider::ProviderError;
+use crate::provider::command_helpers::{append_opt_pair, append_pair};
 
 pub(crate) fn grok_launch_command(
-    adapter: &BasicProviderAdapter,
-    auth_mode: AuthMode,
-    mcp_config: Option<&McpConfig>,
     system_prompt: Option<&str>,
     model: Option<&str>,
     dangerously_skip_permissions: bool,
 ) -> Result<Vec<String>, ProviderError> {
-    let mut argv = grok_base_command(
-        adapter,
-        auth_mode,
-        mcp_config,
-        system_prompt,
-        model,
-        dangerously_skip_permissions,
-        false,
-        None,
-    )?;
-    argv.push("--session-id".to_string());
-    argv.push(next_session_token());
+    let mut argv = grok_base_command(system_prompt, model, dangerously_skip_permissions, None)?;
+    append_pair(&mut argv, "--session-id", next_session_token());
     Ok(argv)
 }
 
 pub(crate) fn grok_base_command(
-    adapter: &BasicProviderAdapter,
-    auth_mode: AuthMode,
-    mcp_config: Option<&McpConfig>,
     system_prompt: Option<&str>,
     model: Option<&str>,
     dangerously_skip_permissions: bool,
-    managed_mcp_config: bool,
     effort: Option<crate::model::enums::ProviderEffort>,
 ) -> Result<Vec<String>, ProviderError> {
     let mut argv = vec!["grok".to_string()];
     if dangerously_skip_permissions {
         argv.push("--always-approve".to_string());
     }
-    if let Some(model) = model.map(str::trim).filter(|value| !value.is_empty()) {
-        argv.push("--model".to_string());
-        argv.push(model.to_string());
-    }
+    append_opt_pair(&mut argv, "--model", model.map(str::trim).filter(|value| !value.is_empty()));
     if let Some(effort) = effort {
         // Grok accepts `--effort` as alias for `--reasoning-effort`.
         argv.push("--effort".to_string());
         argv.push(effort.as_str().to_string());
     }
-    if let Some(prompt) = system_prompt {
-        argv.push("--rules".to_string());
-        argv.push(prompt.to_string());
-    }
+    append_opt_pair(&mut argv, "--rules", system_prompt);
     // Grok CLI has no `--mcp-config` flag — the claude inline-MCP block is
     // intentionally absent. Launch writes `<cwd>/.grok/config.toml`.
-    let _ = (adapter, auth_mode, mcp_config, managed_mcp_config);
     Ok(argv)
 }

package/crates/team-agent/src/provider/adapters/pi.rs

@@ -14,6 +14,7 @@ use std::path::Path;
 
 use crate::model::enums::ProviderEffort;
 use crate::provider::ProviderError;
+use crate::provider::command_helpers::{append_opt_pair, append_pair};
 
 #[derive(Debug, Clone, Copy)]
 pub(crate) enum PiSessionSelector<'a> {
@@ -60,38 +61,27 @@ pub(crate) fn build_pi_command_argv(
         "-e".to_string(),
         request.extension.to_string_lossy().into_owned(),
     ];
-    if let Some(model) = request.model {
-        argv.push("--model".to_string());
-        argv.push(model.to_string());
-    }
+    append_opt_pair(&mut argv, "--model", request.model);
     if let Some(effort) = request.effort {
         argv.push("--thinking".to_string());
         argv.push(effort.as_str().to_string());
     }
-    argv.extend([
-        "--append-system-prompt".to_string(),
-        request.system_prompt.to_string(),
-    ]);
+    append_pair(&mut argv, "--append-system-prompt", request.system_prompt);
     if let Some(session_dir) = request.session_dir {
-        argv.extend([
-            "--session-dir".to_string(),
-            session_dir.to_string_lossy().into_owned(),
-        ]);
+        append_pair(&mut argv, "--session-dir", session_dir.to_string_lossy().into_owned());
     }
     // The shared lifecycle materializer always revalidates resume root/path/header.
     // Keep the pure argv builder usable before a fixture root is materialized, while
     // refusing a missing exact file once the recorded path's parent exists.
     match request.session {
         PiSessionSelector::Fresh { session_id } if !session_id.trim().is_empty() => {
-            argv.push("--session-id".to_string());
-            argv.push(session_id.to_string());
+            append_pair(&mut argv, "--session-id", session_id);
         }
         PiSessionSelector::Resume { path }
             if !path.as_os_str().is_empty()
                 && (!path.parent().is_some_and(Path::is_dir) || path.is_file()) =>
         {
-            argv.push("--session".to_string());
-            argv.push(path.to_string_lossy().into_owned());
+            append_pair(&mut argv, "--session", path.to_string_lossy().into_owned());
         }
         PiSessionSelector::Resume { path } if !path.as_os_str().is_empty() => {
             return Err(ProviderError::ResumeUnavailable(format!(
@@ -105,7 +95,6 @@ pub(crate) fn build_pi_command_argv(
             ));
         }
     }
-    argv.push("--name".to_string());
-    argv.push(request.agent_id.to_string());
+    append_pair(&mut argv, "--name", request.agent_id);
     Ok(argv)
 }

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

@@ -0,0 +1,45 @@
+//! Pure append operations. Callers own ordering, filtering, escaping and env-unset policy.
+use std::collections::BTreeMap;
+
+pub(crate) fn append_pair(argv: &mut Vec<String>, flag: &str, value: impl Into<String>) {
+    argv.push(flag.to_string());
+    argv.push(value.into());
+}
+
+pub(crate) fn append_opt_pair(argv: &mut Vec<String>, flag: &str, value: Option<&str>) {
+    if let Some(value) = value {
+        append_pair(argv, flag, value);
+    }
+}
+
+pub(crate) fn append_env_pair(env: &mut BTreeMap<String, String>, key: &str, value: Option<&str>) {
+    if let Some(value) = value {
+        env.insert(key.to_string(), value.to_string());
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn append_preserves_order_and_raw_values() {
+        let mut argv = vec!["cli".to_string()];
+        append_opt_pair(&mut argv, "--absent", None);
+        append_opt_pair(&mut argv, "--empty", Some(""));
+        append_pair(&mut argv, "--raw", " \"'\\\n ".to_string());
+        append_pair(&mut argv, "--repeat", "first");
+        append_pair(&mut argv, "--repeat", "last");
+        assert_eq!(argv, ["cli", "--empty", "", "--raw", " \"'\\\n ", "--repeat", "first", "--repeat", "last"]);
+    }
+
+    #[test]
+    fn env_append_preserves_absence_empty_values_and_last_write() {
+        let mut env = BTreeMap::from([("Z".to_string(), "old".to_string())]);
+        append_env_pair(&mut env, "Z", None);
+        assert_eq!(env["Z"], "old");
+        append_env_pair(&mut env, "A", Some(""));
+        append_env_pair(&mut env, "Z", Some(" \"'\\\n "));
+        assert_eq!(env.into_iter().collect::<Vec<_>>(), vec![("A".to_string(), "".to_string()), ("Z".to_string(), " \"'\\\n ".to_string())]);
+    }
+}

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

@@ -51,6 +51,7 @@ pub mod argv_route;
 /// 0.5.66 bypass 单源:provider → bypass argv flag 配置表(唯一权威)。
 pub(crate) mod bypass_flags;
 pub mod classify;
+pub(crate) mod command_helpers;
 pub mod faults;
 pub mod model_catalog;
 pub mod session;

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

@@ -9,6 +9,7 @@ use std::sync::mpsc;
 use std::time::{Duration, Instant};
 
 use crate::model::enums::Provider;
+use crate::provider::wire::{parse_canonical_provider, provider_wire};
 
 const CATALOG_TIMEOUT: Duration = Duration::from_secs(10);
 const MAX_CATALOG_BYTES: u64 = 1024 * 1024;
@@ -126,29 +127,7 @@ fn display_provider(provider: &str) -> &str {
 
 /// Only the documented catalog names are accepted; launch aliases stay unchanged.
 pub fn parse_catalog_provider(name: &str) -> Option<Provider> {
-    match name {
-        "pi" => Some(Provider::Pi),
-        "cursor_agent" => Some(Provider::CursorAgent),
-        "codex" => Some(Provider::Codex),
-        "claude" => Some(Provider::Claude),
-        "claude_code" => Some(Provider::ClaudeCode),
-        "grok" => Some(Provider::Grok),
-        _ => None,
-    }
-}
-
-fn provider_wire_name(provider: Provider) -> &'static str {
-    match provider {
-        Provider::Pi => "pi",
-        Provider::CursorAgent => "cursor_agent",
-        Provider::Codex => "codex",
-        Provider::Claude => "claude",
-        Provider::ClaudeCode => "claude_code",
-        Provider::Copilot => "copilot",
-        Provider::GeminiCli => "gemini_cli",
-        Provider::Grok => "grok",
-        Provider::Fake => "fake",
-    }
+    parse_canonical_provider(name).filter(|provider| catalog_source(*provider).is_some())
 }
 
 #[derive(Clone, Copy)]
@@ -175,7 +154,7 @@ fn catalog_source(provider: Provider) -> Option<CatalogSource> {
 pub fn discover_model_catalog(provider_name: &str) -> Result<Vec<ModelRecord>, CatalogError> {
     let provider = parse_catalog_provider(provider_name).ok_or(CatalogError::UnsupportedProvider)?;
     let source = catalog_source(provider).ok_or(CatalogError::UnsupportedProvider)?;
-    let requested_provider = provider_wire_name(provider);
+    let requested_provider = provider_wire(provider);
     let records = match source {
         CatalogSource::Pi => {
             let bytes = run_native("pi", &["--list-models"], None, None, &[], CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut NoopObserver)?;
@@ -881,10 +860,24 @@ mod tests {
 
     #[test]
     fn provider_capability_is_explicit_and_exact() {
-        assert_eq!(parse_catalog_provider("claude_code"), Some(Provider::ClaudeCode));
-        assert_eq!(parse_catalog_provider("cloud"), None);
-        assert!(catalog_source(Provider::Codex).is_some());
-        assert!(catalog_source(Provider::Fake).is_none());
+        for (name, provider) in [
+            ("pi", Provider::Pi),
+            ("cursor_agent", Provider::CursorAgent),
+            ("codex", Provider::Codex),
+            ("claude", Provider::Claude),
+            ("claude_code", Provider::ClaudeCode),
+            ("grok", Provider::Grok),
+        ] {
+            assert_eq!(parse_catalog_provider(name), Some(provider));
+            assert_eq!(provider_wire(provider), name);
+            assert!(catalog_source(provider).is_some());
+        }
+        for name in ["", "cloud", "cursor", "agent", "claude-code", "copilot", "gemini_cli", "fake", "Pi", "CODEX", " pi", "pi ", "pi/model", "codex:model", "claude_code_extra"] {
+            assert_eq!(parse_catalog_provider(name), None);
+        }
+        for provider in [Provider::Copilot, Provider::GeminiCli, Provider::Fake] {
+            assert!(catalog_source(provider).is_none());
+        }
     }
 
     #[test]

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

@@ -1,3 +1,73 @@
+#[test]
+fn trimmed_provider_builders_preserve_fresh_and_resume_argv() {
+    for (provider, base) in [
+        (
+            Provider::Grok,
+            vec!["grok", "--model", "test-model", "--rules", "role"],
+        ),
+        (
+            Provider::CursorAgent,
+            vec!["agent", "--model", "test-model", "--workspace", "{workspace}"],
+        ),
+        (
+            Provider::Copilot,
+            vec![
+                "copilot", "--no-color", "--no-auto-update", "--no-remote",
+                "--disable-builtin-mcps", "--allow-tool", "team_orchestrator",
+                "--model", "test-model",
+            ],
+        ),
+    ] {
+        let adapter = get_adapter(provider);
+        let ctx = ProviderCommandContext {
+            auth_mode: AuthMode::Subscription,
+            mcp_config: None,
+            system_prompt: Some("role"),
+            model: Some("test-model"),
+            dangerously_skip_permissions: false,
+            profile_launch: None,
+            agent_id_hint: Some("worker"),
+            effort: None,
+        };
+        let mut expected = base.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        let fresh = adapter.build_command_plan(ctx).expect("fresh plan");
+        if provider != Provider::CursorAgent {
+            expected.push("--session-id".to_string());
+            expected.push(
+                fresh.expected_session_id.as_ref().expect("session hint").as_str().to_string(),
+            );
+        } else {
+            assert!(fresh.expected_session_id.is_none());
+        }
+        assert_eq!(fresh.argv, expected, "{provider:?} fresh argv");
+        let session = SessionId::new("existing-session");
+        let mut expected = base.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+        expected.extend(["--resume".to_string(), session.as_str().to_string()]);
+        assert_eq!(
+            adapter
+                .build_resume_command_plan(Some(&session), ctx)
+                .expect("resume plan")
+                .argv,
+            expected,
+            "{provider:?} resume argv"
+        );
+        if provider == Provider::CursorAgent {
+            let mut expected = base.iter().map(|s| s.to_string()).collect::<Vec<_>>();
+            expected.insert(1, "--resume".to_string());
+            expected.insert(2, session.as_str().to_string());
+            assert_eq!(
+                adapter
+                    .build_resume_command_with_context(
+                        Some(&session), ctx.auth_mode, None, ctx.system_prompt, ctx.model, false,
+                    )
+                    .expect("legacy resume"),
+                expected,
+                "legacy Cursor resume must retain its distinct flag order"
+            );
+        }
+    }
+}
+
 #[test]
 fn abnormal_dedup_key_uses_signature_and_optional_turn_id() {
     // probe(/tmp/probe_idle.py read_fault_facts): the C8 dedup key is

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

@@ -0,0 +1,55 @@
+//! Exact argv characterization: no helper may trim, escape or reorder caller values.
+#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
+use super::*;
+use crate::model::enums::ProviderEffort;
+use crate::provider::adapters::{claude, codex, copilot, cursor_agent, grok, pi};
+use crate::provider::ProviderCommandOverrides;
+
+#[test]
+fn command_helpers_keep_provider_argv_bytes_and_order() {
+    let raw = " \"'\\\n ";
+    let mcp = McpConfig { raw: serde_json::json!({}) };
+    assert_eq!(claude::claude_base_command(
+        &BasicProviderAdapter { provider: Provider::Claude }, AuthMode::Subscription,
+        Some(&mcp), Some(raw), Some(""), false, false, Some(ProviderEffort::High),
+    ).expect("claude"), ["claude", "--permission-mode", "default", "--model", "", "--effort", "high", "--append-system-prompt", raw, "--mcp-config", "{\"mcpServers\":{}}"]);
+
+    let overrides = ProviderCommandOverrides {
+        codex_profile: Some("".to_string()),
+        codex_config: vec!["model_reasoning_effort=low".to_string()],
+        ..Default::default()
+    };
+    assert_eq!(codex::codex_base_command(
+        Some("resume"), AuthMode::Subscription, Some(&mcp), Some(raw), Some(""),
+        true, Some(&overrides), Some(ProviderEffort::Max),
+    ), ["codex", "resume", "--no-alt-screen", "--disable", "shell_snapshot", "--disable", "apps", "--profile", "", "--dangerously-bypass-approvals-and-sandbox", "--model", "", "-c", "model_reasoning_effort=low", "-c", "model_reasoning_effort=max", "-c", "developer_instructions=\" \\\"'\\\\\\n \""]);
+
+    assert_eq!(copilot::copilot_base_command(
+        AuthMode::Subscription, Some(&mcp), Some(raw), Some(""), true,
+    ), ["copilot", "--no-color", "--no-auto-update", "--no-remote", "--disable-builtin-mcps", "--allow-all", "--allow-tool", "team_orchestrator", "--model", "", "--additional-mcp-config", "{}"]);
+    assert_eq!(cursor_agent::cursor_agent_base_command(Some(raw), true).expect("cursor"),
+        ["agent", "--trust", "--sandbox", "disabled", "--force", "--model", raw, "--workspace", "{workspace}"]);
+    assert_eq!(grok::grok_base_command(Some(raw), Some("  model-id  "), true, Some(ProviderEffort::Medium)).expect("grok"),
+        ["grok", "--always-approve", "--model", "model-id", "--effort", "medium", "--rules", raw]);
+    assert_eq!(grok::grok_base_command(Some(""), Some("  "), false, None).expect("grok empty"), ["grok", "--rules", ""]);
+    assert_eq!(pi::build_pi_command_argv(pi::PiCommandRequest {
+        extension: std::path::Path::new("extension.ts"), model: Some("vendor/model"),
+        effort: Some(ProviderEffort::XHigh), system_prompt: raw,
+        session_dir: Some(std::path::Path::new("sessions")),
+        session: pi::PiSessionSelector::Fresh { session_id: "session-id" }, agent_id: "worker",
+    }).expect("pi"), ["pi", "-e", "extension.ts", "--model", "vendor/model", "--thinking", "xhigh", "--append-system-prompt", raw, "--session-dir", "sessions", "--session-id", "session-id", "--name", "worker"]);
+}
+
+#[test]
+fn command_helpers_keep_absent_options_and_safe_defaults() {
+    assert_eq!(claude::claude_base_command(
+        &BasicProviderAdapter { provider: Provider::Claude }, AuthMode::Subscription,
+        None, None, None, false, false, None,
+    ).expect("claude"), ["claude", "--permission-mode", "default"]);
+    assert_eq!(codex::codex_base_command(None, AuthMode::Subscription, None, None, None, false, None, None),
+        ["codex", "--no-alt-screen", "--disable", "shell_snapshot", "--disable", "apps"]);
+    assert_eq!(copilot::copilot_base_command(AuthMode::Subscription, None, None, None, false),
+        ["copilot", "--no-color", "--no-auto-update", "--no-remote", "--disable-builtin-mcps", "--allow-tool", "team_orchestrator"]);
+    assert_eq!(cursor_agent::cursor_agent_base_command(None, false).expect("cursor"), ["agent", "--workspace", "{workspace}"]);
+    assert_eq!(grok::grok_base_command(None, None, false, None).expect("grok"), ["grok"]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.5.112",
+  "version": "0.5.113",
   "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.112",
-    "@team-agent/cli-darwin-x64": "0.5.112",
-    "@team-agent/cli-linux-x64": "0.5.112"
+    "@team-agent/cli-darwin-arm64": "0.5.113",
+    "@team-agent/cli-darwin-x64": "0.5.113",
+    "@team-agent/cli-linux-x64": "0.5.113"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",