@team-agent/installer 0.3.1 → 0.3.2

package/crates/team-agent/src/state/projection.rs

@@ -14,7 +14,7 @@ use std::path::Path;
 use serde_json::{json, Map, Value};
 
 use super::StateError;
-use crate::state::persist::{load_runtime_state, save_runtime_state};
+use crate::state::persist::{load_runtime_state, save_runtime_state_with_deleted_agents};
 
 /// `team_state_key`(`state.py:93`):从 team_dir(.name)/spec_path(.parent.name)派生 team key,
 /// 跳过 `.team`/`runtime`;兜底 `session_name` 或 `"current"`。
@@ -43,6 +43,122 @@ pub fn team_state_key(state: &Value) -> String {
         .map_or_else(|| "current".to_string(), str::to_string)
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum OwnerTeamResolution {
+    Canonical(String),
+    LegacyAlias { requested: String, canonical: String },
+    Unresolved { requested: String },
+    Ambiguous { requested: String, matches: Vec<String> },
+}
+
+impl OwnerTeamResolution {
+    pub fn canonical_key(&self) -> Option<&str> {
+        match self {
+            OwnerTeamResolution::Canonical(key)
+            | OwnerTeamResolution::LegacyAlias { canonical: key, .. } => Some(key),
+            OwnerTeamResolution::Unresolved { .. } | OwnerTeamResolution::Ambiguous { .. } => None,
+        }
+    }
+}
+
+pub fn resolve_owner_team_id(state: &Value, owner_team_id: &str) -> OwnerTeamResolution {
+    let requested = owner_team_id.trim();
+    if requested.is_empty() {
+        return OwnerTeamResolution::Unresolved { requested: owner_team_id.to_string() };
+    }
+    let teams = state.get("teams").and_then(Value::as_object);
+    if teams.is_some_and(|teams| teams.contains_key(requested)) {
+        if has_top_level_runtime_content(state) {
+            return OwnerTeamResolution::Canonical(requested.to_string());
+        }
+    }
+    if teams.is_none_or(Map::is_empty) {
+        let active = state.get("active_team_key").and_then(Value::as_str).unwrap_or("");
+        let derived = team_state_key(state);
+        if active == requested || derived == requested {
+            return OwnerTeamResolution::Canonical(requested.to_string());
+        }
+        if !active.is_empty() {
+            return OwnerTeamResolution::LegacyAlias {
+                requested: requested.to_string(),
+                canonical: active.to_string(),
+            };
+        }
+        if derived != "current" {
+            return OwnerTeamResolution::LegacyAlias {
+                requested: requested.to_string(),
+                canonical: derived,
+            };
+        }
+        return OwnerTeamResolution::Canonical(requested.to_string());
+    }
+    let Some(teams) = teams else {
+        return OwnerTeamResolution::Unresolved { requested: requested.to_string() };
+    };
+    let mut matches = Vec::new();
+    for (key, entry) in teams {
+        if legacy_owner_team_aliases(entry).any(|alias| alias == requested) {
+            matches.push(key.clone());
+        }
+    }
+    matches.sort();
+    matches.dedup();
+    match matches.len() {
+        0 => OwnerTeamResolution::Unresolved { requested: requested.to_string() },
+        1 => OwnerTeamResolution::LegacyAlias {
+            requested: requested.to_string(),
+            canonical: matches.remove(0),
+        },
+        _ => OwnerTeamResolution::Ambiguous { requested: requested.to_string(), matches },
+    }
+}
+
+fn has_top_level_runtime_content(state: &Value) -> bool {
+    [
+        "session_name",
+        "team_dir",
+        "spec_path",
+        "workspace",
+        "agents",
+        "tasks",
+        "leader_receiver",
+        "team_owner",
+    ]
+    .into_iter()
+    .any(|key| state.get(key).is_some_and(super::json_truthy))
+}
+
+fn legacy_owner_team_aliases(entry: &Value) -> impl Iterator<Item = String> + '_ {
+    let scalar_paths = [
+        "/team/name",
+        "/team/id",
+        "/name",
+        "/team_name",
+        "/team_id",
+        "/spec_name",
+        "/legacy_owner_team_id",
+        "/legacy_team_id",
+        "/legacy_team_name",
+        "/legacy_alias",
+    ];
+    let list_paths = ["/legacy_aliases", "/legacy_team_aliases", "/legacy_owner_team_ids", "/aliases"];
+    let scalars = scalar_paths
+        .into_iter()
+        .filter_map(|path| entry.pointer(path).and_then(Value::as_str));
+    let lists = list_paths.into_iter().flat_map(|path| {
+        entry
+            .pointer(path)
+            .and_then(Value::as_array)
+            .into_iter()
+            .flatten()
+            .filter_map(Value::as_str)
+    });
+    scalars
+        .chain(lists)
+        .filter(|alias| !alias.is_empty())
+        .map(str::to_string)
+}
+
 /// `compact_team_state`(`state.py:105`):剔除 `teams`(team entry 不嵌套全量 teams),保序。
 pub fn compact_team_state(state: &Value) -> Value {
     match state.as_object() {
@@ -339,6 +455,14 @@ pub fn resolve_team_scoped_state(
 /// 纯 `save_runtime_state`(字节等价);多 team 时把本 team 落到 `teams[target_key]=compact(...)`,顶层
 /// 视图按 golden 的 `existing_primary_key` 逻辑择 incoming/existing。§10:无 unwrap/panic。
 pub fn save_team_scoped_state(workspace: &Path, team_state: &Value) -> Result<(), StateError> {
+    save_team_scoped_state_with_deleted_agents(workspace, team_state, &[])
+}
+
+pub(crate) fn save_team_scoped_state_with_deleted_agents(
+    workspace: &Path,
+    team_state: &Value,
+    deleted_agent_ids: &[&str],
+) -> Result<(), StateError> {
     let target_key = team_state_key(team_state);
     let existing = load_runtime_state(workspace)?;
     // existing_primary_key = team_state_key(existing) if existing.get("session_name") else None
@@ -367,7 +491,7 @@ pub fn save_team_scoped_state(workspace: &Path, team_state: &Value) -> Result<()
     // not existing_teams and existing_primary_key == target_key → 纯 save(剔 teams)。
     if existing_teams.is_empty() && existing_primary_key.as_deref() == Some(target_key.as_str()) {
         let merged = compact_team_state(team_state);
-        return save_runtime_state(workspace, &merged);
+        return save_runtime_state_with_deleted_agents(workspace, &merged, deleted_agent_ids);
     }
     // teams = deepcopy(incoming_teams or existing_teams)
     let mut teams = match incoming_teams {
@@ -387,7 +511,7 @@ pub fn save_team_scoped_state(workspace: &Path, team_state: &Value) -> Result<()
     if merged.get("teams").and_then(Value::as_object).is_some_and(Map::is_empty) {
         merged.remove("teams");
     }
-    save_runtime_state(workspace, &Value::Object(merged))
+    save_runtime_state_with_deleted_agents(workspace, &Value::Object(merged), deleted_agent_ids)
 }
 
 // ---- helpers ----

package/crates/team-agent/src/tmux_backend.rs

@@ -494,6 +494,14 @@ fn submit_verification_for_key(key: Key) -> SubmitVerification {
     }
 }
 
+fn capture_has_pasted_content_prompt(text: &str) -> bool {
+    let lower = text.to_ascii_lowercase();
+    lower.contains("pasted content") || lower.contains("pasted text")
+}
+
+const PASTED_CONTENT_APPEAR_POLLS: u32 = 5;
+const PASTED_CONTENT_SUBMIT_ATTEMPTS: u32 = 3;
+
 fn shell_command(argv: &[String], cwd: &Path, env: &BTreeMap<String, String>) -> String {
     let mut parts = Vec::new();
     parts.push("cd".to_string());
@@ -579,7 +587,40 @@ impl Transport for TmuxBackend {
                         self.run_inject_stage(&argv, stage)?;
                     }
                 }
+                let mut saw_pasted_prompt = false;
+                for _ in 0..PASTED_CONTENT_APPEAR_POLLS {
+                    let captured = self.capture(target, CaptureRange::Tail(80))?;
+                    if capture_has_pasted_content_prompt(&captured.text) {
+                        saw_pasted_prompt = true;
+                        break;
+                    }
+                    std::thread::sleep(Duration::from_millis(25));
+                }
                 let submit_argv = tmux_send_keys_argv(&pane, &[submit]);
+                if saw_pasted_prompt {
+                    let mut attempts = 0;
+                    let mut cleared = false;
+                    for _ in 0..PASTED_CONTENT_SUBMIT_ATTEMPTS {
+                        attempts += 1;
+                        self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
+                        let captured = self.capture(target, CaptureRange::Tail(80))?;
+                        if !capture_has_pasted_content_prompt(&captured.text) {
+                            cleared = true;
+                            break;
+                        }
+                    }
+                    return Ok(InjectReport {
+                        stage_reached: InjectStage::Submit,
+                        inject_verification: InjectVerification::CaptureContainsNewPastedContentPrompt,
+                        submit_verification: if cleared {
+                            SubmitVerification::PastedContentPromptAbsentAfterSubmit
+                        } else {
+                            submit_verification_for_key(submit)
+                        },
+                        turn_verification: TurnVerification::NotYetObserved,
+                        attempts,
+                    });
+                }
                 self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
             }
         }
@@ -674,7 +715,10 @@ impl Transport for TmuxBackend {
         }
         let mut panes = Vec::new();
         for line in output.stdout.lines().filter(|line| !line.is_empty()) {
-            if let Some(pane) = parse_pane_info_line(line) {
+            if let Some(mut pane) = parse_pane_info_line(line) {
+                if pane.pane_pid.is_none() {
+                    pane.pane_pid = query_pane_pid(self, &pane.pane_id)?;
+                }
                 panes.push(pane);
             }
         }
@@ -737,22 +781,22 @@ impl Transport for TmuxBackend {
     }
 
     fn kill_session(&self, session: &SessionName) -> Result<(), TransportError> {
-        let argv = vec![
+        let argv = self.tmux_argv(&[
             "tmux".to_string(),
             "kill-session".to_string(),
             "-t".to_string(),
             session.as_str().to_string(),
-        ];
+        ]);
         self.run_ok(&argv)
     }
 
     fn kill_window(&self, target: &Target) -> Result<(), TransportError> {
-        let argv = vec![
+        let argv = self.tmux_argv(&[
             "tmux".to_string(),
             "kill-window".to_string(),
             "-t".to_string(),
             target_name(target),
-        ];
+        ]);
         self.run_ok(&argv)
     }
 
@@ -771,6 +815,22 @@ impl Transport for TmuxBackend {
     }
 }
 
+fn query_pane_pid(backend: &TmuxBackend, pane: &PaneId) -> Result<Option<u32>, TransportError> {
+    let argv = backend.tmux_argv(&[
+        "tmux".to_string(),
+        "display-message".to_string(),
+        "-p".to_string(),
+        "-t".to_string(),
+        pane.as_str().to_string(),
+        "#{pane_pid}".to_string(),
+    ]);
+    let output = backend.runner.run(&argv)?;
+    if !output.success {
+        return Ok(None);
+    }
+    Ok(parse_optional_u32(output.stdout.trim()))
+}
+
 fn parse_pane_info_line(line: &str) -> Option<PaneInfo> {
     let fields = line.split('\t').collect::<Vec<_>>();
     if fields.len() < 11 {
@@ -786,7 +846,7 @@ fn parse_pane_info_line(line: &str) -> Option<PaneInfo> {
         current_command: non_empty(fields[6]).map(str::to_string),
         active: fields[7] == "1",
         current_path: non_empty(fields[8]).map(PathBuf::from),
-        pane_pid: None,
+        pane_pid: fields.get(11).and_then(|raw| parse_optional_u32(raw)),
         leader_env: BTreeMap::new(),
     })
 }

package/package.json

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