@team-agent/installer 0.3.7 → 0.3.8

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

@@ -18,6 +18,7 @@
 use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
 use std::io::{Read, Write};
+use std::os::unix::fs::FileTypeExt;
 use std::path::{Path, PathBuf};
 use std::process::Stdio;
 use std::time::{Duration, Instant};
@@ -331,6 +332,20 @@ pub(crate) fn socket_name_for_workspace(workspace: &Path) -> String {
 }
 
 pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
+    if let Some(existing) = existing_socket_path_for_workspace(workspace) {
+        return Some(existing);
+    }
+    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_for_workspace(workspace)))
+}
+
+pub(crate) fn socket_probe_missing_for_workspace(workspace: &Path) -> bool {
+    existing_socket_path_for_workspace(workspace).is_none()
+}
+
+fn existing_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 {
@@ -340,12 +355,19 @@ pub(crate) fn socket_path_for_workspace(workspace: &Path) -> Option<PathBuf> {
             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))
+    None
+}
+
+pub(crate) fn socket_missing_hint_for_workspace(workspace: &Path) -> String {
+    let socket_name = socket_name_for_workspace(workspace);
+    let roots = tmux_socket_roots()
+        .into_iter()
+        .map(|root| root.display().to_string())
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!(
+        "tmux socket {socket_name} not found under [{roots}]; run `team-agent attach-leader` or restart the team before attaching"
+    )
 }
 
 pub(crate) fn attach_command_for_workspace(
@@ -373,7 +395,7 @@ pub(crate) fn attach_commands_for_windows<'a>(
         .collect()
 }
 
-fn tmux_socket_roots() -> Vec<PathBuf> {
+pub(crate) 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") {
@@ -384,6 +406,29 @@ fn tmux_socket_roots() -> Vec<PathBuf> {
     roots
 }
 
+pub(crate) fn tmux_socket_endpoints() -> Vec<String> {
+    let mut endpoints = Vec::new();
+    for root in tmux_socket_roots() {
+        let Ok(entries) = std::fs::read_dir(root) else {
+            continue;
+        };
+        for entry in entries.flatten() {
+            let Ok(file_type) = entry.file_type() else {
+                continue;
+            };
+            if !file_type.is_socket() {
+                continue;
+            }
+            let path = entry.path();
+            let path = path.canonicalize().unwrap_or(path);
+            endpoints.push(path.to_string_lossy().to_string());
+        }
+    }
+    endpoints.sort();
+    endpoints.dedup();
+    endpoints
+}
+
 pub(crate) fn socket_name_from_tmux_env() -> Option<String> {
     let tmux = std::env::var("TMUX")
         .ok()
@@ -673,6 +718,10 @@ impl Transport for TmuxBackend {
         BackendKind::Tmux
     }
 
+    fn probes_real_tmux_socket_roots(&self) -> bool {
+        true
+    }
+
     fn spawn_first(
         &self,
         session: &SessionName,
@@ -859,6 +908,40 @@ impl Transport for TmuxBackend {
         }
     }
 
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        let argv = self.tmux_argv(&[
+            "tmux".to_string(),
+            "display-message".to_string(),
+            "-p".to_string(),
+            "-t".to_string(),
+            pane.as_str().to_string(),
+            "#{pane_id}".to_string(),
+        ]);
+        let output = self.runner.run(&argv)?;
+        if output.success {
+            let pane_id = output.stdout.trim();
+            if pane_id.is_empty() {
+                return Ok(Some(false));
+            }
+            if pane_id == pane.as_str()
+                && pane_id.starts_with('%')
+                && pane_id[1..].chars().all(|ch| ch.is_ascii_digit())
+            {
+                return Ok(Some(true));
+            }
+            return Ok(None);
+        }
+        let stderr = output.stderr.to_ascii_lowercase();
+        if stderr.contains("can't find pane")
+            || stderr.contains("no such pane")
+            || (stderr.contains("can't find") && stderr.contains("pane"))
+        {
+            Ok(Some(false))
+        } else {
+            Ok(None)
+        }
+    }
+
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {
         // P5 (C-P5-3): `#{pane_pid}` rides the single list-panes call (field index 11),
         // killing the per-pane display-message N+1 fallback.

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

@@ -18,18 +18,39 @@ pub struct SpawnRecord {
     pub argv: Vec<String>,
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 struct OfflineState {
     session_present: bool,
     session_absent_after_spawn_first: bool,
     targets: Vec<PaneInfo>,
     windows: Vec<WindowName>,
+    pane_presence: BTreeMap<String, bool>,
+    liveness: BTreeMap<String, PaneLiveness>,
+    default_liveness: PaneLiveness,
     calls: Vec<&'static str>,
     spawns: Vec<SpawnRecord>,
     inject_targets: Vec<Target>,
     inject_payloads: Vec<String>,
 }
 
+impl Default for OfflineState {
+    fn default() -> Self {
+        Self {
+            session_present: false,
+            session_absent_after_spawn_first: false,
+            targets: Vec::new(),
+            windows: Vec::new(),
+            pane_presence: BTreeMap::new(),
+            liveness: BTreeMap::new(),
+            default_liveness: PaneLiveness::Unknown,
+            calls: Vec::new(),
+            spawns: Vec::new(),
+            inject_targets: Vec::new(),
+            inject_payloads: Vec::new(),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub struct OfflineTransport {
     inner: Arc<Mutex<OfflineState>>,
@@ -60,6 +81,25 @@ impl OfflineTransport {
         self
     }
 
+    pub fn with_default_liveness(self, liveness: PaneLiveness) -> Self {
+        self.with_state(|state| state.default_liveness = liveness);
+        self
+    }
+
+    pub fn with_liveness(self, pane: impl Into<String>, liveness: PaneLiveness) -> Self {
+        self.with_state(|state| {
+            state.liveness.insert(pane.into(), liveness);
+        });
+        self
+    }
+
+    pub fn with_pane_presence(self, pane: impl Into<String>, present: bool) -> Self {
+        self.with_state(|state| {
+            state.pane_presence.insert(pane.into(), present);
+        });
+        self
+    }
+
     pub fn calls(&self) -> Vec<&'static str> {
         self.with_state(|state| state.calls.clone())
     }
@@ -198,9 +238,22 @@ impl Transport for OfflineTransport {
         Ok(None)
     }
 
-    fn liveness(&self, _pane: &PaneId) -> Result<PaneLiveness, TransportError> {
-        self.record("liveness");
-        Ok(PaneLiveness::Unknown)
+    fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError> {
+        Ok(self.with_state(|state| {
+            state.calls.push("liveness");
+            state
+                .liveness
+                .get(pane.as_str())
+                .copied()
+                .unwrap_or(state.default_liveness)
+        }))
+    }
+
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        Ok(self.with_state(|state| {
+            state.calls.push("has_pane");
+            state.pane_presence.get(pane.as_str()).copied()
+        }))
     }
 
     fn list_targets(&self) -> Result<Vec<PaneInfo>, TransportError> {

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

@@ -399,6 +399,12 @@ pub trait Transport: Send + Sync {
     /// 后端种类(诊断/事件用)。
     fn kind(&self) -> BackendKind;
 
+    /// Only the concrete tmux backend should scan real tmux socket roots.
+    /// Test doubles stay hermetic and use their injected probe results.
+    fn probes_real_tmux_socket_roots(&self) -> bool {
+        false
+    }
+
     // —— SPAWN(ST):所有后端天然满足;cwd/env 是 spawn 参数,无独立动词(§gap-setenv)——
 
     /// tmux=`new-session -d` / wezterm=`spawn --new-window` / conpty=`openpty`+spawn。
@@ -481,6 +487,13 @@ pub trait Transport: Send + Sync {
     /// pane 存活三态(`PaneLiveness`,bug-085 穷尽 match;unknown ≠ dead ≠ live)。
     fn liveness(&self, pane: &PaneId) -> Result<PaneLiveness, TransportError>;
 
+    /// Cheap direct pane existence check when a backend can prove it. `Ok(None)`
+    /// preserves the existing Unknown boundary.
+    fn has_pane(&self, pane: &PaneId) -> Result<Option<bool>, TransportError> {
+        let _ = pane;
+        Ok(None)
+    }
+
     // —— ENUMERATE / IDENTITY(SL + 进程探测):身份/rebind 地基 ——
 
     /// 全局枚举所有 pane + 每 pane 的 leader_env。tmux=`list-panes -a` + 读进程 env;

package/npm/install.mjs

@@ -80,13 +80,13 @@ function install(argv) {
   writeExecWrapper(path.join(binDir, "team-agent"), runtimeBinary, []);
   writeExecWrapper(path.join(binDir, "team_orchestrator"), runtimeBinary, ["mcp-server"]);
   writeExecWrapper(path.join(binDir, "team-agent-coordinator"), runtimeBinary, ["coordinator"]);
-  installSkills();
+  installSkills(runtimeBinary);
 
   const teamAgent = path.join(binDir, "team-agent");
   console.log(`installed: ${teamAgent}`);
   console.log(`runtime: ${dest}`);
   console.log(`binary: ${platformBinary.packageName}`);
-  console.log("skill: installed for Codex and Claude");
+  console.log("skill: installed for Codex, Claude and Copilot");
   console.log(`PATH: ensure ${binDir} is on PATH`);
 
   // 0.3.6 hotfix · C-5 cr verdict — post-install binary smoke 门(走 `--help`
@@ -149,14 +149,24 @@ function runDoctor(argv) {
 function uninstall(argv) {
   const opts = parseOptions(argv);
   const prefix = path.resolve(expandHome(opts.prefix || path.join(os.homedir(), ".local")));
+  // 卸载 skill 走二进制单源(同一 SkillTarget 表 codex/claude/copilot),在删 wrapper 前调
+  // (删 wrapper 后 PATH 上的 team-agent 没了,但 runtime 二进制仍在;用 runtime 二进制直调)。
+  const teamAgentBin = path.join(prefix, "bin", "team-agent");
+  if (fs.existsSync(teamAgentBin)) {
+    const res = spawnSync(teamAgentBin, ["install-skill", "--target", "all", "--uninstall", "--json"], {
+      text: true,
+      encoding: "utf8",
+      timeout: VERSION_SMOKE_TIMEOUT_MS,
+    });
+    if (res.status !== 0) {
+      console.error(`WARN: skill uninstall via binary failed (status=${res.status ?? "signal"}); skill dirs may remain under ~/.codex|.claude|.copilot/skills/team-agent`);
+    }
+  }
   for (const name of ["team-agent", "team_orchestrator", "team-agent-coordinator"]) {
     fs.rmSync(path.join(prefix, "bin", name), { force: true });
   }
-  for (const skillDir of skillDestinations()) {
-    fs.rmSync(skillDir, { recursive: true, force: true });
-  }
   console.log(`removed wrappers from ${path.join(prefix, "bin")}`);
-  console.log("removed skills from ~/.codex/skills/team-agent and ~/.claude/skills/team-agent");
+  console.log("removed skills from ~/.codex, ~/.claude and ~/.copilot skills/team-agent");
   if (opts.purgeRuntime) {
     const runtimeRoot = path.resolve(expandHome(opts.runtimeDir || path.join(os.homedir(), ".team-agent", "runtime")));
     fs.rmSync(runtimeRoot, { recursive: true, force: true });
@@ -238,46 +248,32 @@ exec ${shellQuote(binary)} ${argPrefix}"$@"
   fs.chmodSync(file, 0o755);
 }
 
-function installSkills() {
+// RED-1 根治(单源):skill 安装唯一实现在二进制 `install-skill`(SkillTarget 表:
+// codex/claude/copilot)。install.mjs 不再有自己的 JS 拷贝逻辑/目标硬编码——改调二进制,
+// 失败显式报错(非零退出),绝不静默回退 JS。
+function installSkills(runtimeBinary) {
   const source = path.join(packageRoot, "skills", "team-agent");
   if (!fs.existsSync(source)) {
     throw new Error(`skill source not found: ${source}`);
   }
-  for (const dest of skillDestinations()) {
-    fs.rmSync(dest, { recursive: true, force: true });
-    copyTree(source, dest);
+  const res = spawnSync(runtimeBinary, ["install-skill", "--target", "all", "--source", source, "--json"], {
+    text: true,
+    encoding: "utf8",
+    timeout: VERSION_SMOKE_TIMEOUT_MS,
+  });
+  if (res.status !== 0) {
+    const log = (res.stderr || res.stdout || "").trim() || "no stderr/stdout";
+    console.error(`ERROR: skill install failed (status=${res.status ?? "signal"})`);
+    console.error(`ACTION: reinstall, or run \`team-agent install-skill --target all --source ${source}\` manually`);
+    console.error(`LOG: ${runtimeBinary} install-skill --target all => ${log}`);
+    process.exit(1);
   }
 }
 
-function skillDestinations() {
-  return [
-    path.join(os.homedir(), ".codex", "skills", "team-agent"),
-    path.join(os.homedir(), ".claude", "skills", "team-agent"),
-  ];
-}
-
 function makeDoctorWorkspace() {
   return fs.mkdtempSync(path.join(os.tmpdir(), "team-agent-doctor-"));
 }
 
-function copyTree(src, dest) {
-  const stat = fs.lstatSync(src);
-  if (stat.isDirectory()) {
-    fs.mkdirSync(dest, { recursive: true, mode: stat.mode });
-    for (const entry of fs.readdirSync(src)) {
-      if (entry === ".DS_Store") {
-        continue;
-      }
-      copyTree(path.join(src, entry), path.join(dest, entry));
-    }
-    return;
-  }
-  if (stat.isFile()) {
-    fs.copyFileSync(src, dest);
-    fs.chmodSync(dest, stat.mode);
-  }
-}
-
 function expandHome(value) {
   if (value === "~") {
     return os.homedir();

package/package.json

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