@team-agent/installer 0.5.107 → 0.5.109

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)?;
@@ -457,15 +589,18 @@ pub(crate) fn run_command(
         Some((writer, rx))
     } else { None };
     let mut output = None;
+    let mut pending_output = None;
+    let mut output_ready_at: Option<Instant> = None;
     let mut too_large_at = None;
     let status = loop {
-        match reader_rx.try_recv() {
+        match pending_output.take().map_or_else(|| reader_rx.try_recv(), Ok) {
             Ok(Ok(bytes)) => {
                 if bytes.len() as u64 > max_bytes {
                     too_large_at.get_or_insert_with(Instant::now);
                 } else {
                     output = Some(bytes);
                 }
+                output_ready_at = Some(Instant::now());
             }
             Ok(Err(_)) => { terminate(&mut child, pid); return Err(CatalogError::OutputReadFailed); }
             Err(mpsc::TryRecvError::Disconnected) if output.is_none() && too_large_at.is_none() => { terminate(&mut child, pid); return Err(CatalogError::OutputReadFailed); }
@@ -482,7 +617,24 @@ pub(crate) fn run_command(
                 terminate(&mut child, pid);
                 return Err(CatalogError::OutputTooLarge);
             }
-            Ok(None) if started.elapsed() < timeout => std::thread::sleep(Duration::from_millis(10)),
+            Ok(None) if started.elapsed() < timeout => {
+                let mut wait = timeout.saturating_sub(started.elapsed()).min(Duration::from_millis(10));
+                if let Some(over_at) = too_large_at {
+                    wait = wait.min(Duration::from_millis(100).saturating_sub(over_at.elapsed()));
+                }
+                if output.is_none() && too_large_at.is_none() {
+                    // Reader completion wakes us instead of trailing a blind 10ms sleep.
+                    if let Ok(result) = reader_rx.recv_timeout(wait) {
+                        pending_output = Some(result);
+                    }
+                } else {
+                    // stdout can close before exit; never busy-poll a disconnected channel.
+                    let interval = output_ready_at.map_or(Duration::from_millis(10), |at| {
+                        catalog_exit_poll_interval(at.elapsed())
+                    });
+                    std::thread::sleep(wait.min(interval));
+                }
+            }
             Ok(None) if too_large_at.is_some() => { terminate(&mut child, pid); return Err(CatalogError::OutputTooLarge); }
             Ok(None) => { terminate(&mut child, pid); return Err(CatalogError::Timeout); }
             Err(_) => { terminate(&mut child, pid); return Err(CatalogError::CommandCouldNotBeObserved); }
@@ -510,6 +662,16 @@ pub(crate) fn run_command(
     output.ok_or(CatalogError::OutputReadFailed)
 }
 
+fn catalog_exit_poll_interval(elapsed: Duration) -> Duration {
+    [1, 3, 6, 10]
+        .into_iter()
+        .map(Duration::from_millis)
+        .find(|checkpoint| *checkpoint > elapsed)
+        .map_or(Duration::from_millis(10), |checkpoint| {
+            checkpoint.saturating_sub(elapsed)
+        })
+}
+
 fn terminate(child: &mut Child, pid: u32) {
     #[cfg(unix)]
     unsafe {
@@ -568,6 +730,151 @@ impl Drop for OwnedTempDir {
     fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); }
 }
 
+#[cfg(all(test, unix))]
+mod command_wait_regressions {
+    use super::*;
+
+    #[derive(Default)]
+    struct Observer {
+        pid: Option<u32>,
+        exits: Vec<Option<i32>>,
+        output_timeouts: usize,
+    }
+
+    impl CatalogObserver for Observer {
+        fn spawned(&mut self, pid: u32) { self.pid = Some(pid); }
+        fn exited(&mut self, status: &ExitStatus) { self.exits.push(status.code()); }
+        fn output_timeout(&mut self) { self.output_timeouts += 1; }
+    }
+
+    fn run(
+        script: &str,
+        input: Option<&[u8]>,
+        timeout: Duration,
+        max_bytes: u64,
+        observer: &mut Observer,
+    ) -> Result<Vec<u8>, CatalogError> {
+        run_command(
+            Path::new("/bin/sh"), &["-c", script], input, None, &[], &[],
+            timeout, max_bytes, observer,
+        )
+    }
+
+    fn assert_owned_child_gone(observer: &Observer) {
+        let pid = observer.pid.unwrap();
+        assert!(pid > 1);
+        let status = Command::new("/bin/kill")
+            .args(["-0", &pid.to_string()])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .status()
+            .unwrap();
+        assert!(!status.success(), "owned child must be reaped");
+    }
+
+    #[test]
+    fn eof_and_success_preserve_input_and_raw_output() {
+        let mut observer = Observer::default();
+        let input = b"catalog\0\xff\n";
+        let output = run(
+            "exec /bin/cat", Some(input), CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap();
+        assert_eq!(output, input.to_vec());
+        assert_eq!(observer.exits, vec![Some(0)]);
+        assert_eq!(observer.output_timeouts, 0);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn stdout_eof_does_not_hide_a_later_nonzero_exit() {
+        let mut observer = Observer::default();
+        let error = run(
+            "printf 'partial'; exec 1>&-; /bin/sleep 0.03; exit 17",
+            None, CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap_err();
+        assert_eq!(error, CatalogError::CommandFailed);
+        assert_eq!(observer.exits, vec![Some(17)]);
+        assert_eq!(observer.output_timeouts, 0);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn stdout_eof_does_not_disable_the_ten_second_process_timeout() {
+        let mut observer = Observer::default();
+        let started = Instant::now();
+        let error = run(
+            "exec 1>&-; exec /bin/sleep 30", None, CATALOG_TIMEOUT,
+            MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap_err();
+        let elapsed = started.elapsed();
+        assert_eq!(CATALOG_TIMEOUT, Duration::from_secs(10));
+        assert_eq!(error, CatalogError::Timeout);
+        assert!(elapsed >= CATALOG_TIMEOUT);
+        assert!(elapsed < CATALOG_TIMEOUT + Duration::from_secs(2));
+        assert!(observer.exits.is_empty());
+        assert_eq!(observer.output_timeouts, 0);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn exact_one_mib_is_allowed_and_one_more_byte_is_rejected() {
+        assert_eq!(MAX_CATALOG_BYTES, 1024 * 1024);
+        let mut observer = Observer::default();
+        let script = format!("exec /usr/bin/head -c {MAX_CATALOG_BYTES} /dev/zero");
+        let output = run(
+            &script, None, CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap();
+        assert_eq!(output.len() as u64, MAX_CATALOG_BYTES);
+        assert_owned_child_gone(&observer);
+        let mut observer = Observer::default();
+        let script = format!("exec /usr/bin/head -c {} /dev/zero", MAX_CATALOG_BYTES + 1);
+        assert_eq!(
+            run(&script, None, CATALOG_TIMEOUT, MAX_CATALOG_BYTES, &mut observer),
+            Err(CatalogError::OutputTooLarge)
+        );
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn oversized_output_keeps_one_hundred_millisecond_exit_grace() {
+        let mut observer = Observer::default();
+        let started = Instant::now();
+        let error = run(
+            "printf '%65s' x; exec /bin/sleep 30", None, CATALOG_TIMEOUT, 64, &mut observer,
+        ).unwrap_err();
+        assert_eq!(error, CatalogError::OutputTooLarge);
+        assert!(started.elapsed() >= Duration::from_millis(100));
+        assert!(started.elapsed() < Duration::from_secs(2));
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn exited_child_with_inherited_stdout_keeps_output_timeout_observation() {
+        let mut observer = Observer::default();
+        let error = run(
+            "/bin/sleep 30 & exit 0", None, Duration::from_millis(200),
+            MAX_CATALOG_BYTES, &mut observer,
+        ).unwrap_err();
+        assert_eq!(error, CatalogError::Timeout);
+        assert_eq!(observer.exits, vec![Some(0)]);
+        assert_eq!(observer.output_timeouts, 1);
+        assert_owned_child_gone(&observer);
+    }
+
+    #[test]
+    fn early_eof_polling_keeps_ten_millisecond_anchor_and_then_old_cadence() {
+        let mut elapsed = Duration::ZERO;
+        for (sleep_ms, check_ms) in [(1, 1), (2, 3), (3, 6), (4, 10), (10, 20)] {
+            let interval = catalog_exit_poll_interval(elapsed);
+            assert_eq!(interval, Duration::from_millis(sleep_ms));
+            elapsed += interval;
+            assert_eq!(elapsed, Duration::from_millis(check_ms));
+        }
+        assert_eq!(catalog_exit_poll_interval(Duration::from_micros(9500)), Duration::from_micros(500));
+        assert_eq!(catalog_exit_poll_interval(Duration::from_millis(50)), Duration::from_millis(10));
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -647,4 +954,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)));
+    }
 }