@team-agent/installer 0.3.2 → 0.3.4

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

@@ -19,6 +19,13 @@ use crate::state::persist::{load_runtime_state, save_runtime_state_with_deleted_
 /// `team_state_key`(`state.py:93`):从 team_dir(.name)/spec_path(.parent.name)派生 team key,
 /// 跳过 `.team`/`runtime`;兜底 `session_name` 或 `"current"`。
 pub fn team_state_key(state: &Value) -> String {
+    if let Some(team_key) = state
+        .get("team_key")
+        .and_then(Value::as_str)
+        .filter(|key| !key.is_empty())
+    {
+        return team_key.to_string();
+    }
     for field in ["team_dir", "spec_path"] {
         // Python `if not value: continue` —— None/空串 falsy 跳过。
         let value = match state.get(field).and_then(Value::as_str) {
@@ -68,9 +75,7 @@ pub fn resolve_owner_team_id(state: &Value, owner_team_id: &str) -> OwnerTeamRes
     }
     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());
-        }
+        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("");
@@ -113,21 +118,6 @@ pub fn resolve_owner_team_id(state: &Value, owner_team_id: &str) -> OwnerTeamRes
     }
 }
 
-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",
@@ -357,11 +347,7 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
         }
         let matches: Vec<&String> = alive
             .iter()
-            .filter(|(key, value)| {
-                let session = value.get("session_name").and_then(Value::as_str).unwrap_or("");
-                let dir = value.get("team_dir").and_then(Value::as_str).unwrap_or("");
-                team == key.as_str() || team == session || team == dir
-            })
+            .filter(|(key, value)| team_selector_matches(team, key, value))
             .map(|(k, _)| k)
             .collect();
         if matches.len() == 1 {
@@ -398,6 +384,29 @@ pub fn select_runtime_state(workspace: &Path, team: Option<&str>) -> Result<Valu
     ))
 }
 
+fn team_selector_matches(team: &str, key: &str, value: &Value) -> bool {
+    if team == key {
+        return true;
+    }
+    let session = value.get("session_name").and_then(Value::as_str).unwrap_or("");
+    if team == session {
+        return true;
+    }
+    if let Some(stripped) = session.strip_prefix("team-") {
+        if team == stripped {
+            return true;
+        }
+    }
+    let dir = value.get("team_dir").and_then(Value::as_str).unwrap_or("");
+    if team == dir {
+        return true;
+    }
+    std::path::Path::new(dir)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| team == name)
+}
+
 /// `ambiguous_team_target_result`(`state.py:226`):无显式 team 且多候选 → 拒绝 dict;否则 None。
 pub fn ambiguous_team_target_result(state: &Value) -> Option<Value> {
     let alive = team_state_candidates(state);

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

@@ -98,8 +98,11 @@ fn spec_workspace_from_state(state: &Value) -> Option<PathBuf> {
 }
 
 fn selected_team_key(state: &Value, team: Option<&str>) -> String {
-    team.filter(|s| !s.is_empty())
+    state
+        .get("active_team_key")
+        .and_then(Value::as_str)
+        .filter(|s| !s.is_empty())
         .map(ToString::to_string)
-        .or_else(|| state.get("active_team_key").and_then(Value::as_str).filter(|s| !s.is_empty()).map(ToString::to_string))
+        .or_else(|| team.filter(|s| !s.is_empty()).map(ToString::to_string))
         .unwrap_or_else(|| team_state_key(state))
 }

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

@@ -27,8 +27,8 @@ use crate::transport::{
     normalize_capture, tmux_capture_argv, tmux_empty_inject_argv, tmux_inject_text_argv,
     tmux_query_argv, tmux_send_keys_argv, tmux_spawn_argv, AttachOutcome, BackendKind,
     CaptureRange, CapturedText, InjectPayload, InjectReport, InjectStage, InjectVerification, Key,
-    PaneField, PaneId, PaneInfo, PaneMode, SessionName, SetEnvOutcome, SpawnResult, SubmitVerification,
-    Target, Transport, TransportError, TurnVerification, WindowName,
+    PaneField, PaneId, PaneInfo, PaneMode, SessionName, SetEnvOutcome, SpawnResult,
+    SubmitVerification, Target, Transport, TransportError, TurnVerification, WindowName,
 };
 
 /// Result of running an external command — the typed output of the OS edge.
@@ -91,22 +91,29 @@ impl RealCommandRunner {
         };
         let mut child = std::process::Command::new(program)
             .args(argv.iter().skip(1))
-            .stdin(if stdin_text.is_some() { Stdio::piped() } else { Stdio::null() })
+            .stdin(if stdin_text.is_some() {
+                Stdio::piped()
+            } else {
+                Stdio::null()
+            })
             .stdout(Stdio::piped())
             .stderr(Stdio::piped())
             .spawn()?;
         if let Some(text) = stdin_text {
-            let mut stdin = child.stdin.take().ok_or_else(|| {
-                std::io::Error::other("stdin pipe missing")
-            })?;
+            let mut stdin = child
+                .stdin
+                .take()
+                .ok_or_else(|| std::io::Error::other("stdin pipe missing"))?;
             stdin.write_all(text.as_bytes())?;
         }
-        let stdout = child.stdout.take().ok_or_else(|| {
-            std::io::Error::other("stdout pipe missing")
-        })?;
-        let stderr = child.stderr.take().ok_or_else(|| {
-            std::io::Error::other("stderr pipe missing")
-        })?;
+        let stdout = child
+            .stdout
+            .take()
+            .ok_or_else(|| std::io::Error::other("stdout pipe missing"))?;
+        let stderr = child
+            .stderr
+            .take()
+            .ok_or_else(|| std::io::Error::other("stderr pipe missing"))?;
         let stdout_thread = std::thread::spawn(move || read_pipe(stdout));
         let stderr_thread = std::thread::spawn(move || read_pipe(stderr));
         let deadline = Instant::now() + COMMAND_TIMEOUT;
@@ -173,7 +180,10 @@ impl TmuxBackend {
     /// Backend bound to the real `tmux` subprocess on the SHARED default socket (no `-L`).
     /// Non-team callers + existing argv/unit tests stay unaffected.
     pub fn new() -> Self {
-        Self { runner: Box::new(RealCommandRunner), socket: None }
+        Self {
+            runner: Box::new(RealCommandRunner),
+            socket: None,
+        }
     }
 
     /// CP-1 team backend: bound to the real `tmux` subprocess on a PER-WORKSPACE socket, derived
@@ -182,7 +192,9 @@ impl TmuxBackend {
     pub fn for_workspace(workspace: &Path) -> Self {
         Self {
             runner: Box::new(RealCommandRunner),
-            socket: Some(TmuxSocketEndpoint::Name(socket_name_for_workspace(workspace))),
+            socket: Some(TmuxSocketEndpoint::Name(socket_name_for_workspace(
+                workspace,
+            ))),
         }
     }
 
@@ -190,7 +202,10 @@ impl TmuxBackend {
         if socket.is_empty() || socket == "default" {
             Self::new()
         } else {
-            Self { runner: Box::new(RealCommandRunner), socket: Some(TmuxSocketEndpoint::Name(socket.to_string())) }
+            Self {
+                runner: Box::new(RealCommandRunner),
+                socket: Some(TmuxSocketEndpoint::Name(socket.to_string())),
+            }
         }
     }
 
@@ -198,7 +213,10 @@ impl TmuxBackend {
         if endpoint.is_empty() || endpoint == "default" {
             Self::new()
         } else if Path::new(endpoint).is_absolute() {
-            Self { runner: Box::new(RealCommandRunner), socket: Some(TmuxSocketEndpoint::Path(endpoint.to_string())) }
+            Self {
+                runner: Box::new(RealCommandRunner),
+                socket: Some(TmuxSocketEndpoint::Path(endpoint.to_string())),
+            }
         } else {
             Self::new()
         }
@@ -206,25 +224,50 @@ impl TmuxBackend {
 
     /// Backend with an injected runner (tests: canned/recording tmux output). Shared default socket.
     pub fn with_runner(runner: Box<dyn CommandRunner>) -> Self {
-        Self { runner, socket: None }
+        Self {
+            runner,
+            socket: None,
+        }
     }
 
     /// Backend with an injected runner bound to a per-workspace socket (tests: assert the `-L` is in
     /// the recorded argv for a workspace-bound backend).
     pub fn with_runner_for_workspace(runner: Box<dyn CommandRunner>, workspace: &Path) -> Self {
-        Self { runner, socket: Some(TmuxSocketEndpoint::Name(socket_name_for_workspace(workspace))) }
+        Self {
+            runner,
+            socket: Some(TmuxSocketEndpoint::Name(socket_name_for_workspace(
+                workspace,
+            ))),
+        }
     }
 
-    pub(crate) fn with_runner_for_tmux_endpoint(runner: Box<dyn CommandRunner>, endpoint: &str) -> Self {
+    pub(crate) fn with_runner_for_tmux_endpoint(
+        runner: Box<dyn CommandRunner>,
+        endpoint: &str,
+    ) -> Self {
         if Path::new(endpoint).is_absolute() {
-            Self { runner, socket: Some(TmuxSocketEndpoint::Path(endpoint.to_string())) }
+            Self {
+                runner,
+                socket: Some(TmuxSocketEndpoint::Path(endpoint.to_string())),
+            }
         } else if endpoint.is_empty() || endpoint == "default" {
-            Self { runner, socket: None }
+            Self {
+                runner,
+                socket: None,
+            }
         } else {
-            Self { runner, socket: None }
+            Self {
+                runner,
+                socket: None,
+            }
         }
     }
 
+    /// Build the exact argv that a workspace-bound tmux backend will execute.
+    pub fn argv_for_workspace(workspace: &Path, argv: &[String]) -> Vec<String> {
+        Self::for_workspace(workspace).tmux_argv(argv)
+    }
+
     /// THE RUN CHOKEPOINT: every executed `tmux` argv is funneled through here. When a per-team
     /// socket is set, inject `-L <socket>` right after the leading "tmux" token; otherwise pass argv
     /// through unchanged. Non-`tmux` argv (e.g. the spawned provider command) is never rewritten.
@@ -257,10 +300,7 @@ impl TmuxBackend {
         if self.socket.is_none() {
             return;
         }
-        let argv = self.tmux_argv(&[
-            "tmux".to_string(),
-            "kill-server".to_string(),
-        ]);
+        let argv = self.tmux_argv(&["tmux".to_string(), "kill-server".to_string()]);
         let _ = self.runner.run(&argv);
     }
 }
@@ -278,6 +318,60 @@ pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
     format!("ta-{:012x}", hasher.finish() & 0xffff_ffff_ffff)
 }
 
+pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
+    let socket_name = socket_name_for_workspace(workspace);
+    let roots = tmux_socket_roots();
+    for root in &roots {
+        let root = root.canonicalize().unwrap_or_else(|_| root.clone());
+        let candidate = root.join(&socket_name);
+        if candidate.exists() {
+            return Some(candidate.canonicalize().unwrap_or(candidate));
+        }
+    }
+    let uid = unsafe { libc::geteuid() };
+    let default_root = PathBuf::from(format!("/tmp/tmux-{uid}"));
+    let default_root = default_root
+        .canonicalize()
+        .unwrap_or(default_root);
+    Some(default_root.join(socket_name))
+}
+
+pub(crate) fn attach_command_for_workspace(
+    workspace: &Path,
+    session_name: &SessionName,
+    window_name: &str,
+) -> Option<String> {
+    let socket_path = socket_path_for_workspace(workspace)?;
+    Some(format!(
+        "tmux -S {} attach -t {}:{}",
+        socket_path.display(),
+        session_name.as_str(),
+        window_name
+    ))
+}
+
+pub(crate) fn attach_commands_for_windows<'a>(
+    workspace: &Path,
+    session_name: &SessionName,
+    window_names: impl IntoIterator<Item = &'a str>,
+) -> Vec<String> {
+    window_names
+        .into_iter()
+        .filter_map(|window_name| attach_command_for_workspace(workspace, session_name, window_name))
+        .collect()
+}
+
+fn tmux_socket_roots() -> Vec<PathBuf> {
+    let uid = unsafe { libc::geteuid() };
+    let mut roots = vec![PathBuf::from(format!("/tmp/tmux-{uid}"))];
+    if let Some(tmpdir) = std::env::var_os("TMPDIR") {
+        roots.push(PathBuf::from(tmpdir).join(format!("tmux-{uid}")));
+    }
+    roots.sort();
+    roots.dedup();
+    roots
+}
+
 pub(crate) fn socket_name_from_tmux_env() -> Option<String> {
     let tmux = std::env::var("TMUX")
         .ok()
@@ -362,10 +456,13 @@ impl TmuxBackend {
 
     fn run_spawn(&self, argv: &[String]) -> Result<CommandOutput, TransportError> {
         let argv = self.tmux_argv(argv);
-        let output = self.runner.run(&argv).map_err(|source| TransportError::Spawn {
-            backend: BackendKind::Tmux,
-            source,
-        })?;
+        let output = self
+            .runner
+            .run(&argv)
+            .map_err(|source| TransportError::Spawn {
+                backend: BackendKind::Tmux,
+                source,
+            })?;
         if output.success {
             Ok(output)
         } else {
@@ -373,16 +470,12 @@ impl TmuxBackend {
         }
     }
 
-    fn run_inject_stage(
-        &self,
-        argv: &[String],
-        stage: InjectStage,
-    ) -> Result<(), TransportError> {
+    fn run_inject_stage(&self, argv: &[String], stage: InjectStage) -> Result<(), TransportError> {
         let argv = self.tmux_argv(argv);
-        let output = self.runner.run(&argv).map_err(|source| TransportError::Inject {
-            stage,
-            source,
-        })?;
+        let output = self
+            .runner
+            .run(&argv)
+            .map_err(|source| TransportError::Inject { stage, source })?;
         if output.success {
             Ok(())
         } else {
@@ -397,10 +490,10 @@ impl TmuxBackend {
         stdin: &str,
     ) -> Result<(), TransportError> {
         let argv = self.tmux_argv(argv);
-        let output = self.runner.run_with_stdin(&argv, stdin).map_err(|source| TransportError::Inject {
-            stage,
-            source,
-        })?;
+        let output = self
+            .runner
+            .run_with_stdin(&argv, stdin)
+            .map_err(|source| TransportError::Inject { stage, source })?;
         if output.success {
             Ok(())
         } else {
@@ -611,11 +704,12 @@ impl Transport for TmuxBackend {
                     }
                     return Ok(InjectReport {
                         stage_reached: InjectStage::Submit,
-                        inject_verification: InjectVerification::CaptureContainsNewPastedContentPrompt,
+                        inject_verification:
+                            InjectVerification::CaptureContainsNewPastedContentPrompt,
                         submit_verification: if cleared {
                             SubmitVerification::PastedContentPromptAbsentAfterSubmit
                         } else {
-                            submit_verification_for_key(submit)
+                            SubmitVerification::PastedContentPromptStillPresentAfterSubmit
                         },
                         turn_verification: TurnVerification::NotYetObserved,
                         attempts,
@@ -656,7 +750,10 @@ impl Transport for TmuxBackend {
     ) -> Result<CapturedText, TransportError> {
         let pane = pane_from_target(target);
         let argv = self.tmux_argv(&tmux_capture_argv(&pane, range));
-        let output = self.runner.run(&argv).map_err(|source| TransportError::Capture { source })?;
+        let output = self
+            .runner
+            .run(&argv)
+            .map_err(|source| TransportError::Capture { source })?;
         if !output.success {
             return Err(subprocess_error(argv, output));
         }
@@ -666,11 +763,7 @@ impl Transport for TmuxBackend {
         })
     }
 
-    fn query(
-        &self,
-        target: &Target,
-        field: PaneField,
-    ) -> Result<Option<String>, TransportError> {
+    fn query(&self, target: &Target, field: PaneField) -> Result<Option<String>, TransportError> {
         let pane = pane_from_target(target);
         let argv = self.tmux_argv(&tmux_query_argv(&pane, field));
         let output = self.runner.run(&argv)?;
@@ -693,7 +786,11 @@ impl Transport for TmuxBackend {
         if output.success {
             return Ok(PaneLiveness::Live);
         }
-        if output.stderr.to_ascii_lowercase().contains("can't find pane") {
+        if output
+            .stderr
+            .to_ascii_lowercase()
+            .contains("can't find pane")
+        {
             Ok(PaneLiveness::Dead)
         } else {
             Ok(PaneLiveness::Unknown)
@@ -736,10 +833,7 @@ impl Transport for TmuxBackend {
         Ok(output.success)
     }
 
-    fn list_windows(
-        &self,
-        session: &SessionName,
-    ) -> Result<Vec<WindowName>, TransportError> {
+    fn list_windows(&self, session: &SessionName) -> Result<Vec<WindowName>, TransportError> {
         // golden runtime.py:1023-1029 `_tmux_window_exists`: `tmux list-windows -t <s> -F #{window_name}`;
         // returncode != 0 -> false (here: an empty window set), else the window names by line.
         let argv = self.tmux_argv(&[
@@ -800,10 +894,7 @@ impl Transport for TmuxBackend {
         self.run_ok(&argv)
     }
 
-    fn attach_session(
-        &self,
-        session: &SessionName,
-    ) -> Result<AttachOutcome, TransportError> {
+    fn attach_session(&self, session: &SessionName) -> Result<AttachOutcome, TransportError> {
         let argv = [
             "tmux".to_string(),
             "attach-session".to_string(),

package/crates/team-agent/src/transport/test_support.rs

@@ -21,6 +21,7 @@ pub struct SpawnRecord {
 #[derive(Debug, Clone, Default)]
 struct OfflineState {
     session_present: bool,
+    session_absent_after_spawn_first: bool,
     targets: Vec<PaneInfo>,
     windows: Vec<WindowName>,
     calls: Vec<&'static str>,
@@ -44,6 +45,11 @@ impl OfflineTransport {
         self
     }
 
+    pub fn with_session_absent_after_spawn_first(self) -> Self {
+        self.with_state(|state| state.session_absent_after_spawn_first = true);
+        self
+    }
+
     pub fn with_targets(self, targets: Vec<PaneInfo>) -> Self {
         self.with_state(|state| state.targets = targets);
         self
@@ -100,6 +106,9 @@ impl OfflineTransport {
         let pane_index = self.with_state(|state| {
             state.calls.push(kind);
             state.spawns.push(SpawnRecord { kind: kind.to_string(), argv: argv.to_vec() });
+            if kind == "spawn_first" && !state.session_absent_after_spawn_first {
+                state.session_present = true;
+            }
             state.spawns.len().saturating_sub(1)
         });
         SpawnResult {

package/crates/team-agent/src/transport/tests/wire.rs

@@ -103,6 +103,10 @@
             submit_verification_wire(SubmitVerification::PastedContentPromptAbsentAfterSubmit),
             "pasted_content_prompt_absent_after_submit"
         );
+        assert_eq!(
+            submit_verification_wire(SubmitVerification::PastedContentPromptStillPresentAfterSubmit),
+            "pasted_content_prompt_still_present_after_submit"
+        );
         assert_eq!(
             submit_verification_wire(SubmitVerification::SendKeysFailed),
             "send_keys_failed"

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

@@ -165,6 +165,7 @@ pub enum Key {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum CaptureRange {
     Tail(u32),
+    Head(u32),
     Full,
 }
 
@@ -290,6 +291,8 @@ pub enum SubmitVerification {
     EnterSentWithoutPlaceholderCheck,
     /// `pasted_content_prompt_absent_after_submit`。
     PastedContentPromptAbsentAfterSubmit,
+    /// `pasted_content_prompt_still_present_after_submit`。
+    PastedContentPromptStillPresentAfterSubmit,
     /// `{key}_sent_after_visible_token`(key 由 variant 携带)。
     KeySentAfterVisibleToken { key: Key },
     /// `send_keys_failed`。
@@ -580,9 +583,10 @@ pub fn tmux_cancel_mode_argv(pane: &PaneId, mode: PaneMode) -> Vec<String> {
 pub fn tmux_capture_argv(pane: &PaneId, range: CaptureRange) -> Vec<String> {
     let spec = match range {
         CaptureRange::Tail(lines) => format!("-{lines}"),
+        CaptureRange::Head(_) => "0".to_string(),
         CaptureRange::Full => "-".to_string(),
     };
-    vec![
+    let mut argv = vec![
         "tmux".to_string(),
         "capture-pane".to_string(),
         "-p".to_string(),
@@ -590,7 +594,11 @@ pub fn tmux_capture_argv(pane: &PaneId, range: CaptureRange) -> Vec<String> {
         spec,
         "-t".to_string(),
         pane.as_str().to_string(),
-    ]
+    ];
+    if let CaptureRange::Head(lines) = range {
+        argv.extend(["-E".to_string(), lines.saturating_sub(1).to_string()]);
+    }
+    argv
 }
 
 /// PaneField → `display-message -p -t <target> [-F] <fmt>`。
@@ -748,6 +756,9 @@ pub fn submit_verification_wire(v: SubmitVerification) -> String {
         SubmitVerification::PastedContentPromptAbsentAfterSubmit => {
             "pasted_content_prompt_absent_after_submit".to_string()
         }
+        SubmitVerification::PastedContentPromptStillPresentAfterSubmit => {
+            "pasted_content_prompt_still_present_after_submit".to_string()
+        }
         SubmitVerification::KeySentAfterVisibleToken { key } => {
             format!("{}_sent_after_visible_token", tmux_key_name(key))
         }

package/package.json

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