@team-agent/installer 0.3.1 → 0.3.3

package/crates/team-agent/src/provider/approvals/runtime_prompts.rs

@@ -88,13 +88,7 @@ pub fn awaiting_human_confirm_reason(
                 None
             }
         }
-        ApprovalKind::Command => {
-            if leader_auto_approval_allowed {
-                None
-            } else {
-                Some("leader_restricted")
-            }
-        }
+        ApprovalKind::Command => Some("command_approval_requires_human"),
         ApprovalKind::Unknown => Some("approval_requires_human"),
     }
 }

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

@@ -229,7 +229,11 @@ fn decide_state(fact: &LifecycleFact, process: ProcessLiveness) -> ClassifyResul
             ProcessLiveness::Alive => classify_result(
                 TurnState::Working,
                 fact.turn_id.clone(),
-                "open_turn",
+                if fact.reason == "assistant_in_flight" {
+                    &fact.reason
+                } else {
+                    "open_turn"
+                },
                 ClassifySource::SessionFile,
                 Vec::new(),
             ),
@@ -281,12 +285,55 @@ fn decide_state(fact: &LifecycleFact, process: ProcessLiveness) -> ClassifyResul
 
 fn claude_lifecycle_fact(record: &serde_json::Value) -> Option<LifecycleFact> {
     let record_type = record.get("type").and_then(serde_json::Value::as_str);
+    if record_type == Some("system")
+        && record.get("subtype").and_then(serde_json::Value::as_str) == Some("api_error")
+        && record.get("level").and_then(serde_json::Value::as_str) == Some("error")
+    {
+        return Some(lifecycle(
+            FactKind::Error,
+            record
+                .get("sessionId")
+                .or_else(|| record.get("parentUuid"))
+                .or_else(|| record.get("uuid"))
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new),
+            "api_error",
+            vec!["api_error".to_string()],
+        ));
+    }
+    if record_type == Some("user") && claude_record_has_error_tool_result(record) {
+        return Some(lifecycle(
+            FactKind::Error,
+            record
+                .get("parentUuid")
+                .or_else(|| record.get("uuid"))
+                .and_then(serde_json::Value::as_str)
+                .map(TurnId::new),
+            "tool_result_is_error",
+            vec!["tool_result_is_error".to_string()],
+        ));
+    }
     if record_type == Some("assistant") {
-        let stop_reason = record
+        let turn_id = record.get("requestId").and_then(serde_json::Value::as_str).map(TurnId::new);
+        let Some(stop_reason) = record
             .get("message")
             .and_then(|m| m.get("stop_reason"))
-            .and_then(serde_json::Value::as_str)?;
-        let turn_id = record.get("requestId").and_then(serde_json::Value::as_str).map(TurnId::new);
+            .and_then(serde_json::Value::as_str) else {
+                if record
+                    .get("message")
+                    .and_then(|m| m.get("content"))
+                    .and_then(serde_json::Value::as_array)
+                    .is_some()
+                {
+                    return Some(lifecycle(
+                        FactKind::TurnOpen,
+                        turn_id,
+                        "assistant_in_flight",
+                        vec!["assistant_in_flight".to_string()],
+                    ));
+                }
+                return None;
+            };
         return match stop_reason {
             "tool_use" => Some(lifecycle(FactKind::TurnOpen, turn_id, "open_turn", Vec::new())),
             "end_turn" => Some(lifecycle(FactKind::TurnComplete, turn_id, "end_turn", Vec::new())),

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

@@ -22,9 +22,18 @@ pub(crate) fn find_session_id(record: &serde_json::Value) -> Option<String> {
     if let Some(s) = record.get("sessionId").and_then(serde_json::Value::as_str) {
         return Some(s.to_string());
     }
-    record
+    if let Some(s) = record
         .get("session_id")
         .and_then(serde_json::Value::as_str)
+    {
+        return Some(s.to_string());
+    }
+    record
+        .get("session_meta")
+        .and_then(|v| v.get("payload"))
+        .or_else(|| record.get("payload"))
+        .and_then(|v| v.get("id"))
+        .and_then(serde_json::Value::as_str)
         .map(ToString::to_string)
 }
 

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

@@ -20,6 +20,14 @@ const TRUST_MARKERS: &[&str] = &[
     "Do you trust this folder?",
 ];
 const UPDATE_MARKERS: &[&str] = &["Update available!", "Update now"];
+const CLAUDE_TRUST_MARKERS: &[&str] = &[
+    "Quick safety check",
+    "Is this a project you created or one you trust?",
+    "Yes, I trust this folder",
+    "No, exit",
+    "Enter to confirm",
+];
+const CLAUDE_READY_MARKERS: &[&str] = &["Claude Code"];
 /// Plain ready markers (not the bare `›` glyph — that glyph also indicates a
 /// numbered-menu selector and is handled by [`rightmost_input_prompt_glyph`] with
 /// shape gating per N15 / CR-063: detect by SHAPE, not a single Unicode codepoint).
@@ -87,6 +95,17 @@ pub fn classify_codex_startup_screen(output: &str) -> StartupScreenDecision {
     }
 }
 
+pub fn classify_claude_startup_screen(output: &str) -> StartupScreenDecision {
+    if has_active_claude_yes_trust_shape(output) {
+        return StartupScreenDecision::AnswerWorkspaceTrust;
+    }
+    if has_claude_ready_shape(output) {
+        StartupScreenDecision::Ready
+    } else {
+        StartupScreenDecision::KeepPolling
+    }
+}
+
 /// Actionable trust shape (N15): the captured text contains a trust phrase AND a
 /// numbered-menu selector line `› <digit>. `. This is the modal-still-active signal
 /// that survives Codex's pre-rendering of the banner/input prompt below the menu.
@@ -121,6 +140,51 @@ fn contains_numbered_menu_glyph(output: &str) -> bool {
     false
 }
 
+fn has_active_claude_yes_trust_shape(output: &str) -> bool {
+    if !CLAUDE_TRUST_MARKERS
+        .iter()
+        .all(|marker| output.contains(marker))
+    {
+        return false;
+    }
+    output
+        .lines()
+        .map(str::trim_start)
+        .any(|line| {
+            line == "❯ 1. Yes, I trust this folder"
+                || line == "> 1. Yes, I trust this folder"
+        })
+}
+
+fn has_claude_ready_shape(output: &str) -> bool {
+    max_rfind(output, CLAUDE_READY_MARKERS).is_some()
+        && rightmost_claude_input_prompt_glyph(output).is_some()
+}
+
+fn rightmost_claude_input_prompt_glyph(output: &str) -> Option<usize> {
+    let mut best = rightmost_input_prompt_for_glyph(output, '❯');
+    best = max_two(best, rightmost_input_prompt_for_glyph(output, '>'));
+    best
+}
+
+fn rightmost_input_prompt_for_glyph(output: &str, glyph: char) -> Option<usize> {
+    let glyph_len = glyph.len_utf8();
+    let mut best = None;
+    let mut start = 0;
+    while let Some(rel) = output[start..].find(glyph) {
+        let abs = start + rel;
+        let tail_start = abs + glyph_len;
+        if tail_start <= output.len() && !is_numbered_menu_tail(&output[tail_start..]) {
+            best = Some(abs);
+        }
+        start = tail_start;
+        if start > output.len() {
+            break;
+        }
+    }
+    best
+}
+
 /// Rightmost `›` whose tail is NOT a numbered-menu selector (` <digit>. `). A bare
 /// `›` followed by free text or whitespace is the Codex main-input prompt indicator;
 /// a `›` followed by `1. Yes, continue` is part of the trust/update menu and is NOT
@@ -204,6 +268,36 @@ pub fn codex_handle_startup_prompts(
     handled
 }
 
+pub fn claude_handle_startup_prompts(
+    transport: &dyn Transport,
+    target: &Target,
+    checks: usize,
+    sleep_s: f64,
+) -> Vec<HandledPrompt> {
+    let mut handled = Vec::new();
+    for _ in 0..checks {
+        let screen = match transport.capture(target, CaptureRange::Full) {
+            Ok(captured) => captured.text,
+            Err(_) => String::new(),
+        };
+        match classify_claude_startup_screen(&screen) {
+            StartupScreenDecision::AnswerWorkspaceTrust => {
+                let _ = transport.send_keys(target, &[Key::Enter]);
+                handled.push(HandledPrompt {
+                    prompt: "claude_workspace_trust".to_string(),
+                    action: "sent_enter".to_string(),
+                });
+                sleep_between_polls(sleep_s);
+            }
+            StartupScreenDecision::Ready => break,
+            StartupScreenDecision::SkipUpdatePrompt | StartupScreenDecision::KeepPolling => {
+                sleep_between_polls(sleep_s);
+            }
+        }
+    }
+    handled
+}
+
 fn max_rfind(output: &str, needles: &[&str]) -> Option<usize> {
     needles.iter().filter_map(|needle| output.rfind(needle)).max()
 }

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

@@ -1,10 +1,13 @@
 //! provider 共享类型:enums / newtypes / ProviderCaps / ProviderError / 捕获+classify payload / 占位结构。
 
+use std::collections::{BTreeMap, BTreeSet};
 use std::path::PathBuf;
 
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
+use super::AuthMode;
+
 // ===========================================================================
 // ENUMS (穷尽 + serde rename 到精确 Python 字符串)
 // ===========================================================================
@@ -305,6 +308,50 @@ pub struct ProviderCaps {
     pub writes_global_settings: bool,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct ProviderCommandOverrides {
+    pub model: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub struct ProviderProfileLaunch {
+    pub env_overlay: BTreeMap<String, String>,
+    pub env_unset: BTreeSet<String>,
+    pub command_overrides: ProviderCommandOverrides,
+    pub claude_config_dir: Option<PathBuf>,
+    pub claude_projects_root: Option<PathBuf>,
+    pub managed_mcp_config: bool,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct ProviderCommandContext<'a> {
+    pub auth_mode: AuthMode,
+    pub mcp_config: Option<&'a McpConfig>,
+    pub system_prompt: Option<&'a str>,
+    pub model: Option<&'a str>,
+    pub tools: &'a [&'a str],
+    pub profile_launch: Option<&'a ProviderProfileLaunch>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct CommandPlan {
+    pub argv: Vec<String>,
+    pub expected_session_id: Option<SessionId>,
+    pub provider_projects_root: Option<PathBuf>,
+    pub managed_mcp_config: bool,
+}
+
+impl CommandPlan {
+    pub fn argv_only(argv: Vec<String>) -> Self {
+        Self {
+            argv,
+            expected_session_id: None,
+            provider_projects_root: None,
+            managed_mcp_config: false,
+        }
+    }
+}
+
 // ===========================================================================
 // ERROR
 // ===========================================================================