@team-agent/installer 0.5.0 → 0.5.2

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

@@ -7,6 +7,40 @@ use crate::messaging::{DeliveryOutcome, DeliveryRefusal, DeliveryStage, Delivery
 /// `cmd_send`(`commands.py:164`)。解析 target(`--to` fanout / 单 target / `*`)→ [`MessageTarget`],
 /// 拼 [`SendOptions`](no_ack→requires_ack 取反、no_wait→wait_visible 取反等)→ `messaging::send_message`。
 pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
+    if let Some(ref to_name) = args.to_name {
+        if args.pane.is_some() || args.target.is_some() || args.targets.is_some() {
+            return Err(CliError::Usage(
+                "--to-name and --pane/TARGET/--to are mutually exclusive: \
+                 --to-name resolves a stable workspace/team/name to a live pane"
+                    .to_string(),
+            ));
+        }
+        let content = args.message.join(" ");
+        if content.is_empty() {
+            return Err(CliError::Usage(
+                "--to-name requires a non-empty message".to_string(),
+            ));
+        }
+        let (resolved, transport) =
+            match crate::cli::named_address::resolve_name_for_cli(&args.workspace, to_name) {
+                Ok(resolved) => resolved,
+                Err(error) if args.json => {
+                    return Ok(CmdResult::from_json(error.to_json(), args.json));
+                }
+                Err(error) => return Err(CliError::Usage(error.n38_message())),
+            };
+        let mut value = send_to_named_pane_direct(
+            &args.workspace,
+            transport.as_ref(),
+            &resolved,
+            &content,
+            &args.sender,
+            args.task.as_deref(),
+            args.json,
+        )?;
+        add_send_reminder_if_ok(&mut value);
+        return Ok(CmdResult::from_json(value, args.json));
+    }
     // F1 (0.3.26, cross-team send): --pane <pane_id> direct targeting.
     // Mutually exclusive with target / --to (agent-name routing).
     if let Some(ref pane_id) = args.pane {
@@ -20,7 +54,9 @@ pub fn cmd_send(args: &SendArgs) -> Result<CmdResult, CliError> {
         }
         let content = args.message.join(" ");
         if content.is_empty() {
-            return Err(CliError::Usage("--pane requires a non-empty message".to_string()));
+            return Err(CliError::Usage(
+                "--pane requires a non-empty message".to_string(),
+            ));
         }
         let mut value = send_to_pane_direct(
             &args.workspace,
@@ -145,6 +181,169 @@ fn send_to_pane_direct(
     }))
 }
 
+fn send_to_named_pane_direct(
+    sender_workspace: &Path,
+    transport: &dyn crate::transport::Transport,
+    resolved: &crate::cli::named_address::ResolvedNamedAddress,
+    content: &str,
+    sender: &str,
+    task_id: Option<&str>,
+    _json: bool,
+) -> Result<serde_json::Value, CliError> {
+    use crate::messaging::delivery::render_message;
+    use crate::transport::{InjectPayload, Key, PaneId, Target};
+
+    let message_id = format!("named_send_{}", chrono::Utc::now().timestamp_millis());
+    let rendered = render_message(sender, task_id, content, &message_id);
+    let sender_run_workspace = crate::model::paths::canonical_run_workspace(sender_workspace)
+        .unwrap_or_else(|_| sender_workspace.to_path_buf());
+    let event_log = crate::event_log::EventLog::new(&sender_run_workspace);
+    if let Some(warning) = &resolved.warning {
+        eprintln!("warning: {warning}");
+    }
+    if resolved.transport_kind.as_deref() == Some("codex_app_server") {
+        return send_to_named_app_server_leader(
+            &event_log,
+            resolved,
+            &message_id,
+            &rendered,
+            sender,
+        );
+    }
+    let target = Target::Pane(PaneId::new(&resolved.pane_id));
+    let report = transport
+        .inject(&target, &InjectPayload::Text(rendered), Key::Enter, true)
+        .map_err(|e| {
+            CliError::Runtime(format!(
+                "inject to named target {} pane {} failed: {e}",
+                resolved.raw_name, resolved.pane_id
+            ))
+        })?;
+    let target_kind = named_target_kind_wire(resolved.target_kind);
+    let event = serde_json::json!({
+        "to_name": resolved.raw_name,
+        "target_kind": target_kind,
+        "sender": sender,
+        "sender_workspace": sender_run_workspace.display().to_string(),
+        "target_workspace": resolved.target_workspace.display().to_string(),
+        "team_key": resolved.team_key,
+        "agent_id": resolved.agent_id,
+        "pane_id": resolved.pane_id,
+        "session_name": resolved.session_name,
+        "window_name": resolved.window_name,
+        "tmux_endpoint": resolved.tmux_endpoint,
+        "state_pane_id": resolved.state_pane_id,
+        "state_pane_stale": resolved.state_pane_stale,
+        "agent_status": resolved.agent_status,
+        "warning": resolved.warning,
+        "message_id": message_id,
+        "submit_verification": crate::transport::submit_verification_wire(report.submit_verification),
+        "inject_verification": format!("{:?}", report.inject_verification),
+    });
+    let _ = event_log.write("send.name_direct", event.clone());
+    let ok = matches!(
+        report.submit_verification,
+        crate::transport::SubmitVerification::EnterSentWithoutPlaceholderCheck
+            | crate::transport::SubmitVerification::PastedContentPromptAbsentAfterSubmit
+            | crate::transport::SubmitVerification::KeySentAfterVisibleToken { .. }
+    );
+    let mut value = event;
+    if let Some(obj) = value.as_object_mut() {
+        obj.insert("ok".to_string(), serde_json::json!(ok));
+    }
+    Ok(value)
+}
+
+fn send_to_named_app_server_leader(
+    event_log: &crate::event_log::EventLog,
+    resolved: &crate::cli::named_address::ResolvedNamedAddress,
+    message_id: &str,
+    rendered: &str,
+    sender: &str,
+) -> Result<serde_json::Value, CliError> {
+    let receiver = serde_json::json!({
+        "mode": "codex_app_server",
+        "transport_kind": "codex_app_server",
+        "app_server": resolved.app_server.clone().unwrap_or(serde_json::Value::Null),
+    });
+    let binding = crate::codex_app_server::binding_from_receiver(&receiver)
+        .map_err(|error| CliError::Runtime(format!("invalid app-server named leader: {error}")))?;
+    let target_kind = named_target_kind_wire(resolved.target_kind);
+    let base_event = serde_json::json!({
+        "to_name": resolved.raw_name,
+        "target_kind": target_kind,
+        "sender": sender,
+        "sender_workspace": resolved.sender_workspace.display().to_string(),
+        "target_workspace": resolved.target_workspace.display().to_string(),
+        "team_key": resolved.team_key,
+        "agent_id": resolved.agent_id,
+        "transport_kind": "codex_app_server",
+        "socket": binding.socket,
+        "thread_id": binding.thread_id,
+        "message_id": message_id,
+    });
+    match crate::codex_app_server::submit_to_bound_thread(&binding, message_id, rendered) {
+        Ok(submit) => {
+            let event = merge_json(
+                base_event.clone(),
+                serde_json::json!({
+                    "ok": true,
+                    "turn_id": submit.turn_id,
+                    "turn_status": submit.turn_status,
+                }),
+            );
+            let _ = event_log.write("send.name_app_server", event.clone());
+            Ok(event)
+        }
+        Err(crate::codex_app_server::AppServerError::LeaderBusy(message)) => {
+            let event = merge_json(
+                base_event.clone(),
+                serde_json::json!({
+                    "ok": false,
+                    "status": "retry_scheduled",
+                    "reason": "leader_busy",
+                    "channel": "leader_busy",
+                    "error": message,
+                }),
+            );
+            let _ = event_log.write("send.name_app_server", event.clone());
+            Ok(event)
+        }
+        Err(error) => {
+            let event = merge_json(
+                base_event.clone(),
+                serde_json::json!({
+                    "ok": false,
+                    "status": "refused",
+                    "reason": error.code(),
+                    "channel": "rebind_required",
+                    "error": error.to_string(),
+                    "action": "run team-agent attach-app-server-leader for the target team",
+                }),
+            );
+            let _ = event_log.write("send.name_app_server", event.clone());
+            Ok(event)
+        }
+    }
+}
+
+fn merge_json(mut left: serde_json::Value, right: serde_json::Value) -> serde_json::Value {
+    if let (Some(left), Some(right)) = (left.as_object_mut(), right.as_object()) {
+        for (key, value) in right {
+            left.insert(key.clone(), value.clone());
+        }
+    }
+    left
+}
+
+fn named_target_kind_wire(kind: crate::cli::named_address::NamedTargetKind) -> &'static str {
+    match kind {
+        crate::cli::named_address::NamedTargetKind::Worker => "worker",
+        crate::cli::named_address::NamedTargetKind::Leader => "leader",
+        crate::cli::named_address::NamedTargetKind::SessionWindow => "session_window",
+    }
+}
+
 pub fn cmd_fallback_send_leader(args: &FallbackSendLeaderArgs) -> Result<CmdResult, CliError> {
     if let Some(value) = fallback_business_refusal(&args.primary_error, args.json) {
         return Ok(value);

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

@@ -280,7 +280,29 @@ use rusqlite::params;
         if let (Some(session), Some(agents)) = (session, state.get("agents").and_then(Value::as_object)) {
             let run_ws = crate::model::paths::canonical_run_workspace(workspace)
                 .unwrap_or_else(|_| workspace.to_path_buf());
-            let backend = crate::tmux_backend::TmuxBackend::for_workspace(&run_ws);
+            // 0.5.x Phase 1d Batch 3: use the factory-resolved backend
+            // so conpty teams get their scrollback from the shim rather
+            // than a fake tmux capture that always returns empty. Tmux
+            // teams take the same code path as before (byte-equivalent).
+            let resolved = crate::transport_factory::resolve_read_only_transport(
+                &run_ws,
+                Some(state),
+                crate::transport_factory::TransportPurpose::Status,
+            );
+            let backend: Box<dyn crate::transport::Transport> = match resolved {
+                Ok(r) => r.backend,
+                Err(_) => {
+                    // Read-path fallback: refused factory means we don't
+                    // try to inspect approval prompts. Empty vec = no
+                    // waiting approvals, honest.
+                    return Ok(json!({
+                        "ok": true,
+                        "waiting": false,
+                        "waiting_count": 0,
+                        "approvals": [],
+                    }));
+                }
+            };
             for (agent_id, agent_state) in agents {
                 if agent.is_some_and(|wanted| wanted != agent_id) {
                     continue;
@@ -469,14 +491,30 @@ use rusqlite::params;
         }
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .unwrap_or_else(|_| workspace.to_path_buf());
-        let selection = crate::tmux_backend::tmux_backend_for_runtime_state_or_workspace(
+        // 0.5.x Phase 1d Batch 3: route through the factory so a
+        // conpty team does NOT get its `has_session` probe served by a
+        // tmux backend (which would always return false and drive the
+        // reader into a false `tmux_session_missing` state — design
+        // §Batch 3 Verification anchor). Tmux teams see byte-equivalent
+        // behavior because factory Layer 3 (legacy tmux endpoint) uses
+        // the same `tmux_backend_for_runtime_state_or_workspace` shape.
+        let resolved = crate::transport_factory::resolve_read_only_transport(
             &run_ws,
             Some(state),
+            crate::transport_factory::TransportPurpose::Status,
         );
-        selection
-            .backend
-            .has_session(&crate::transport::SessionName::new(name))
-            .unwrap_or(false)
+        match resolved {
+            Ok(r) => r
+                .backend
+                .has_session(&crate::transport::SessionName::new(name))
+                .unwrap_or(false),
+            Err(_) => {
+                // Factory refused (e.g. explicit conpty without a
+                // resolvable team_key). Honest: return false rather
+                // than pretend a tmux session exists.
+                false
+            }
+        }
     }
 
     fn message_counts(conn: &rusqlite::Connection, owner_team_id: Option<&str>) -> Result<Value, CliError> {

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

@@ -50,6 +50,7 @@ use super::*;
             json: true,
             message_id: None,
             pane: None,
+            to_name: None,
         };
         let _ = cmd_send(&args);
 

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

@@ -87,6 +87,7 @@ mod divergence;
 mod lane_c;
 mod leader_watch;
 mod missing_subcommands;
+mod named_address;
 mod repair_state_byte_lock;
 mod peer_allow;
 mod run_delegation;