@team-agent/installer 0.5.1 → 0.5.3

package/crates/team-agent/src/lifecycle/restart/agent.rs

@@ -559,25 +559,17 @@ pub(super) fn drain_old_pane_and_pid(
     })
 }
 
-/// Best-effort liveness probe for a pid. Returns true if the pid exists
-/// on Unix (signal 0). On other platforms, returns true conservatively.
+/// Best-effort liveness probe for a pid.
+///
+/// 0.5.x Windows portability Batch 3: routes through
+/// `crate::platform::process::pid_is_alive`. Unix uses `kill(pid, 0)`
+/// with the `EPERM = Live` branch preserved byte-for-byte; Windows
+/// uses `OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION)` +
+/// `GetExitCodeProcess` (STILL_ACTIVE = Live). The legacy non-Unix
+/// `true` fallback (which broke drain by reporting every pid alive)
+/// is gone.
 pub(super) fn pid_is_alive(pid: u32) -> bool {
-    #[cfg(unix)]
-    {
-        // SAFETY: kill(pid, 0) checks if pid exists without sending a signal.
-        let ret = unsafe { libc::kill(pid as i32, 0) };
-        if ret == 0 {
-            return true;
-        }
-        // EPERM also means the process exists (we just can't signal it).
-        let err = std::io::Error::last_os_error();
-        matches!(err.raw_os_error(), Some(libc::EPERM))
-    }
-    #[cfg(not(unix))]
-    {
-        let _ = pid;
-        true
-    }
+    crate::platform::process::pid_is_alive(pid)
 }
 
 /// Read state.agents[agent_id].pane_pid (u32) from the runtime state.

package/crates/team-agent/src/lifecycle/restart/common.rs

@@ -467,6 +467,22 @@ pub(super) fn start_coordinator_for_workspace(workspace: &Path) -> Result<bool,
 /// only within `lifecycle::restart`. Sharing the resolver across the lifecycle
 /// module is the correct ownership: restart/add/fork all need the SAME socket
 /// the live team uses, and duplicating the lookup invited drift.**
+/// 0.5.x Phase 1d Batch 1: this legacy resolver stays tmux-only. It
+/// still returns a concrete `TmuxBackend` because the 6 caller sites
+/// (rebuild/agent/remove/launch) currently call `TmuxBackend`-specific
+/// methods (`.tmux_endpoint()`, `.for_workspace()`, etc.). But it now
+/// routes through the factory so its **selection semantics** match
+/// the new `lifecycle_worker_transport_for_selected_state` API:
+///
+/// - If `state.transport.kind` is `"conpty"`, this legacy tmux-typed
+///   resolver **fails-closed** with `TransportBackendKindMismatch`
+///   rather than silently returning a tmux backend that would
+///   spawn/inject into the wrong pane universe. That satisfies CR C-1
+///   fail-closed while the migration of caller sites to the generic
+///   `_transport_for_selected_state` API completes.
+/// - Otherwise (default/legacy tmux endpoint), behavior is preserved
+///   byte-for-byte through
+///   `tmux_backend_for_runtime_state_or_workspace`.
 pub(crate) fn lifecycle_worker_tmux_backend_for_selected_state(
     run_workspace: &Path,
     team: Option<&str>,
@@ -485,12 +501,66 @@ pub(crate) fn lifecycle_worker_tmux_backend_for_selected_state(
             .unwrap_or("");
         return Err(LifecycleError::TeamSelect(format!("{reason}: {detail}")));
     }
+    // CR C-1 fail-closed: state with `transport.kind=conpty` must NOT
+    // silently downgrade to a tmux backend just because the caller
+    // asked for the tmux-typed variant. Callers that see this refusal
+    // are expected to migrate to `lifecycle_worker_transport_for_selected_state`
+    // during Batch 2/3.
+    if let Some(state_ref) = state.as_ref() {
+        if let Some(kind) = state_ref.pointer("/transport/kind").and_then(|v| v.as_str()) {
+            if kind.eq_ignore_ascii_case("conpty") {
+                return Err(LifecycleError::TeamSelect(format!(
+                    "backend_kind_mismatch: state.transport.kind={kind:?} but the legacy \
+                     tmux-typed lifecycle resolver was invoked; caller must migrate to \
+                     `lifecycle_worker_transport_for_selected_state` (Phase 1d Batch 2/3)"
+                )));
+            }
+        }
+    }
     Ok(state
         .as_ref()
         .map(|state| lifecycle_worker_tmux_backend_for_state(run_workspace, state))
         .unwrap_or_else(|| crate::tmux_backend::TmuxBackend::for_workspace(run_workspace)))
 }
 
+/// 0.5.x Phase 1d Batch 1: new generic-typed lifecycle resolver.
+///
+/// Same team-selection semantics as the legacy tmux-typed variant, but
+/// returns a `ResolvedTransport` from the factory so callers that can
+/// hold `Box<dyn Transport>` (or the resolved `BackendKind`) work
+/// against both tmux AND conpty state. Caller migration to this API
+/// happens across Batch 2-5.
+///
+/// Fail-closed rules follow the factory (C-1 ×2, C-2 CLI-vs-state,
+/// C-3 N38 notices via `ResolvedTransport.notices`).
+pub(crate) fn lifecycle_worker_transport_for_selected_state(
+    run_workspace: &Path,
+    team: Option<&str>,
+) -> Result<crate::transport_factory::ResolvedTransport, LifecycleError> {
+    let (state, refusal) = crate::state::projection::resolve_team_scoped_state(run_workspace, team)
+        .map_err(|e| LifecycleError::StatePersist(e.to_string()))?;
+    if let Some(refusal) = refusal {
+        let reason = refusal
+            .get("reason")
+            .and_then(|v| v.as_str())
+            .unwrap_or("team_target_unresolved");
+        let detail = refusal
+            .get("error")
+            .or_else(|| refusal.get("message"))
+            .and_then(|v| v.as_str())
+            .unwrap_or("");
+        return Err(LifecycleError::TeamSelect(format!("{reason}: {detail}")));
+    }
+    let input = crate::transport_factory::TransportFactoryInput::new(
+        run_workspace,
+        crate::transport_factory::TransportPurpose::LifecycleWorker,
+    )
+    .with_team_key(team)
+    .with_state(state.as_ref());
+    crate::transport_factory::resolve_transport(input)
+        .map_err(|e| LifecycleError::TeamSelect(e.to_string()))
+}
+
 pub(super) fn lifecycle_worker_tmux_backend_for_state(
     run_workspace: &Path,
     state: &serde_json::Value,

package/crates/team-agent/src/lifecycle/tests/agent_ops.rs

@@ -287,6 +287,7 @@ impl Drop for EnvVarGuard {
     }
 }
 
+#[cfg(unix)]
 struct TmuxShim {
     log: std::path::PathBuf,
     _path: EnvVarGuard,
@@ -297,6 +298,7 @@ struct TmuxShim {
     _real_tmux: EnvVarGuard,
 }
 
+#[cfg(unix)]
 fn install_e27_tmux_shim(expected_endpoint: &str, session_name: &str) -> TmuxShim {
     use std::os::unix::fs::PermissionsExt;
 
@@ -441,6 +443,9 @@ fn assert_only_expected_socket_used(log: &std::path::Path, expected_endpoint: &s
     }
 }
 
+// 0.5.x Windows portability Batch 5: E27 tests use a shell-script
+// tmux shim + Unix socket paths. Unix-only.
+#[cfg(unix)]
 #[test]
 #[serial_test::serial(env)]
 fn e27_stop_agent_uses_attached_explicit_state_socket() {
@@ -461,6 +466,7 @@ fn e27_stop_agent_uses_attached_explicit_state_socket() {
     );
 }
 
+#[cfg(unix)]
 #[test]
 #[serial_test::serial(env)]
 fn e27_reset_agent_uses_attached_explicit_state_socket_for_stop_and_spawn() {
@@ -491,6 +497,7 @@ fn e27_reset_agent_uses_attached_explicit_state_socket_for_stop_and_spawn() {
     );
 }
 
+#[cfg(unix)]
 #[test]
 #[serial_test::serial(env)]
 fn e27_stop_agent_expands_short_state_socket_name() {

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -2693,6 +2693,13 @@ fn quick_start_state_seeds_spec_path_workspace_leader_display_backend() {
             "tasks",
             "display_backend",
             "is_external_leader",
+            // 0.5.x Phase 1d hot-path 接线 (裁决1 msg_76e1d98202b8):
+            // `transport = { kind, source }` inserted here by
+            // `annotate_runtime_transport`. Kind is `"tmux"` for the
+            // default tmux path (byte-equivalent behavior + new metadata
+            // field); source is `"unknown"` until Phase 2 threads
+            // `ResolvedTransport.source` through the launch call site.
+            "transport",
             // 0.4.0 refactor: `team_key` added as top-level topology marker
             // alongside active_team_key (refactor-modular-architecture). The
             // owner / leader_receiver / owner_epoch invariants below still

package/crates/team-agent/src/lifecycle/tests/phase_golden.rs

@@ -558,6 +558,15 @@ fn normalize_path_string(text: &str, ctx: &NormalizeCtx) -> String {
 
 fn normalize_team_agent_binary_path(text: &str) -> String {
     let mut out = text.to_string();
+    // 0.5.0 hermetic 教训「环境路径类 token 化」的直接延伸
+    // (leader msg_6ee04cf5aee8):归一化改为结构判据,不绑路径前缀。
+    // 用户 CARGO_TARGET_DIR 可以指到任意目录(默认 `<repo>/target`,
+    // 全局改道时是 `/Volumes/nvme/cargo-target`,CI 时可能是别的)。
+    // 结构判据:任意绝对路径下的 `/deps/team_agent-<hex>`(可选 `.exe`)
+    // → `<TEAM_AGENT_BIN>`。同时保留旧 marker 兼容(处理旧固定字符串
+    // 出现在 output 里,以及 `debug/team-agent` / `release/team-agent`
+    // 这两个非 `/deps/` 分支)。
+    out = normalize_deps_team_agent_by_structure(&out);
     for marker in [
         "/target/debug/deps/team_agent-",
         "/target/debug/team-agent",
@@ -568,6 +577,60 @@ fn normalize_team_agent_binary_path(text: &str) -> String {
     out
 }
 
+/// Structural (path-prefix-independent) normalization for
+/// `/…/deps/team_agent-<hex>(.exe)?` occurrences. Scans the input for
+/// every `/deps/team_agent-` marker and rewrites the containing
+/// absolute path token to `<TEAM_AGENT_BIN>`, no matter which
+/// `CARGO_TARGET_DIR` produced it.
+fn normalize_deps_team_agent_by_structure(text: &str) -> String {
+    const MARKER: &str = "/deps/team_agent-";
+    let mut out = String::with_capacity(text.len());
+    let bytes = text.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        let Some(rel) = text[i..].find(MARKER) else {
+            out.push_str(&text[i..]);
+            break;
+        };
+        let marker_idx = i + rel;
+        // Locate the start of the absolute path token: walk back from
+        // `marker_idx` while the byte is not one of a small set of
+        // delimiters (quote, whitespace, `[`, `(`, `,`, `:` after
+        // whitespace). The absolute-path anchor MUST also start with
+        // `/` — if the containing token is not absolute, skip
+        // rewriting so we don't eat unrelated text.
+        let path_start = text[..marker_idx]
+            .rfind(|c: char| matches!(c, '"' | '\'' | ' ' | '[' | '(' | ',' | '\n' | '\t'))
+            .map(|idx| idx + 1)
+            .unwrap_or(0);
+        // Confirm the token starts with `/` (absolute path).
+        if !text[path_start..].starts_with('/') {
+            // Not an absolute path — leave alone.
+            out.push_str(&text[i..marker_idx + MARKER.len()]);
+            i = marker_idx + MARKER.len();
+            continue;
+        }
+        // Extend the end past the hex hash + optional `.exe`. Same
+        // continuation rule as `replace_path_with_marker`: alnum + `-`
+        // + `_` + `.`.
+        let mut path_end = marker_idx + MARKER.len();
+        while path_end < text.len() {
+            let ch = text[path_end..].chars().next().expect("char at boundary");
+            if ch.is_ascii_alphanumeric() || matches!(ch, '-' | '_' | '.') {
+                path_end += ch.len_utf8();
+            } else {
+                break;
+            }
+        }
+        // Emit everything up to the path start, then the token, then
+        // continue past the eaten span.
+        out.push_str(&text[i..path_start]);
+        out.push_str("<TEAM_AGENT_BIN>");
+        i = path_end;
+    }
+    out
+}
+
 fn replace_path_with_marker(mut text: String, marker: &str, token: &str) -> String {
     let mut search_from = 0;
     while let Some(offset) = text[search_from..].find(marker) {

package/crates/team-agent/src/mcp_server/wire.rs

@@ -314,14 +314,13 @@ fn non_empty_env(key: &str) -> Option<String> {
         .filter(|value| !value.is_empty())
 }
 
-#[cfg(unix)]
+// 0.5.x Windows portability Batch 3: parent-pid probe routes through
+// `crate::platform::process::current_parent_pid`. Unix uses
+// `libc::getppid`; Windows uses Toolhelp32Snapshot. Both return
+// `Option<u32>`; the legacy `0` fallback (which would have silently
+// degraded MCP metadata + orphan detection on Windows) is gone.
 fn parent_pid() -> u32 {
-    u32::try_from(unsafe { libc::getppid() }).unwrap_or(0)
-}
-
-#[cfg(not(unix))]
-fn parent_pid() -> u32 {
-    0
+    crate::platform::process::current_parent_pid().unwrap_or(0)
 }
 
 fn error_response_value(id: RpcId, code: i64, message: String) -> Value {