@team-agent/installer 0.3.10 → 0.3.12

package/Cargo.lock

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

package/Cargo.toml

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

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

@@ -22,7 +22,9 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
     // empty message body is a prompt-only invocation (`team-agent send "fix the build"`).
     // The lone positional is CONTENT, not a target — reject with `routing_ambiguous`
     // (NOT `target_not_in_team`, which would lie that the user did pick a target).
-    if let Some(amb) = routing_ambiguous_value(&selected.run_workspace, args, &target, &content, &opts) {
+    if let Some(amb) =
+        routing_ambiguous_value(&selected.run_workspace, args, &target, &content, &opts)
+    {
         return Ok(CmdResult::from_json(amb, args.json));
     }
     let outcome = messaging::send_message(&selected.run_workspace, &target, &content, &opts)?;
@@ -117,7 +119,10 @@ fn watch_notice_json(target: &MessageTarget, opts: &SendOptions) -> Value {
     let agent_id = match target {
         MessageTarget::Single(agent) => agent.clone(),
         MessageTarget::Broadcast => "*".to_string(),
-        MessageTarget::Fanout(recipients) => recipients.first().cloned().unwrap_or_else(|| "-".to_string()),
+        MessageTarget::Fanout(recipients) => recipients
+            .first()
+            .cloned()
+            .unwrap_or_else(|| "-".to_string()),
     };
     json!({
         "status": "registered",
@@ -174,6 +179,7 @@ fn delivery_status_wire(status: DeliveryStatus) -> &'static str {
         DeliveryStatus::Queued => "queued",
         DeliveryStatus::Blocked => "blocked",
         DeliveryStatus::Refused => "refused",
+        DeliveryStatus::Degraded => "degraded",
         DeliveryStatus::RetryScheduled => "retry_scheduled",
         DeliveryStatus::TrustAutoAnswerExhausted => "trust_auto_answer_exhausted",
         DeliveryStatus::AlreadyDelivered => "already_delivered",
@@ -195,6 +201,7 @@ fn delivery_refusal_wire(reason: DeliveryRefusal) -> &'static str {
         DeliveryRefusal::TmuxTargetMissing => "tmux_target_missing",
         DeliveryRefusal::MessageAlreadyClaimed => "message_already_claimed",
         DeliveryRefusal::LeaderNotAttached => "leader_not_attached",
+        DeliveryRefusal::CoordinatorUnavailable => "coordinator_unavailable",
         DeliveryRefusal::NoCallerPane => "no_caller_pane",
         DeliveryRefusal::TeamOwnerMismatch => "team_owner_mismatch",
         DeliveryRefusal::Ambiguous => "ambiguous",

package/crates/team-agent/src/coordinator/backoff.rs

@@ -8,7 +8,7 @@ use crate::model::enums::Provider;
 use crate::provider::ProviderAdapter;
 
 use super::health::{coordinator_pid_path, write_coordinator_metadata};
-use super::tick::TickError;
+use super::tick::{TickError, TickReport};
 use super::types::{
     ErrorLists, MetadataSource, Pid, ProviderRegistry, WorkspacePath, BACKOFF_MAX_SEC,
     DEFAULT_TICK_INTERVAL_SEC,
@@ -87,7 +87,7 @@ pub fn run_daemon_with_coordinator(
             );
             break;
         }
-        match coordinator.tick() {
+        match run_tick_with_panic_marker(&event_log, || coordinator.tick()) {
             Ok(report) => {
                 if consecutive_failures > 0 {
                     event_log.write(
@@ -150,6 +150,36 @@ pub fn run_daemon_with_coordinator(
     Ok(())
 }
 
+fn run_tick_with_panic_marker<F>(event_log: &EventLog, tick: F) -> Result<TickReport, TickError>
+where
+    F: FnOnce() -> Result<TickReport, TickError>,
+{
+    match std::panic::catch_unwind(std::panic::AssertUnwindSafe(tick)) {
+        Ok(result) => result,
+        Err(payload) => {
+            let panic_message = panic_payload_message(payload.as_ref());
+            event_log.write(
+                "coordinator.tick_panic",
+                serde_json::json!({
+                    "panic": panic_message,
+                    "backtrace": std::backtrace::Backtrace::force_capture().to_string(),
+                }),
+            )?;
+            Err(TickError::Panic(panic_message))
+        }
+    }
+}
+
+fn panic_payload_message(payload: &(dyn std::any::Any + Send)) -> String {
+    if let Some(message) = payload.downcast_ref::<&str>() {
+        (*message).to_string()
+    } else if let Some(message) = payload.downcast_ref::<String>() {
+        message.clone()
+    } else {
+        "non-string panic payload".to_string()
+    }
+}
+
 /// 当前 ppid(`os.getppid()`,孤儿自检输入)。
 fn current_ppid() -> u32 {
     u32::try_from(unsafe { libc::getppid() }).unwrap_or(0)
@@ -199,3 +229,54 @@ pub enum DaemonError {
     #[error("tick: {0}")]
     Tick(#[from] TickError),
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tmp_ws(tag: &str) -> std::path::PathBuf {
+        use std::sync::atomic::{AtomicU64, Ordering};
+        static N: AtomicU64 = AtomicU64::new(0);
+        let n = N.fetch_add(1, Ordering::Relaxed);
+        let path =
+            std::env::temp_dir().join(format!("ta-rs-coord-{tag}-{}-{n}", std::process::id()));
+        std::fs::create_dir_all(&path).unwrap();
+        path
+    }
+
+    #[test]
+    fn coordinator_tick_panic_writes_durable_marker() {
+        let workspace = tmp_ws("tick-panic");
+        let event_log = EventLog::new(&workspace);
+
+        let old_hook = std::panic::take_hook();
+        std::panic::set_hook(Box::new(|_| {}));
+        let result = run_tick_with_panic_marker(&event_log, || -> Result<TickReport, TickError> {
+            panic!("synthetic tick panic")
+        });
+        std::panic::set_hook(old_hook);
+
+        assert!(
+            matches!(result, Err(TickError::Panic(message)) if message == "synthetic tick panic")
+        );
+        let events = event_log.tail(20).unwrap();
+        let panic_event = events
+            .iter()
+            .find(|event| {
+                event.get("event").and_then(serde_json::Value::as_str)
+                    == Some("coordinator.tick_panic")
+            })
+            .expect("coordinator.tick_panic event");
+        assert_eq!(
+            panic_event.get("panic").and_then(serde_json::Value::as_str),
+            Some("synthetic tick panic")
+        );
+        assert!(
+            panic_event
+                .get("backtrace")
+                .and_then(serde_json::Value::as_str)
+                .is_some_and(|backtrace| !backtrace.is_empty()),
+            "panic marker must carry a backtrace; event={panic_event}"
+        );
+    }
+}

package/crates/team-agent/src/coordinator/health.rs

@@ -1,6 +1,8 @@
 //! coordinator 健康/身份 & 只读可观测面:metadata 身份原语 + coordinator 路径 + watch 实时流。
 
 use std::io::{Read, Seek, SeekFrom};
+#[cfg(unix)]
+use std::os::unix::process::CommandExt;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 use std::time::Duration;
@@ -96,13 +98,15 @@ pub fn start_coordinator(workspace: &WorkspacePath) -> Result<StartReport, Start
         .append(true)
         .open(&log_path)?;
     let log_err = log.try_clone()?;
-    let child = Command::new(std::env::current_exe()?)
+    let mut command = Command::new(std::env::current_exe()?);
+    command
         .args(["coordinator", "--workspace"])
         .arg(workspace.as_path())
         .stdin(Stdio::null())
         .stdout(Stdio::from(log))
-        .stderr(Stdio::from(log_err))
-        .spawn()?;
+        .stderr(Stdio::from(log_err));
+    detach_daemon_child(&mut command);
+    let child = command.spawn()?;
     let pid = Pid::new(child.id());
     std::fs::write(coordinator_pid_path(workspace), pid.to_string())?;
     write_coordinator_metadata(workspace, pid, MetadataSource::Start)?;
@@ -116,6 +120,24 @@ pub fn start_coordinator(workspace: &WorkspacePath) -> Result<StartReport, Start
     })
 }
 
+#[cfg(unix)]
+fn detach_daemon_child(command: &mut Command) {
+    // The coordinator is a daemon: it must not remain in the launcher's process
+    // group, otherwise bare SSH command teardown can SIGHUP it after quick-start exits.
+    unsafe {
+        command.pre_exec(|| {
+            if libc::setsid() == -1 {
+                Err(std::io::Error::last_os_error())
+            } else {
+                Ok(())
+            }
+        });
+    }
+}
+
+#[cfg(not(unix))]
+fn detach_daemon_child(_command: &mut Command) {}
+
 /// `stop_coordinator`(`lifecycle.py:228-247`):SIGTERM pid + 清 pid/meta → typed report。
 pub fn stop_coordinator(workspace: &WorkspacePath) -> Result<StopReport, StopError> {
     let pid_path = coordinator_pid_path(workspace);
@@ -696,3 +718,41 @@ fn clean_text(text: &str) -> String {
 fn prefix_chars(text: &str, max: usize) -> String {
     text.chars().take(max).collect()
 }
+
+#[cfg(all(test, unix))]
+mod tests {
+    use super::*;
+
+    struct ChildGuard(std::process::Child);
+
+    impl Drop for ChildGuard {
+        fn drop(&mut self) {
+            unsafe {
+                libc::kill(self.0.id() as libc::pid_t, libc::SIGTERM);
+            }
+            let _ = self.0.wait();
+        }
+    }
+
+    #[test]
+    fn coordinator_daemon_spawn_helper_detaches_session() {
+        let mut command = Command::new("/bin/sleep");
+        command
+            .arg("30")
+            .stdin(Stdio::null())
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        detach_daemon_child(&mut command);
+
+        let child = command.spawn().expect("spawn detached child");
+        let guard = ChildGuard(child);
+        let pid = guard.0.id() as libc::pid_t;
+        let sid = unsafe { libc::getsid(pid) };
+
+        assert_ne!(sid, -1, "getsid({pid}) failed");
+        assert_eq!(
+            sid, pid,
+            "detached coordinator children must become session leaders so launcher SIGHUP does not reach them"
+        );
+    }
+}