@team-agent/installer 0.3.1 → 0.3.3

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);
     }
 }
@@ -362,10 +402,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 +416,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 +436,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 {
@@ -494,6 +533,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 +626,41 @@ 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 {
+                            SubmitVerification::PastedContentPromptStillPresentAfterSubmit
+                        },
+                        turn_verification: TurnVerification::NotYetObserved,
+                        attempts,
+                    });
+                }
                 self.run_inject_stage(&submit_argv, InjectStage::Submit)?;
             }
         }
@@ -615,7 +696,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));
         }
@@ -625,11 +709,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)?;
@@ -652,7 +732,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)
@@ -674,7 +758,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);
             }
         }
@@ -692,10 +779,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(&[
@@ -737,29 +821,26 @@ 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)
     }
 
-    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(),
@@ -771,6 +852,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 +883,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/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.1",
+  "version": "0.3.3",
   "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.3",
+    "@team-agent/cli-darwin-x64": "0.3.3",
+    "@team-agent/cli-linux-x64": "0.3.3"
   },
   "scripts": {
     "postinstall": "node npm/bincheck.mjs",