@team-agent/installer 0.3.16 → 0.3.17

package/Cargo.lock

@@ -566,7 +566,7 @@ dependencies = [
 
 [[package]]
 name = "team-agent"
-version = "0.3.16"
+version = "0.3.17"
 dependencies = [
  "anyhow",
  "chrono",

package/Cargo.toml

@@ -9,7 +9,7 @@ members = ["crates/team-agent"]
 
 [workspace.package]
 edition = "2021"
-version = "0.3.16"
+version = "0.3.17"
 license = "AGPL-3.0"
 rust-version = "1.95"
 

package/crates/team-agent/src/cli/mod.rs

@@ -3019,7 +3019,7 @@ pub mod leader_port {
         provider: crate::provider::Provider,
         _confirm: bool,
     ) -> Result<Value, CliError> {
-        let result = crate::leader::attach_leader(workspace, pane, provider)
+        let result = crate::leader::attach_leader(workspace, team, pane, provider)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let requeued =
             attach_requeued_exhausted_watchers(workspace, result.bound_pane_id.as_ref())?;

package/crates/team-agent/src/cli/tests/base.rs

@@ -90,6 +90,16 @@ use super::*;
         );
     }
 
+    #[test]
+    fn leader_launcher_args_external_leader_after_dashdash_is_provider_arg() {
+        let got = leader_launcher_args(&["--".into(), "--external-leader".into()]).unwrap();
+        assert!(!got.external_leader);
+        assert_eq!(
+            got.provider_args,
+            vec!["--".to_string(), "--external-leader".to_string()]
+        );
+    }
+
     #[test]
     fn leader_launcher_args_attach_session_spaced() {
         // golden: ["--attach-session","mysess"] -> attach_session="mysess"

package/crates/team-agent/src/leader/lease.rs

@@ -1,6 +1,7 @@
 //! leader::lease — attach / claim / autobind 统一 CAS 路径 + claim_lease_no_incident
 //! + 双写 / 分叉检测。
 
+use std::collections::BTreeSet;
 use std::path::Path;
 
 use serde_json::{json, Value};
@@ -25,27 +26,34 @@ use super::{
 /// 整段临界区做 state 变更 + 事件 + 双写 + requeue exhausted watchers。
 pub fn attach_leader(
     workspace: &Path,
+    team: Option<&str>,
     pane: Option<&PaneId>,
     provider: Provider,
 ) -> Result<LeaseResult, LeaderError> {
     let event_log = crate::event_log::EventLog::new(workspace);
-    let mut state = crate::state::persist::load_runtime_state(workspace)?;
-    let targets = crate::tmux_backend::TmuxBackend::for_workspace(workspace)
-        .list_targets()
-        .unwrap_or_default();
+    let scoped_team = team.filter(|value| !value.is_empty());
+    let mut state = if scoped_team.is_some() {
+        crate::state::projection::select_runtime_state(workspace, scoped_team)?
+    } else {
+        crate::state::persist::load_runtime_state(workspace)?
+    };
+    let targets = attach_leader_targets(workspace, &state);
     let pane_id = pane
         .cloned()
         .or_else(|| std::env::var("TMUX_PANE").ok().filter(|p| !p.is_empty()).map(PaneId::new))
         .ok_or_else(|| LeaderError::Validation("tmux pane not found".to_string()))?;
     let non_empty_pane_id = NonEmptyPaneId::try_from_pane(&pane_id)?;
-    let Some(target) = targets.iter().find(|target| target.pane_id == pane_id) else {
+    let Some(target) = targets.iter().find(|target| target.info.pane_id == pane_id) else {
         return Err(LeaderError::Validation(format!("tmux pane not found: {pane_id}")));
     };
-    let mut receiver = receiver_for_attach_target(workspace, &state, target, provider, Discovery::ExplicitPane)?;
-    let validation = validate_attach_target(workspace, &state, target);
+    let mut receiver = receiver_for_attach_target(workspace, &state, &target.info, provider, Discovery::ExplicitPane)?;
+    if let Some(endpoint) = target.endpoint.as_ref() {
+        receiver.tmux_socket = Some(endpoint.clone());
+    }
+    let validation = validate_attach_target(workspace, &state, &target.info);
     if validation.is_err() {
-        let pane_info = pane_info_value(target);
-        let targets_value = Value::Array(targets.iter().map(pane_info_value).collect());
+        let pane_info = pane_info_value(&target.info);
+        let targets_value = Value::Array(targets.iter().map(|target| pane_info_value(&target.info)).collect());
         let owner_record = state_owner(&state);
         if let Some((readopted, validation)) = crate::leader::try_readopt_leader_pane(
             workspace,
@@ -85,7 +93,7 @@ pub fn attach_leader(
     let epoch = current_owner_epoch(&state);
     if state.get("team_owner").is_some() {
         write_receiver_to_state(&mut state, &receiver)?;
-        write_lease_dual_state(workspace, &state)?;
+        write_claim_state(workspace, &state, scoped_team, None)?;
         event_log.write(
             super::LeaderEvent::ReceiverAttached.name(),
             json!({"pane_id": pane_id.as_str(), "owner_epoch": epoch.0}),
@@ -108,7 +116,7 @@ pub fn attach_leader(
     receiver.leader_session_uuid = Some(identity.leader_session_uuid.clone());
     let owner = make_owner(provider, &non_empty_pane_id, &identity, next_epoch);
     write_binding_to_state(&mut state, &receiver, &owner)?;
-    write_lease_dual_state(workspace, &state)?;
+    write_claim_state(workspace, &state, scoped_team, None)?;
     event_log.write(
         super::LeaderEvent::ReceiverAttached.name(),
         json!({"pane_id": pane_id.as_str(), "owner_epoch": next_epoch.0}),
@@ -126,6 +134,80 @@ pub fn attach_leader(
     })
 }
 
+#[derive(Clone)]
+struct AttachLeaderTarget {
+    info: PaneInfo,
+    endpoint: Option<String>,
+}
+
+fn attach_leader_targets(workspace: &Path, state: &Value) -> Vec<AttachLeaderTarget> {
+    let mut targets = Vec::new();
+    for endpoint in state_recorded_tmux_endpoints(state) {
+        let backend = tmux_backend_for_endpoint(&endpoint);
+        targets.extend(
+            backend
+                .list_targets()
+                .unwrap_or_default()
+                .into_iter()
+                .map(|info| AttachLeaderTarget {
+                    info,
+                    endpoint: Some(endpoint.clone()),
+                }),
+        );
+    }
+    targets.extend(
+        crate::tmux_backend::TmuxBackend::for_workspace(workspace)
+            .list_targets()
+            .unwrap_or_default()
+            .into_iter()
+            .map(|info| AttachLeaderTarget { info, endpoint: None }),
+    );
+    targets
+}
+
+fn tmux_backend_for_endpoint(endpoint: &str) -> crate::tmux_backend::TmuxBackend {
+    if endpoint.is_empty() || endpoint == "default" {
+        crate::tmux_backend::TmuxBackend::new()
+    } else if Path::new(endpoint).is_absolute() {
+        crate::tmux_backend::TmuxBackend::for_tmux_endpoint(endpoint)
+    } else {
+        crate::tmux_backend::TmuxBackend::for_socket_name(endpoint)
+    }
+}
+
+fn state_recorded_tmux_endpoints(state: &Value) -> BTreeSet<String> {
+    let mut out = BTreeSet::new();
+    push_state_tmux_endpoints(state, &mut out);
+    if let Some(teams) = state.get("teams").and_then(Value::as_object) {
+        for team_state in teams.values() {
+            push_state_tmux_endpoints(team_state, &mut out);
+        }
+    }
+    out
+}
+
+fn push_state_tmux_endpoints(state: &Value, out: &mut BTreeSet<String>) {
+    for key in ["tmux_socket", "tmux_endpoint"] {
+        if let Some(endpoint) = state
+            .get(key)
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+        {
+            out.insert(endpoint.to_string());
+        }
+    }
+    for key in ["team_owner", "leader_receiver"] {
+        if let Some(endpoint) = state
+            .get(key)
+            .and_then(|value| value.get("tmux_socket"))
+            .and_then(Value::as_str)
+            .filter(|value| !value.is_empty())
+        {
+            out.insert(endpoint.to_string());
+        }
+    }
+}
+
 fn requeue_exhausted_watchers_after_attach(
     workspace: &Path,
     state: &Value,

package/crates/team-agent/src/leader/start.rs

@@ -205,6 +205,9 @@ pub fn execute_leader_plan(
                 .unwrap_or_else(|| "signal".to_string())
         )));
     }
+    if plan.is_external_leader {
+        persist_external_leader_topology_marker(plan, workspace)?;
+    }
     if detached {
         Ok(LeaderLaunchOutcome {
             status: LeaderLaunchStatus::Detached,
@@ -529,6 +532,41 @@ fn persist_managed_leader_binding(
     Ok(())
 }
 
+fn persist_external_leader_topology_marker(
+    plan: &LeaderStartPlan,
+    workspace: &Path,
+) -> Result<(), LeaderError> {
+    let identity = plan
+        .identity
+        .as_ref()
+        .ok_or_else(|| LeaderError::Start("external leader identity missing".to_string()))?;
+    let mut state = crate::state::persist::load_runtime_state(workspace)
+        .unwrap_or_else(|_| serde_json::json!({}));
+    if let Some(obj) = state.as_object_mut() {
+        obj.entry("workspace".to_string()).or_insert_with(|| {
+            serde_json::json!(resolve_workspace_for_hash(workspace).to_string_lossy().to_string())
+        });
+        obj.entry("active_team_key".to_string())
+            .or_insert_with(|| serde_json::json!(identity.team_id.as_str()));
+        if let Some(session) = plan.session_name.as_ref() {
+            obj.entry("session_name".to_string())
+                .or_insert_with(|| serde_json::json!(session.as_str()));
+        }
+        obj.insert("is_external_leader".to_string(), serde_json::json!(true));
+    }
+    let entry = crate::state::projection::compact_team_state(&state);
+    if let Some(obj) = state.as_object_mut() {
+        let teams = obj
+            .entry("teams".to_string())
+            .or_insert_with(|| serde_json::json!({}));
+        if let Some(teams) = teams.as_object_mut() {
+            teams.insert(identity.team_id.as_str().to_string(), entry);
+        }
+    }
+    crate::state::persist::save_runtime_state(workspace, &state)?;
+    Ok(())
+}
+
 fn insert_detach_flag(argv: &mut Vec<String>) -> bool {
     if argv.iter().any(|arg| arg == "-d") {
         return false;

package/crates/team-agent/src/leader/tests/lease_api.rs

@@ -14,7 +14,7 @@ use super::*;
     fn attach_leader_errors_when_pane_not_resolvable() {
         let ws = std::env::temp_dir().join(format!("ta_rs_attach_{}", std::process::id()));
         std::fs::create_dir_all(&ws).unwrap();
-        let r = attach_leader(&ws, Some(&PaneId::new("%1")), Provider::Codex);
+        let r = attach_leader(&ws, None, Some(&PaneId::new("%1")), Provider::Codex);
         // 不可解析 pane → Err(Validation),错误串提及 pane not found。
         match r {
             Err(LeaderError::Validation(msg)) => {
@@ -39,7 +39,7 @@ use super::*;
         let ws = std::env::temp_dir().join(format!("ta_rs_attach_ok_{}", std::process::id()));
         std::fs::create_dir_all(&ws).unwrap();
         let pane = PaneId::new("%1");
-        let r = attach_leader(&ws, Some(&pane), Provider::Codex).unwrap();
+        let r = attach_leader(&ws, None, Some(&pane), Provider::Codex).unwrap();
         assert!(r.ok);
         assert_eq!(r.status, LeaseStatus::Claimed);
         let owner = r.owner.as_ref().expect("attach 成功必带 owner");

package/package.json

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