@team-agent/installer 0.5.49 → 0.5.51

package/crates/team-agent/src/cli/send/coordinator.rs

@@ -0,0 +1,163 @@
+use super::*;
+
+pub(super) fn dirty_topology_refusal_value(
+    selected: &crate::state::selector::SelectedTeam,
+    requested_team: Option<&str>,
+) -> Option<Value> {
+    let issue_ids = crate::topology::restart_dirty_topology_issue_ids(&selected.state);
+    if issue_ids.is_empty() {
+        return None;
+    }
+    let session_name = selected
+        .state
+        .get("session_name")
+        .and_then(Value::as_str)
+        .unwrap_or_default()
+        .to_string();
+    let reason = issue_ids
+        .first()
+        .cloned()
+        .unwrap_or_else(|| "dirty_topology".to_string());
+    let repair_team = requested_team
+        .filter(|team| !team.is_empty())
+        .unwrap_or(selected.team_key.as_str());
+    Some(json!({
+        "ok": false,
+        "status": "refused_dirty_topology",
+        "reason": reason,
+        "session_name": session_name,
+        "error": "send refused: tmux endpoint/socket topology is inconsistent; run diagnose from the intended leader socket before sending",
+        "issues": issue_ids
+            .iter()
+            .map(|id| json!({"id": id}))
+            .collect::<Vec<_>>(),
+        "next_actions": [
+            "team-agent diagnose --json",
+            format!("team-agent claim-leader --team {repair_team} --confirm --json"),
+            format!("team-agent takeover --team {repair_team} --confirm --json")
+        ],
+    }))
+}
+
+pub(super) fn target_has_known_worker(state: &Value, target: &MessageTarget, sender: &str) -> bool {
+    let Some(agents) = state.get("agents").and_then(Value::as_object) else {
+        return false;
+    };
+    match target {
+        MessageTarget::Single(target) => agents.contains_key(target),
+        MessageTarget::Broadcast => agents.keys().any(|agent| agent != sender),
+        MessageTarget::Fanout(recipients) => recipients
+            .iter()
+            .any(|recipient| agents.contains_key(recipient)),
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(super) struct LoudEnsureResult {
+    previous_status: String,
+    start: crate::coordinator::StartReport,
+}
+
+pub(super) fn loud_ensure_coordinator(
+    selected: &crate::state::selector::SelectedTeam,
+) -> Result<Option<LoudEnsureResult>, CliError> {
+    if in_process_unit_test() {
+        return Ok(None);
+    }
+    let workspace = crate::coordinator::WorkspacePath::new(selected.run_workspace.clone());
+    let previous = crate::coordinator::coordinator_health(&workspace);
+    if previous.ok {
+        return Ok(None);
+    }
+    if previous.service_available
+        && matches!(
+            previous.binary_identity_relation,
+            crate::coordinator::CoordinatorBinaryIdentityRelation::DaemonNewerThanCaller
+        )
+    {
+        return Ok(None);
+    }
+    let previous_status = coordinator_health_status_wire(previous.status).to_string();
+    let start = crate::coordinator::start_coordinator_with_team(
+        &workspace,
+        Some(selected.team_key.as_str()),
+    )
+    .map_err(|error| CliError::Runtime(error.to_string()))?;
+    if !start.ok {
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    if matches!(
+        start.status,
+        crate::coordinator::StartOutcome::Started
+            | crate::coordinator::StartOutcome::StartedAfterRotation
+    ) {
+        crate::event_log::EventLog::new(&selected.run_workspace)
+            .write(
+                "coordinator.ensure_restarted",
+                json!({
+                    "coordinator_previous_status": previous_status,
+                    "status": start.status,
+                    "pid": start.pid.map(|pid| pid.get()),
+                    "previous_pid": start.previous_pid.map(|pid| pid.get()),
+                    "binary_path": start.binary_path,
+                    "binary_version": start.binary_version,
+                    "rotation_reason": start.rotation_reason,
+                }),
+            )
+            .map_err(|error| CliError::Runtime(error.to_string()))?;
+        return Ok(Some(LoudEnsureResult {
+            previous_status,
+            start,
+        }));
+    }
+    Ok(None)
+}
+
+#[cfg(test)]
+pub(super) fn in_process_unit_test() -> bool {
+    true
+}
+
+#[cfg(not(test))]
+pub(super) fn in_process_unit_test() -> bool {
+    false
+}
+
+pub(super) fn append_loud_ensure_fields(value: &mut Value, ensure: Option<&LoudEnsureResult>) {
+    let Some(ensure) = ensure else {
+        return;
+    };
+    if !ensure.start.ok {
+        return;
+    }
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("coordinator_auto_restarted".to_string(), json!(true));
+        obj.insert(
+            "coordinator_previous_status".to_string(),
+            json!(ensure.previous_status),
+        );
+        obj.insert(
+            "coordinator".to_string(),
+            coordinator_start_json(&ensure.start),
+        );
+    }
+}
+
+pub(super) fn coordinator_start_json(report: &crate::coordinator::StartReport) -> Value {
+    let summary = crate::lifecycle::CoordinatorStartSummary::from_start_report(report);
+    crate::lifecycle::coordinator_start_summary_value(&summary)
+}
+
+pub(super) fn coordinator_health_status_wire(
+    status: crate::coordinator::CoordinatorHealthStatus,
+) -> &'static str {
+    match status {
+        crate::coordinator::CoordinatorHealthStatus::Missing => "missing",
+        crate::coordinator::CoordinatorHealthStatus::InvalidPid => "invalid_pid",
+        crate::coordinator::CoordinatorHealthStatus::Running => "running",
+        crate::coordinator::CoordinatorHealthStatus::Stale => "stale",
+    }
+}

package/crates/team-agent/src/cli/send/mailbox.rs

@@ -0,0 +1,99 @@
+use super::*;
+
+pub(super) fn maybe_enqueue_offline_leader_mailbox(
+    sender_workspace: &Path,
+    to_name: &str,
+    content: &str,
+    sender: &str,
+    task_id: Option<&str>,
+    error: &crate::cli::named_address::NamedAddressError,
+) -> Result<Option<Value>, CliError> {
+    if error.kind != crate::cli::named_address::NamedAddressErrorKind::LeaderNotAttached {
+        return Ok(None);
+    }
+    let parsed = match crate::cli::named_address::parse_leader_target_workspace_and_team(
+        sender_workspace,
+        to_name,
+    ) {
+        Ok(Some(v)) => v,
+        Ok(None) => return Ok(None),
+        Err(_) => return Ok(None),
+    };
+    let (target_workspace, team_key) = parsed;
+    // Owner-scope refusal: sender workspace == target workspace. Keep
+    // the actionable attach hint (owner sees status/diagnose copy that
+    // points at `attach-leader`).
+    let sender_canonical =
+        std::fs::canonicalize(sender_workspace).unwrap_or_else(|_| sender_workspace.to_path_buf());
+    let target_canonical =
+        std::fs::canonicalize(&target_workspace).unwrap_or_else(|_| target_workspace.clone());
+    if sender_canonical == target_canonical {
+        return Ok(None);
+    }
+    // Verify the target team is actually alive on this host — mailbox
+    // is only for `team live + leader unattached`. Fail-closed otherwise
+    // so we never leave a message in a permanently-dead workspace's DB.
+    let state = match crate::state::persist::load_runtime_state(&target_workspace) {
+        Ok(s) => s,
+        Err(_) => return Ok(None),
+    };
+    let team_alive = target_team_is_alive_for_mailbox(&state, &team_key);
+    if !team_alive {
+        return Ok(None);
+    }
+    let event_log = crate::event_log::EventLog::new(&target_workspace);
+    let task = task_id.map(|s| crate::model::ids::TaskId::new(s.to_string()));
+    let outcome = messaging::enqueue_leader_mailbox_until_attach(
+        &target_workspace,
+        &team_key,
+        content,
+        task.as_ref(),
+        sender,
+        &event_log,
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let message_id = outcome.message_id.clone().unwrap_or_else(|| "".to_string());
+    Ok(Some(json!({
+        "ok": true,
+        "status": "queued_until_leader_attach",
+        "message_status": "queued_until_leader_attach",
+        "channel": "leader_mailbox",
+        "delivered": false,
+        "to_name": to_name,
+        "target_workspace": target_workspace.display().to_string(),
+        "team_key": team_key,
+        "recipient": "leader",
+        "leader_attached": false,
+        "message_id": message_id,
+    })))
+}
+
+/// Positive-source liveness heuristic per offline-mailbox-toname-design.md §4:
+/// - target workspace has state and the team key is present + not archived/down;
+/// - AND at least one live tmux fact — a persisted `session_name` OR any
+///   agent with a recorded pane on the recorded socket.
+///
+/// We deliberately do NOT poll coordinator health here — enqueuing is
+/// safe even when the coordinator is transiently down; attach-leader
+/// itself replays via `requeue_blocked_leader_messages` regardless.
+pub(super) fn target_team_is_alive_for_mailbox(state: &Value, team_key: &str) -> bool {
+    let team = state
+        .get("teams")
+        .and_then(|v| v.as_object())
+        .and_then(|teams| teams.get(team_key));
+    let Some(team) = team else {
+        return false;
+    };
+    let status = team
+        .get("status")
+        .and_then(|v| v.as_str())
+        .unwrap_or("alive");
+    if matches!(status, "archived" | "down" | "stopped") {
+        return false;
+    }
+    // A recorded session_name is enough — target's coordinator/attach
+    // path will re-verify tmux presence when the replay fires.
+    team.get("session_name")
+        .and_then(|v| v.as_str())
+        .is_some_and(|s| !s.is_empty())
+}

package/crates/team-agent/src/cli/send/persist.rs

@@ -0,0 +1,154 @@
+use super::coordinator::{
+    append_loud_ensure_fields, dirty_topology_refusal_value, loud_ensure_coordinator,
+    target_has_known_worker,
+};
+use super::presentation::delivery_outcome_json;
+use crate::cli::{CliError, SendArgs};
+use crate::messaging::{
+    self, DeliveryOutcome, DeliveryStatus, MessageTarget, SendOptions, SendOrigin,
+};
+use crate::model::ids::{TaskId, TeamKey};
+use serde_json::{json, Value};
+use std::path::Path;
+
+/// Translate SendArgs into the persisted-send options.
+pub fn send_options_from_args(args: &SendArgs) -> SendOptions {
+    SendOptions {
+        origin: SendOrigin::Cli,
+        task_id: args.task.as_ref().map(|s| TaskId::new(s.clone())),
+        route_task_id: true,
+        sender: args.sender.clone(),
+        requires_ack: !args.no_ack,
+        confirm_human: args.confirm_human,
+        wait_visible: !args.no_wait,
+        timeout: args.timeout,
+        watch_result: args.watch_result,
+        team: args.team.as_ref().map(|s| TeamKey::new(s.clone())),
+        message_id: args.message_id.clone(),
+        ..SendOptions::default()
+    }
+}
+
+pub(super) fn persist_resolved_target(
+    args: &SendArgs,
+    resolved: &crate::cli::named_address::ResolvedNamedAddress,
+    target: &MessageTarget,
+    content: &str,
+) -> Result<Value, CliError> {
+    let selected = crate::state::selector::resolve_active_team(
+        &resolved.target_workspace,
+        resolved.team_key.as_deref(),
+        crate::state::selector::SelectorMode::RuntimeOnly,
+    )?;
+    if let Some(value) = dirty_topology_refusal_value(&selected, resolved.team_key.as_deref()) {
+        return Ok(value);
+    }
+    let mut opts = send_options_from_args(args);
+    opts.route_task_id = args.to_name.is_none() && args.to_leader.is_none();
+    opts.team = Some(TeamKey::new(selected.team_key.clone()));
+    let coordinator_ensure =
+        if target_has_known_worker(&selected.state, target, opts.sender.as_str()) {
+            loud_ensure_coordinator(&selected)?
+        } else {
+            None
+        };
+    let outcome = messaging::send_message(&selected.run_workspace, target, content, &opts)?;
+    let mut value = delivery_outcome_json(&outcome, target, content, &opts);
+    append_loud_ensure_fields(&mut value, coordinator_ensure.as_ref());
+    Ok(value)
+}
+
+pub(super) fn routing_ambiguous_value(
+    workspace: &Path,
+    args: &SendArgs,
+    target: &MessageTarget,
+    content: &str,
+    opts: &SendOptions,
+) -> Option<Value> {
+    if args.targets.is_some() || !content.is_empty() {
+        return None;
+    }
+    let MessageTarget::Single(name) = target else {
+        return None;
+    };
+    if name.is_empty() {
+        return None;
+    }
+    let state = crate::state::persist::load_runtime_state(workspace).ok()?;
+    let in_team = state
+        .get("agents")
+        .and_then(|v| v.as_object())
+        .is_some_and(|a| a.contains_key(name));
+    if in_team {
+        return None;
+    }
+    // aeab1c7 follow-up: `content` is no longer emitted anywhere from `send`
+    // responses (including this refusal). Replace with `content_length_bytes`
+    // to keep the size-sanity field consistent with the normal-send shape.
+    Some(json!({
+        "ok": false,
+        "status": "refused",
+        "target": null,
+        "agent_id": null,
+        "content_length_bytes": name.len(),
+        "sender": opts.sender,
+        "message_id": null,
+        "message_status": "refused",
+        "verification": null,
+        "stage": null,
+        "reason": "routing_ambiguous",
+        "channel": null,
+    }))
+}
+
+pub(super) fn selected_state_with_active_key(
+    selected: &crate::state::selector::SelectedTeam,
+) -> Value {
+    let mut state = selected.state.clone();
+    if let Some(obj) = state.as_object_mut() {
+        obj.insert(
+            "active_team_key".to_string(),
+            Value::String(selected.team_key.clone()),
+        );
+    }
+    state
+}
+
+pub(super) fn initial_delivery_allows_watch(status: DeliveryStatus) -> bool {
+    matches!(
+        status,
+        DeliveryStatus::Delivered | DeliveryStatus::AlreadyDelivered
+    )
+}
+
+pub(super) fn observe_initial_delivery_for_watch(
+    selected: &crate::state::selector::SelectedTeam,
+    target: &MessageTarget,
+    outcome: &DeliveryOutcome,
+    opts: &SendOptions,
+) -> Result<DeliveryOutcome, CliError> {
+    if !matches!(target, MessageTarget::Single(agent) if !agent.is_empty()) {
+        return Ok(outcome.clone());
+    }
+    if !matches!(outcome.status, DeliveryStatus::Queued) {
+        return Ok(outcome.clone());
+    }
+    let Some(message_id) = outcome.message_id.as_deref() else {
+        return Ok(outcome.clone());
+    };
+    let transport = crate::lifecycle::restart::lifecycle_worker_tmux_backend_for_selected_state(
+        &selected.run_workspace,
+        opts.team.as_ref().map(TeamKey::as_str),
+    )
+    .map_err(|e| CliError::Runtime(e.to_string()))?;
+    let event_log = crate::event_log::EventLog::new(&selected.run_workspace);
+    let state = selected_state_with_active_key(selected);
+    crate::messaging::deliver_persisted_message(
+        &selected.run_workspace,
+        &transport,
+        message_id,
+        &event_log,
+        &state,
+    )
+    .map_err(CliError::from)
+}