@team-agent/installer 0.3.0 → 0.3.2

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

@@ -161,7 +161,12 @@ pub struct TmuxBackend {
     runner: Box<dyn CommandRunner>,
     /// `Some(name)` for a per-team socket -> every `tmux` argv gets `-L <name>` injected after the
     /// leading "tmux" token; `None` (default) -> bare `tmux` on the shared default socket.
-    socket: Option<String>,
+    socket: Option<TmuxSocketEndpoint>,
+}
+
+enum TmuxSocketEndpoint {
+    Name(String),
+    Path(String),
 }
 
 impl TmuxBackend {
@@ -177,7 +182,25 @@ impl TmuxBackend {
     pub fn for_workspace(workspace: &Path) -> Self {
         Self {
             runner: Box::new(RealCommandRunner),
-            socket: Some(socket_name_for_workspace(workspace)),
+            socket: Some(TmuxSocketEndpoint::Name(socket_name_for_workspace(workspace))),
+        }
+    }
+
+    pub(crate) fn for_socket_name(socket: &str) -> Self {
+        if socket.is_empty() || socket == "default" {
+            Self::new()
+        } else {
+            Self { runner: Box::new(RealCommandRunner), socket: Some(TmuxSocketEndpoint::Name(socket.to_string())) }
+        }
+    }
+
+    pub(crate) fn for_tmux_endpoint(endpoint: &str) -> Self {
+        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())) }
+        } else {
+            Self::new()
         }
     }
 
@@ -189,7 +212,17 @@ impl TmuxBackend {
     /// 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(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 {
+        if Path::new(endpoint).is_absolute() {
+            Self { runner, socket: Some(TmuxSocketEndpoint::Path(endpoint.to_string())) }
+        } else if endpoint.is_empty() || endpoint == "default" {
+            Self { runner, socket: None }
+        } else {
+            Self { runner, socket: None }
+        }
     }
 
     /// THE RUN CHOKEPOINT: every executed `tmux` argv is funneled through here. When a per-team
@@ -197,11 +230,19 @@ impl TmuxBackend {
     /// through unchanged. Non-`tmux` argv (e.g. the spawned provider command) is never rewritten.
     fn tmux_argv(&self, argv: &[String]) -> Vec<String> {
         match &self.socket {
-            Some(socket) if argv.first().map(String::as_str) == Some("tmux") => {
+            Some(endpoint) if argv.first().map(String::as_str) == Some("tmux") => {
                 let mut out = Vec::with_capacity(argv.len() + 2);
                 out.push("tmux".to_string());
-                out.push("-L".to_string());
-                out.push(socket.clone());
+                match endpoint {
+                    TmuxSocketEndpoint::Name(socket) => {
+                        out.push("-L".to_string());
+                        out.push(socket.clone());
+                    }
+                    TmuxSocketEndpoint::Path(socket) => {
+                        out.push("-S".to_string());
+                        out.push(socket.clone());
+                    }
+                }
                 out.extend(argv.iter().skip(1).cloned());
                 out
             }
@@ -237,6 +278,17 @@ pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
     format!("ta-{:012x}", hasher.finish() & 0xffff_ffff_ffff)
 }
 
+pub(crate) fn socket_name_from_tmux_env() -> Option<String> {
+    let tmux = std::env::var("TMUX")
+        .ok()
+        .filter(|value| !value.is_empty())?;
+    let socket_path = tmux.split(',').next().unwrap_or("").trim();
+    if socket_path.is_empty() || !Path::new(socket_path).is_absolute() {
+        return None;
+    }
+    Some(socket_path.to_string())
+}
+
 /// Deterministic FNV-1a (64-bit) — std `DefaultHasher` is NOT stable across releases, so a fixed
 /// FNV keeps the socket identical for the CLI, the daemon, and every later op on the same workspace.
 struct Fnv1a(u64);
@@ -442,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());
@@ -527,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)?;
             }
         }
@@ -622,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);
             }
         }
@@ -685,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)
     }
 
@@ -719,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 {
@@ -734,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/npm/install.mjs

@@ -10,6 +10,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const packageRoot = path.resolve(__dirname, "..");
 const require = createRequire(import.meta.url);
 const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+const DOCTOR_TIMEOUT_MS = 5000;
 
 const command = process.argv[2] || "install";
 const args = process.argv.slice(3);
@@ -87,11 +88,20 @@ function install(argv) {
   console.log("skill: installed for Codex and Claude");
   console.log(`PATH: ensure ${binDir} is on PATH`);
 
-  const doctor = spawnSync(teamAgent, ["doctor", "--json"], { text: true, encoding: "utf8" });
-  if (doctor.status === 0) {
-    console.log("doctor: ok");
-  } else {
-    console.log("doctor: has blockers; run `team-agent doctor` after updating PATH");
+  const doctorWorkspace = makeDoctorWorkspace();
+  try {
+    const doctor = spawnSync(teamAgent, ["doctor", "--json", "--workspace", doctorWorkspace], {
+      text: true,
+      encoding: "utf8",
+      timeout: DOCTOR_TIMEOUT_MS,
+    });
+    if (doctor.status === 0) {
+      console.log("doctor: ok");
+    } else {
+      console.log("doctor: has blockers; run `team-agent doctor` after updating PATH");
+    }
+  } finally {
+    fs.rmSync(doctorWorkspace, { recursive: true, force: true });
   }
 }
 
@@ -103,8 +113,16 @@ function runDoctor(argv) {
     console.error(`team-agent wrapper not found: ${teamAgent}`);
     process.exit(1);
   }
-  const proc = spawnSync(teamAgent, ["doctor"], { stdio: "inherit" });
-  process.exit(proc.status ?? 1);
+  const doctorWorkspace = makeDoctorWorkspace();
+  try {
+    const proc = spawnSync(teamAgent, ["doctor", "--workspace", doctorWorkspace], {
+      stdio: "inherit",
+      timeout: DOCTOR_TIMEOUT_MS,
+    });
+    process.exit(proc.status ?? 1);
+  } finally {
+    fs.rmSync(doctorWorkspace, { recursive: true, force: true });
+  }
 }
 
 function uninstall(argv) {
@@ -217,6 +235,10 @@ function skillDestinations() {
   ];
 }
 
+function makeDoctorWorkspace() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "team-agent-doctor-"));
+}
+
 function copyTree(src, dest) {
   const stat = fs.lstatSync(src);
   if (stat.isDirectory()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@team-agent/installer",
-  "version": "0.3.0",
+  "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.0",
-    "@team-agent/cli-darwin-x64": "0.3.0",
-    "@team-agent/cli-linux-x64": "0.3.0"
+    "@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",