@team-agent/installer 0.3.0 → 0.3.1

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

@@ -332,6 +332,9 @@ pub fn apply_first_time_leader_binding(
         r.insert("leader_session_uuid".to_string(), id_uuid.clone());
         r.insert("machine_fingerprint".to_string(), id_fp.clone());
         r.insert("owner_epoch".to_string(), json!(0));
+        if let Some(socket) = crate::tmux_backend::socket_name_from_tmux_env() {
+            r.insert("tmux_socket".to_string(), json!(socket));
+        }
     }
     let owner = json!({
         "pane_id": receiver.get("pane_id").cloned().unwrap_or(Value::Null),

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

@@ -98,6 +98,185 @@
         items.iter().map(|s| (*s).to_string()).collect()
     }
 
+    struct EnvGuard {
+        saved: Vec<(String, Option<String>)>,
+    }
+
+    impl EnvGuard {
+        fn apply(vars: &[(&str, Option<&str>)]) -> Self {
+            let saved = vars.iter().map(|(k, _)| ((*k).to_string(), std::env::var(k).ok())).collect();
+            for (k, v) in vars {
+                match v {
+                    Some(val) => std::env::set_var(k, val),
+                    None => std::env::remove_var(k),
+                }
+            }
+            Self { saved }
+        }
+    }
+
+    impl Drop for EnvGuard {
+        fn drop(&mut self) {
+            for (k, v) in &self.saved {
+                match v {
+                    Some(val) => std::env::set_var(k, val),
+                    None => std::env::remove_var(k),
+                }
+            }
+        }
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn leader_receiver_endpoint_from_tmux_env_preserves_full_socket_path() {
+        let leader_socket = "/tmp/ta-leader-root/tmux-501/dl2f";
+        let _env = EnvGuard::apply(&[
+            ("TMUX", Some("/tmp/ta-leader-root/tmux-501/dl2f,12345,0")),
+            ("TMUX_TMPDIR", Some("/tmp/ta-coordinator-root")),
+        ]);
+
+        assert_eq!(
+            super::socket_name_from_tmux_env().as_deref(),
+            Some(leader_socket),
+            "leader receivers must persist the exact tmux endpoint from $TMUX; a short -L socket \
+             name is re-rooted under the coordinator's TMUX_TMPDIR and cannot reach an external \
+             leader pane"
+        );
+    }
+
+    #[test]
+    #[serial_test::serial(env)]
+    fn leader_receiver_endpoint_from_tmux_env_rejects_short_socket_name() {
+        let _env = EnvGuard::apply(&[
+            ("TMUX", Some("dl9aa40c88,12345,0")),
+            ("TMUX_TMPDIR", Some("/tmp/ta-coordinator-root")),
+        ]);
+
+        assert_eq!(
+            super::socket_name_from_tmux_env(),
+            None,
+            "leader_receiver.tmux_socket is a durable physical endpoint: a short socket name from \
+             $TMUX must not be persisted because tmux -L <short> is re-rooted under the coordinator"
+        );
+    }
+
+    #[test]
+    fn leader_receiver_delivery_uses_full_socket_endpoint_not_short_l_reconstruction() {
+        let manifest = Path::new(env!("CARGO_MANIFEST_DIR"));
+        let delivery = std::fs::read_to_string(manifest.join("src/messaging/delivery.rs")).unwrap();
+        let leader_receiver =
+            std::fs::read_to_string(manifest.join("src/messaging/leader_receiver.rs")).unwrap();
+        let tmux_backend = std::fs::read_to_string(manifest.join("src/tmux_backend.rs")).unwrap();
+
+        assert!(
+            tmux_backend.contains("\"-S\""),
+            "tmux backend must support `tmux -S <full-socket-path>` for persisted external leader \
+             endpoints; `-L <short-name>` is not enough when leader and coordinator TMUX_TMPDIR differ"
+        );
+        assert!(
+            !delivery.contains("TmuxBackend::for_socket_name(socket)"),
+            "worker->leader delivery must not reconstruct an external leader endpoint with \
+             `tmux -L <short-name>`; it must use the persisted full socket path endpoint"
+        );
+        assert!(
+            !leader_receiver.contains("TmuxBackend::for_socket_name(socket)"),
+            "leader_receiver live checks must verify the same full socket endpoint used by delivery, \
+            not a short socket name resolved under the coordinator's socket root"
+        );
+    }
+
+    #[test]
+    fn leader_receiver_full_endpoint_liveness_list_and_inject_use_s_path_command_shape() {
+        let endpoint = "/private/tmp/tmux-501/default";
+        let stdout = "%7\tteam-x\t0\tleader\t0\t/dev/ttys003\tbash\t1\t/Users/me/work\t1\t0\n";
+        let (be, rec, _stdin) = {
+            let recorded = Arc::new(Mutex::new(Vec::new()));
+            let stdin_recorded = Arc::new(Mutex::new(Vec::new()));
+            let runner = MockCommandRunner {
+                recorded: Arc::clone(&recorded),
+                stdin_recorded: Arc::clone(&stdin_recorded),
+                queue: Mutex::new(
+                    vec![
+                        MockResp::Out(ok(stdout)),
+                        MockResp::Out(ok("%7\n")),
+                        MockResp::Out(ok("")),
+                        MockResp::Out(ok("")),
+                        MockResp::Out(ok("")),
+                    ]
+                    .into_iter()
+                    .collect(),
+                ),
+                default: MockResp::Out(ok("")),
+            };
+            (
+                TmuxBackend::with_runner_for_tmux_endpoint(Box::new(runner), endpoint),
+                recorded,
+                stdin_recorded,
+            )
+        };
+
+        let _ = be.list_targets().expect("list_targets via endpoint");
+        let _ = be.liveness(&PaneId::new("%7")).expect("liveness via endpoint");
+        let _ = be
+            .inject(
+                &Target::Pane(PaneId::new("%7")),
+                &InjectPayload::Text("hello leader".to_string()),
+                Key::Enter,
+                true,
+            )
+            .expect("inject via endpoint");
+
+        let calls = rec.lock().unwrap().clone();
+        assert!(
+            calls.len() >= 5,
+            "fixture must exercise list-panes, display-message, buffer/paste, and send-keys; got {calls:?}"
+        );
+        for call in &calls {
+            assert!(
+                call.starts_with(&["tmux".to_string(), "-S".to_string(), endpoint.to_string()]),
+                "leader receiver list/liveness/inject must use tmux -S <full socket path>; got {call:?}"
+            );
+            assert!(
+                !call.windows(2).any(|w| w == ["-L".to_string(), endpoint.to_string()]),
+                "leader receiver full endpoint must never be reconstructed with -L; got {call:?}"
+            );
+        }
+        assert!(
+            calls.iter().any(|call| call.iter().any(|arg| arg == "list-panes"))
+                && calls.iter().any(|call| call.iter().any(|arg| arg == "display-message"))
+                && calls.iter().any(|call| call.iter().any(|arg| arg == "paste-buffer"))
+                && calls.iter().any(|call| call.iter().any(|arg| arg == "send-keys")),
+            "contract must cover liveness/list/inject command shapes; got {calls:?}"
+        );
+    }
+
+    #[test]
+    fn leader_receiver_short_endpoint_must_not_reconstruct_tmux_l_socket() {
+        let endpoint = "dl9aa40c88";
+        let (be, rec) = {
+            let recorded = Arc::new(Mutex::new(Vec::new()));
+            let runner = MockCommandRunner {
+                recorded: Arc::clone(&recorded),
+                stdin_recorded: Arc::new(Mutex::new(Vec::new())),
+                queue: Mutex::new(vec![MockResp::Out(ok(""))].into_iter().collect()),
+                default: MockResp::Out(ok("")),
+            };
+            (
+                TmuxBackend::with_runner_for_tmux_endpoint(Box::new(runner), endpoint),
+                recorded,
+            )
+        };
+
+        let _ = be.list_targets().expect("short endpoint should not become -L");
+
+        let calls = rec.lock().unwrap().clone();
+        assert!(
+            calls.iter().all(|call| !call.windows(2).any(|w| w == ["-L".to_string(), endpoint.to_string()])),
+            "non-canonical leader endpoints must be rejected or left unbound, never reconstructed as \
+             tmux -L <short> under the coordinator socket root; calls={calls:?}"
+        );
+    }
+
     // ── 1. has_session: exit 0 -> true, exit 1 -> false; argv = `tmux has-session -t <s>` ──────────
     #[test]
     fn has_session_argv_and_exit_code_maps_to_bool() {

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);

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