@team-agent/installer 0.5.106 → 0.5.108

package/crates/team-agent/src/model/yaml/tests.rs

@@ -5,9 +5,11 @@ use super::*;
 /// 把一段 YAML 文本经 `dumps(loads(t))` 往返,断言**逐字节**等于 Python golden。
 /// 这是 §4.2 双跑对该方言的字节锁:golden 由
 /// `PYTHONPATH=src python3 -c "from team_agent.simple_yaml import loads,dumps; ..."` 取得。
-fn roundtrip_eq(input: &str, golden: &str) {
-    let v = loads(input).unwrap();
-    assert_eq!(dumps(&v), golden, "roundtrip mismatch for input:\n{input}");
+fn roundtrip_eq(id: &str, input: &str, golden: &str, note: &str) {
+    let parsed = loads(input);
+    assert!(parsed.is_ok(), "case={id}; {note}; parse failed: {parsed:?}");
+    let v = parsed.unwrap();
+    assert_eq!(dumps(&v), golden, "case={id}; {note}; roundtrip mismatch for input:\n{input}");
 }
 
 // === 真实语料:examples/team.spec.yaml 的 dumps(loads(t)) golden(逐字节) ===
@@ -41,168 +43,47 @@ fn rich_edge_fixture_roundtrip_matches_python_golden() {
     assert_eq!(dumps(&v), golden);
 }
 
-// === SKILL.md front-matter 块(`---` 之间那段)的 loads/dumps ===
-#[test]
-fn skill_front_matter_roundtrip() {
-    // 取自 skills/team-agent/SKILL.md 的 front matter。
-    let input = "name: team-agent\ndescription: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\n";
-    let golden = "name: \"team-agent\"\ndescription: \"Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\"\n";
-    roundtrip_eq(input, golden);
-}
-
-// === 方言怪癖逐一对拍(每个 golden 来自 Python 真相源)===
-
-#[test]
-fn block_scalar_basic() {
-    roundtrip_eq(
-        "msg: |\n  line one\n  line two\n",
-        "msg: |\n  line one\n  line two\n",
-    );
-}
-
-#[test]
-fn block_scalar_blank_line_becomes_padded() {
-    // 空行在 dumps 时产生仅含 pad 的行(尾随空格)—— Python 行为,必须复刻。
-    roundtrip_eq("msg: |\n  a\n\n  b\n", "msg: |\n  a\n  \n  b\n");
-}
-
-#[test]
-fn inline_unquoted_list_stays_string() {
-    // ast.literal_eval('[a, b, c]') 失败 → 原样字符串。
-    roundtrip_eq("tools: [a, b, c]\n", "tools: \"[a, b, c]\"\n");
-}
-
-#[test]
-fn inline_quoted_list_becomes_list() {
-    roundtrip_eq("x: ['a', 'b']\n", "x:\n  - \"a\"\n  - \"b\"\n");
-}
-
-#[test]
-fn ints_canonicalize() {
-    // 007 -> 7,-5 保号。
-    roundtrip_eq("a: 1\nb: -5\nc: 007\n", "a: 1\nb: -5\nc: 7\n");
-}
-
-#[test]
-fn int_plus_and_underscore() {
-    roundtrip_eq("a: +3\nb: 1_000\n", "a: 3\nb: 1000\n");
-}
-
-#[test]
-fn non_ints_stay_strings() {
-    roundtrip_eq(
-        "a: 1.5\nb: 0x1f\nc: 1e3\nd: _1\n",
-        "a: \"1.5\"\nb: \"0x1f\"\nc: \"1e3\"\nd: \"_1\"\n",
-    );
-}
-
-#[test]
-fn bools_and_nulls() {
-    roundtrip_eq(
-        "a: true\nb: False\nc: NULL\nd: ~\n",
-        "a: true\nb: false\nc: null\nd: null\n",
-    );
-}
-
-#[test]
-fn empty_collections() {
-    roundtrip_eq("a: {}\nb: []\n", "a: {}\nb: []\n");
-}
-
-#[test]
-fn quoted_strings_unwrap() {
-    roundtrip_eq("a: \"hello\"\nb: 'world'\n", "a: \"hello\"\nb: \"world\"\n");
-}
-
-#[test]
-fn nested_map() {
-    roundtrip_eq("a:\n  b:\n    c: 1\n", "a:\n  b:\n    c: 1\n");
-}
-
-#[test]
-fn list_of_maps() {
-    roundtrip_eq(
-        "items:\n  - id: x\n    val: 1\n  - id: y\n    val: 2\n",
-        "items:\n  - id: \"x\"\n    val: 1\n  - id: \"y\"\n    val: 2\n",
-    );
-}
-
-#[test]
-fn scalar_list_mixed() {
-    roundtrip_eq(
-        "a:\n  - 1\n  - two\n  - true\n",
-        "a:\n  - 1\n  - \"two\"\n  - true\n",
-    );
-}
-
-#[test]
-fn empty_value_is_null() {
-    roundtrip_eq("a:\nb: 2\n", "a: null\nb: 2\n");
-}
-
-#[test]
-fn inline_comment_not_stripped() {
-    // 整行注释被跳过;行内 `#` 不被当注释,留在值里。
-    roundtrip_eq(
-        "# top\na: 1  # inline?\nb: 2\n",
-        "a: \"1  # inline?\"\nb: 2\n",
-    );
-}
-
-#[test]
-fn key_no_space_after_colon() {
-    roundtrip_eq("a:1\n", "a: 1\n");
-}
-
-#[test]
-fn special_chars_json_escaped() {
-    roundtrip_eq("a: he said \"hi\"\n", "a: \"he said \\\"hi\\\"\"\n");
-}
-
-#[test]
-fn unicode_preserved() {
-    roundtrip_eq("name: café ☕\n", "name: \"café ☕\"\n");
-}
-
-#[test]
-fn list_item_value_has_colon_and_space() {
-    // foo: bar baz —— item_text 看起来是 key-value(key=foo 合法),value = "bar baz"。
-    roundtrip_eq("a:\n  - foo: bar baz\n", "a:\n  - foo: \"bar baz\"\n");
-}
-
-// === JSON 顶层路径(`{`/`[` 开头 → json.loads,保留键序)===
-
-#[test]
-fn json_object_path_preserves_key_order() {
-    roundtrip_eq("{\"a\": 1, \"b\": [1,2]}", "a: 1\nb:\n  - 1\n  - 2\n");
-}
-
-#[test]
-fn json_array_path() {
-    roundtrip_eq("[1, 2, 3]", "- 1\n- 2\n- 3\n");
-}
-
-#[test]
-fn json_leading_whitespace() {
-    roundtrip_eq("   {\"a\": 1}", "a: 1\n");
-}
-
-#[test]
-fn json_float_becomes_quoted_string() {
-    // json.loads -> float 1.5; dumps -> json.dumps(str(1.5)) = "1.5"。
-    roundtrip_eq("{\"a\": 1.5}", "a: \"1.5\"\n");
-}
-
-#[test]
-fn json_string_with_newline_becomes_block_scalar() {
-    roundtrip_eq("{\"x\": \"with\\nnewline\"}", "x: |\n  with\n  newline\n");
-}
-
-#[test]
-fn json_empty_object_and_array_top_level() {
-    // 顶层 {} / [] → _dump 返回空 → "\n"。
-    roundtrip_eq("{}", "\n");
-    roundtrip_eq("[]", "\n");
+// === SKILL front matter、方言怪癖与 JSON 顶层路径:逐字节锁定 Python golden ===
+#[test]
+fn python_golden_roundtrip_cases() {
+    // (旧函数 id, input, golden, Python 语义说明)。26 个旧测试包含 27 次往返。
+    let cases = [
+        (
+            "skill_front_matter_roundtrip",
+            "name: team-agent\ndescription: Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\n",
+            "name: \"team-agent\"\ndescription: \"Use only when the user explicitly asks to start, operate, inspect, shutdown, or restart a Team Agent team. Treat the team-agent CLI as a sealed appliance.\"\n",
+            "取自 skills/team-agent/SKILL.md 的 front matter。SKILL.md front-matter 块(`---` 之间那段)。",
+        ),
+        ("block_scalar_basic", "msg: |\n  line one\n  line two\n", "msg: |\n  line one\n  line two\n", ""),
+        ("block_scalar_blank_line_becomes_padded", "msg: |\n  a\n\n  b\n", "msg: |\n  a\n  \n  b\n", "空行在 dumps 时产生仅含 pad 的行(尾随空格)—— Python 行为,必须复刻。"),
+        ("inline_unquoted_list_stays_string", "tools: [a, b, c]\n", "tools: \"[a, b, c]\"\n", "ast.literal_eval('[a, b, c]') 失败 → 原样字符串。"),
+        ("inline_quoted_list_becomes_list", "x: ['a', 'b']\n", "x:\n  - \"a\"\n  - \"b\"\n", ""),
+        ("ints_canonicalize", "a: 1\nb: -5\nc: 007\n", "a: 1\nb: -5\nc: 7\n", "007 -> 7,-5 保号。"),
+        ("int_plus_and_underscore", "a: +3\nb: 1_000\n", "a: 3\nb: 1000\n", ""),
+        ("non_ints_stay_strings", "a: 1.5\nb: 0x1f\nc: 1e3\nd: _1\n", "a: \"1.5\"\nb: \"0x1f\"\nc: \"1e3\"\nd: \"_1\"\n", ""),
+        ("bools_and_nulls", "a: true\nb: False\nc: NULL\nd: ~\n", "a: true\nb: false\nc: null\nd: null\n", ""),
+        ("empty_collections", "a: {}\nb: []\n", "a: {}\nb: []\n", ""),
+        ("quoted_strings_unwrap", "a: \"hello\"\nb: 'world'\n", "a: \"hello\"\nb: \"world\"\n", ""),
+        ("nested_map", "a:\n  b:\n    c: 1\n", "a:\n  b:\n    c: 1\n", ""),
+        ("list_of_maps", "items:\n  - id: x\n    val: 1\n  - id: y\n    val: 2\n", "items:\n  - id: \"x\"\n    val: 1\n  - id: \"y\"\n    val: 2\n", ""),
+        ("scalar_list_mixed", "a:\n  - 1\n  - two\n  - true\n", "a:\n  - 1\n  - \"two\"\n  - true\n", ""),
+        ("empty_value_is_null", "a:\nb: 2\n", "a: null\nb: 2\n", ""),
+        ("inline_comment_not_stripped", "# top\na: 1  # inline?\nb: 2\n", "a: \"1  # inline?\"\nb: 2\n", "整行注释被跳过;行内 `#` 不被当注释,留在值里。"),
+        ("key_no_space_after_colon", "a:1\n", "a: 1\n", ""),
+        ("special_chars_json_escaped", "a: he said \"hi\"\n", "a: \"he said \\\"hi\\\"\"\n", ""),
+        ("unicode_preserved", "name: café ☕\n", "name: \"café ☕\"\n", ""),
+        ("list_item_value_has_colon_and_space", "a:\n  - foo: bar baz\n", "a:\n  - foo: \"bar baz\"\n", "foo: bar baz —— item_text 看起来是 key-value(key=foo 合法),value = \"bar baz\"。"),
+        ("json_object_path_preserves_key_order", "{\"a\": 1, \"b\": [1,2]}", "a: 1\nb:\n  - 1\n  - 2\n", "JSON 顶层路径保留键序。"),
+        ("json_array_path", "[1, 2, 3]", "- 1\n- 2\n- 3\n", ""),
+        ("json_leading_whitespace", "   {\"a\": 1}", "a: 1\n", ""),
+        ("json_float_becomes_quoted_string", "{\"a\": 1.5}", "a: \"1.5\"\n", "json.loads -> float 1.5; dumps -> json.dumps(str(1.5)) = \"1.5\"。"),
+        ("json_string_with_newline_becomes_block_scalar", "{\"x\": \"with\\nnewline\"}", "x: |\n  with\n  newline\n", ""),
+        ("json_empty_object_and_array_top_level", "{}", "\n", "顶层 {} / [] → _dump 返回空 → \"\\n\"。"),
+        ("json_empty_object_and_array_top_level", "[]", "\n", "顶层 {} / [] → _dump 返回空 → \"\\n\"。"),
+    ];
+    for (id, input, golden, note) in cases {
+        roundtrip_eq(id, input, golden, note);
+    }
 }
 
 // === dumps-only 结构(直接构造 Value,golden 来自 Python dumps)===

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

@@ -80,10 +80,11 @@ impl CatalogError {
             "cursor_agent" => "agent",
             "codex" => "codex",
             "claude" | "claude_code" => "claude",
+            "grok" => "grok",
             _ => "provider CLI",
         };
         match self {
-            Self::UnsupportedProvider => "choose a supported provider: pi, cursor_agent, codex, claude, or claude_code".into(),
+            Self::UnsupportedProvider => "choose a supported provider: pi, cursor_agent, codex, claude, claude_code, or grok".into(),
             Self::ExecutableUnavailable => format!("install or repair the PATH-first `{executable}` executable, then retry `team-agent models --provider {provider}`"),
             Self::UnsupportedSchema => format!("upgrade `{executable}` to a version that supports its model catalog protocol, then retry `team-agent models --provider {provider}`"),
             Self::CommandFailed => format!("run `{executable}` directly to check catalog/account access, then retry `team-agent models --provider {provider}`"),
@@ -118,6 +119,7 @@ fn display_provider(provider: &str) -> &str {
         "cursor_agent" => "Cursor",
         "codex" => "Codex",
         "claude" | "claude_code" => "Claude",
+        "grok" => "Grok",
         _ => provider,
     }
 }
@@ -130,6 +132,7 @@ pub fn parse_catalog_provider(name: &str) -> Option<Provider> {
         "codex" => Some(Provider::Codex),
         "claude" => Some(Provider::Claude),
         "claude_code" => Some(Provider::ClaudeCode),
+        "grok" => Some(Provider::Grok),
         _ => None,
     }
 }
@@ -153,6 +156,7 @@ enum CatalogSource {
     Pi,
     CursorAgent,
     Codex,
+    Grok,
     Claude,
 }
 
@@ -163,7 +167,8 @@ fn catalog_source(provider: Provider) -> Option<CatalogSource> {
         Provider::CursorAgent => Some(CatalogSource::CursorAgent),
         Provider::Codex => Some(CatalogSource::Codex),
         Provider::Claude | Provider::ClaudeCode => Some(CatalogSource::Claude),
-        Provider::Copilot | Provider::GeminiCli | Provider::Grok | Provider::Fake => None,
+        Provider::Grok => Some(CatalogSource::Grok),
+        Provider::Copilot | Provider::GeminiCli | Provider::Fake => None,
     }
 }
 
@@ -184,6 +189,10 @@ pub fn discover_model_catalog(provider_name: &str) -> Result<Vec<ModelRecord>, C
             let bytes = run_native("codex", &["debug", "models"], None, None, &[], CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut NoopObserver)?;
             parse_codex_catalog(&bytes, requested_provider)?
         }
+        CatalogSource::Grok => {
+            let bytes = run_native("grok", &["models"], None, None, &[], CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut NoopObserver)?;
+            parse_grok_catalog(&bytes)?
+        }
         CatalogSource::Claude => discover_claude_catalog(requested_provider)?,
     };
     Ok(records)
@@ -242,8 +251,20 @@ pub(crate) fn parse_pi_catalog(bytes: &[u8]) -> Result<Vec<ModelRecord>, Catalog
 
 pub(crate) fn parse_cursor_catalog(bytes: &[u8]) -> Result<Vec<ModelRecord>, CatalogError> {
     let text = std::str::from_utf8(bytes).map_err(|_| CatalogError::InvalidUtf8)?;
+    let lines = text.lines().collect::<Vec<_>>();
+    let tip_line = lines
+        .iter()
+        .rposition(|line| !line.trim().is_empty())
+        .filter(|index| {
+            lines[*index]
+                .strip_prefix("Tip: use --model ")
+                .is_some_and(|tip| !tip.is_empty())
+        });
     let mut records: Vec<ModelRecord> = Vec::new();
-    for line in text.lines() {
+    for (index, line) in lines.into_iter().enumerate() {
+        if Some(index) == tip_line {
+            continue;
+        }
         let line = line.trim();
         if line.is_empty() || line.trim_end_matches(':').eq_ignore_ascii_case("available models") { continue; }
         let Some((id, display)) = line.split_once(" - ") else { return Err(CatalogError::Malformed); };
@@ -260,6 +281,117 @@ pub(crate) fn parse_cursor_catalog(bytes: &[u8]) -> Result<Vec<ModelRecord>, Cat
     Ok(records)
 }
 
+fn parse_grok_catalog(bytes: &[u8]) -> Result<Vec<ModelRecord>, CatalogError> {
+    let text = std::str::from_utf8(bytes).map_err(|_| CatalogError::InvalidUtf8)?;
+    let mut has_auth_notice = false;
+    let mut has_models_header = false;
+    let mut declared_default: Option<String> = None;
+    let mut starred_default: Option<String> = None;
+    let mut marked_default: Option<String> = None;
+    let mut seen = HashSet::new();
+    let mut records = Vec::new();
+
+    for line in text.lines() {
+        let line = line.trim();
+        if line.is_empty() {
+            continue;
+        }
+        if !has_models_header {
+            if matches!(line, "You are logged in with grok.com." | "You are not authenticated.") {
+                if has_auth_notice {
+                    return Err(CatalogError::Malformed);
+                }
+                has_auth_notice = true;
+                continue;
+            }
+            if let Some(id) = line.strip_prefix("Default model: ") {
+                if declared_default.is_some() || id.is_empty() {
+                    return Err(CatalogError::Malformed);
+                }
+                validate_identity(id)?;
+                declared_default = Some(id.to_string());
+                continue;
+            }
+            if line == "Available models:" {
+                has_models_header = true;
+                continue;
+            }
+            return Err(CatalogError::Malformed);
+        }
+
+        let (is_starred, row) = if let Some(row) = line.strip_prefix("- ") {
+            (false, row)
+        } else if let Some(row) = line.strip_prefix("* ") {
+            (true, row)
+        } else {
+            return Err(CatalogError::Malformed);
+        };
+        if row == "(default)" {
+            return Err(CatalogError::Malformed);
+        }
+        let (id, has_default_marker) = row
+            .strip_suffix(" (default)")
+            .map_or((row, false), |id| (id, true));
+        if id.is_empty() {
+            return Err(CatalogError::Malformed);
+        }
+        validate_identity(id)?;
+        if !seen.insert(id.to_string()) {
+            return Err(CatalogError::DuplicateIdentity(id.to_string()));
+        }
+        if is_starred {
+            if starred_default.as_deref().is_some_and(|current| current != id) {
+                return Err(CatalogError::Malformed);
+            }
+            starred_default = Some(id.to_string());
+        }
+        if has_default_marker {
+            if marked_default.as_deref().is_some_and(|current| current != id) {
+                return Err(CatalogError::Malformed);
+            }
+            marked_default = Some(id.to_string());
+        }
+        records.push(ModelRecord {
+            provider: "grok".into(),
+            vendor: "xai".into(),
+            id: id.into(),
+            display_name: id.into(),
+            default: None,
+            aliases: Vec::new(),
+        });
+    }
+    if !has_models_header {
+        return Err(CatalogError::Malformed);
+    }
+    if records.is_empty() {
+        return Err(CatalogError::Empty);
+    }
+
+    let mut default_id: Option<&str> = None;
+    for candidate in [
+        declared_default.as_deref(),
+        starred_default.as_deref(),
+        marked_default.as_deref(),
+    ]
+    .into_iter()
+    .flatten()
+    {
+        if default_id.is_some_and(|current| current != candidate) {
+            return Err(CatalogError::Malformed);
+        }
+        default_id = Some(candidate);
+    }
+    if let Some(default_id) = default_id {
+        if !seen.contains(default_id) {
+            return Err(CatalogError::Malformed);
+        }
+        for record in &mut records {
+            record.default = Some(record.id.as_str() == default_id);
+        }
+    }
+    Ok(records)
+}
+
 fn parse_codex_catalog(bytes: &[u8], provider: &str) -> Result<Vec<ModelRecord>, CatalogError> {
     let value: serde_json::Value = serde_json::from_slice(bytes).map_err(|_| CatalogError::Malformed)?;
     let rows = value.get("models").and_then(serde_json::Value::as_array).ok_or(CatalogError::UnsupportedSchema)?;
@@ -647,4 +779,35 @@ mod tests {
         assert!(!model_matches(&row, "LUNA absent"));
         assert!(model_matches(&row, "  "));
     }
+
+    #[test]
+    fn frozen_cursor_catalog_skips_only_its_native_trailing_tip() {
+        let frozen = include_bytes!("testdata/cursor-list-models-native.stdout");
+        let records = parse_cursor_catalog(frozen).unwrap();
+        let low = records.iter().find(|row| row.id == "gpt-5.6-luna-low").unwrap();
+        assert_eq!(low.provider.as_str(), "cursor_agent");
+        assert_eq!(low.vendor.as_str(), "gpt");
+        assert_eq!(low.display_name, "GPT-5.6 Luna 1M Low (current)");
+        assert_eq!(low.default, Some(false));
+        assert!(low.aliases.is_empty());
+        let xhigh = records.iter().find(|row| row.id == "gpt-5.6-luna-xhigh").unwrap();
+        assert_eq!(xhigh.id.as_str(), "gpt-5.6-luna-xhigh");
+        assert_eq!(xhigh.display_name, "GPT-5.6 Luna 1M Extra High");
+        let auto = records.iter().find(|row| row.id == "auto").unwrap();
+        assert_eq!(auto.default, Some(true));
+
+        let text = std::str::from_utf8(frozen).unwrap();
+        let without_tip = text.split_once("\nTip: use --model ").unwrap().0;
+        assert_eq!(parse_cursor_catalog(without_tip.as_bytes()).unwrap(), parse_cursor_catalog(frozen).unwrap());
+    }
+
+    #[test]
+    fn cursor_tip_compatibility_keeps_fail_closed_row_validation() {
+        let duplicate = b"Available models\na - A\na - A\n";
+        assert!(matches!(parse_cursor_catalog(duplicate), Err(CatalogError::DuplicateIdentity(_))));
+        assert!(matches!(parse_cursor_catalog(b"Available models\n"), Err(CatalogError::Empty)));
+        assert!(matches!(parse_cursor_catalog(&[b'A', 0xff]), Err(CatalogError::InvalidUtf8)));
+        assert!(matches!(parse_cursor_catalog(b"Available models\na - A\nnot a model row\n"), Err(CatalogError::Malformed)));
+        assert!(matches!(parse_cursor_catalog(b"Available models\na - A\nTip: use --model a to switch.\nunexpected tail\n"), Err(CatalogError::Malformed)));
+    }
 }