@team-agent/installer 0.5.0 → 0.5.2

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

@@ -112,6 +112,10 @@ fn dispatch(command: &str, args: &[String], cwd: &Path) -> Result<ExitCode, CliE
         "claim-leader" => cmd_claim_leader(&claim_leader_args(args, cwd)).map(emit_result),
         // Real dispatch: `cmd_attach_leader` writes the `leader_receiver` binding.
         "attach-leader" => cmd_attach_leader(&attach_leader_args(args, cwd)?).map(emit_result),
+        "attach-app-server-leader" => {
+            cmd_attach_app_server_leader(&attach_app_server_leader_args(args, cwd)?)
+                .map(emit_result)
+        }
         "identity" => cmd_identity(&identity_args(args, cwd)).map(emit_result),
         "approvals" => cmd_approvals(&approvals_args(args, cwd)).map(emit_result),
         "inbox" => cmd_inbox(&inbox_args(args, cwd)?).map(emit_result),
@@ -167,6 +171,7 @@ const DISPATCH_COMMANDS: &[&str] = &[
     "takeover",
     "claim-leader",
     "attach-leader",
+    "attach-app-server-leader",
     "identity",
     "approvals",
     "inbox",
@@ -210,6 +215,23 @@ fn is_known_subcommand(command: &str) -> bool {
     DISPATCH_COMMANDS.contains(&command) || SPEC_ONLY_HELP_COMMANDS.contains(&command)
 }
 
+/// Test-only public accessor for `command_help` — allows integration
+/// tests to grep the help copy without depending on internal parser
+/// machinery.
+pub fn __test_command_help(command: Option<&str>) -> String {
+    command_help(command)
+}
+
+/// Test-only public accessor for `quick_start_args` — allows
+/// integration tests to exercise the parser without going through
+/// stdio + the full `main` entrypoint.
+pub fn __test_quick_start_args(
+    args: &[String],
+    cwd: &std::path::Path,
+) -> Result<crate::cli::types::QuickStartArgs, crate::cli::CliError> {
+    quick_start_args(args, cwd)
+}
+
 fn command_help(command: Option<&str>) -> String {
     match command {
         None => {
@@ -222,10 +244,10 @@ fn command_help(command: Option<&str>) -> String {
             )
         }
         Some("init") => "usage: team-agent init [--workspace WORKSPACE] [--force] [--json]".to_string(),
-        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.".to_string(),
+        Some("quick-start") => "usage: team-agent quick-start [TEAMDIR] [--workspace WORKSPACE] [--name NAME] [--team-id TEAM|--team TEAM] [--yes] [--no-display] [--backend tmux|conpty] [--json]\n\ndefaults: display_backend=adaptive; set display_backend: none in TEAM.md or pass --no-display to use one worker window per agent.\n\n--backend selects the worker transport (Phase 1d Batch 2): tmux (default on POSIX; unchanged behavior), conpty (Windows-native ConPTY worker transport; requires the shim binary and Windows host).".to_string(),
         Some("start") => "usage: team-agent start [TEAMDIR] [--yes] [--fresh] [--json]".to_string(),
         Some("compile") => "usage: team-agent compile --team TEAM [--out FILE] [--json]".to_string(),
-        Some("send") => "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]".to_string(),
+        Some("send") => "usage: team-agent send TARGET MESSAGE... [--workspace WORKSPACE] [--team TEAM] [--targets AGENTS] [--to-name NAME] [--pane PANE] [--task TASK] [--sender SENDER] [--watch-result] [--requires-ack|--no-ack] [--no-wait] [--timeout SECONDS] [--confirm-human] [--message-id ID] [--json]\n\nMVP: name-based cross-workspace addressing assumes trusted local caller; no auth gate.".to_string(),
         Some("fallback-send-leader") => "usage: team-agent fallback-send-leader --workspace WORKSPACE --team TEAM --sender AGENT --message-id ID --content TEXT --primary-error ERROR [--task TASK] [--json]\n\nEmergency one-shot fallback only after a leader-bound MCP send transport failure; restart-agent after use.".to_string(),
         Some("fallback-report-result") => "usage: team-agent fallback-report-result --workspace WORKSPACE --team TEAM --agent-id AGENT --task-id TASK --result-json JSON --primary-error ERROR [--json]\n\nEmergency one-shot fallback only after a report_result MCP transport failure; persists the result DB row, then restart-agent after use.".to_string(),
         Some("allow-peer-talk") => "usage: team-agent allow-peer-talk A B [--workspace WORKSPACE] [--json]".to_string(),
@@ -247,6 +269,7 @@ fn command_help(command: Option<&str>) -> String {
         Some("takeover") => "usage: team-agent takeover [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]".to_string(),
         Some("claim-leader") => "usage: team-agent claim-leader [--workspace WORKSPACE] [--team TEAM] [--confirm] [--json]".to_string(),
         Some("attach-leader") => "usage: team-agent attach-leader [--workspace WORKSPACE] [--team TEAM] [--pane PANE] [--provider PROVIDER] [--confirm] [--json]".to_string(),
+        Some("attach-app-server-leader") => "usage: team-agent attach-app-server-leader [--workspace WORKSPACE] [--team TEAM] --socket unix:///path.sock --thread-id THREAD_ID [--json]".to_string(),
         Some("identity") => "usage: team-agent identity [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("approvals") => "usage: team-agent approvals [AGENT] [--workspace WORKSPACE] [--team TEAM] [--json]".to_string(),
         Some("inbox") => "usage: team-agent inbox AGENT [--workspace WORKSPACE] [--team TEAM] [--limit N] [--since CURSOR] [--json]".to_string(),
@@ -668,13 +691,20 @@ struct ParsedArgs {
     out: Option<PathBuf>,
     auth_mode: Option<String>,
     pane: Option<String>,
+    to_name: Option<String>,
     provider: Option<String>,
+    socket: Option<String>,
+    thread_id: Option<String>,
     message_id: Option<String>,
     content: Option<String>,
     primary_error: Option<String>,
     agent_id: Option<String>,
     task_id: Option<String>,
     result_json: Option<String>,
+    /// 0.5.x Phase 1d Batch 2: quick-start `--backend <tmux|conpty>`.
+    /// Raw string (validated at the quick-start builder); the factory
+    /// enforces literal semantics.
+    backend: Option<String>,
 }
 
 fn parse_args(args: &[String]) -> ParsedArgs {
@@ -716,6 +746,7 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             }
             "--force" => parsed.force = true,
             "--no-display" => parsed.no_display = true,
+            "--backend" => parsed.backend = next_arg(args, &mut i),
             "--discard-session" => parsed.discard_session = true,
             "--role-file" => parsed.role_file = next_arg(args, &mut i),
             "--as" => parsed.as_agent = next_arg(args, &mut i),
@@ -750,7 +781,10 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             "--out" => parsed.out = next_arg(args, &mut i).map(PathBuf::from),
             "--auth-mode" => parsed.auth_mode = next_arg(args, &mut i),
             "--pane" => parsed.pane = next_arg(args, &mut i),
+            "--to-name" => parsed.to_name = next_arg(args, &mut i),
             "--provider" => parsed.provider = next_arg(args, &mut i),
+            "--socket" => parsed.socket = next_arg(args, &mut i),
+            "--thread-id" => parsed.thread_id = next_arg(args, &mut i),
             "--message-id" => parsed.message_id = next_arg(args, &mut i),
             "--content" => parsed.content = next_arg(args, &mut i),
             "--primary-error" => parsed.primary_error = next_arg(args, &mut i),
@@ -762,9 +796,18 @@ fn parse_args(args: &[String]) -> ParsedArgs {
             other if other.starts_with("--pane=") => {
                 parsed.pane = Some(other.trim_start_matches("--pane=").to_string());
             }
+            other if other.starts_with("--to-name=") => {
+                parsed.to_name = Some(other.trim_start_matches("--to-name=").to_string());
+            }
             other if other.starts_with("--provider=") => {
                 parsed.provider = Some(other.trim_start_matches("--provider=").to_string());
             }
+            other if other.starts_with("--socket=") => {
+                parsed.socket = Some(other.trim_start_matches("--socket=").to_string());
+            }
+            other if other.starts_with("--thread-id=") => {
+                parsed.thread_id = Some(other.trim_start_matches("--thread-id=").to_string());
+            }
             other if other.starts_with('-') => {}
             other => parsed.positionals.push(other.to_string()),
         }
@@ -828,6 +871,20 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
     } else {
         workspace.join(agents_dir)
     };
+    // 0.5.x Phase 1d Batch 2: validate the `--backend` literal up-front
+    // so users get a fast, actionable error instead of a downstream
+    // factory refusal. Accept the same literals as the factory
+    // `RequestedTransportBackend::parse_literal`.
+    if let Some(literal) = parsed.backend.as_deref() {
+        let normalized = literal.trim().to_ascii_lowercase();
+        if normalized != "tmux" && normalized != "conpty" {
+            return Err(CliError::Usage(format!(
+                "--backend must be `tmux` or `conpty`, got {literal:?}. \
+                 `pty` is not a supported literal in Phase 1d (design \
+                 §Non-Goals + CR C-1 ②)."
+            )));
+        }
+    }
     Ok(QuickStartArgs {
         workspace,
         agents_dir,
@@ -836,6 +893,7 @@ fn quick_start_args(args: &[String], cwd: &Path) -> Result<QuickStartArgs, CliEr
         yes: parsed.yes,
         no_display: parsed.no_display,
         json: parsed.json,
+        backend: parsed.backend,
     })
 }
 
@@ -875,7 +933,7 @@ fn resolve_cli_path(cwd: &Path, path: &Path) -> PathBuf {
 
 fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
     let parsed = parse_args(args);
-    let target = if parsed.targets.is_some() || parsed.pane.is_some() {
+    let target = if parsed.targets.is_some() || parsed.pane.is_some() || parsed.to_name.is_some() {
         None
     } else {
         parsed.positionals.first().cloned()
@@ -903,6 +961,7 @@ fn send_args(args: &[String], cwd: &Path) -> Result<SendArgs, CliError> {
         json: parsed.json,
         message_id: parsed.message_id,
         pane: parsed.pane.clone(),
+        to_name: parsed.to_name.clone(),
     })
 }
 
@@ -1073,6 +1132,26 @@ fn attach_leader_args(args: &[String], cwd: &Path) -> Result<AttachLeaderArgs, C
     })
 }
 
+fn attach_app_server_leader_args(
+    args: &[String],
+    cwd: &Path,
+) -> Result<AttachAppServerLeaderArgs, CliError> {
+    let parsed = parse_args(args);
+    Ok(AttachAppServerLeaderArgs {
+        workspace: workspace(&parsed, cwd),
+        team: parsed.team,
+        socket: parsed
+            .socket
+            .filter(|socket| !socket.is_empty())
+            .ok_or_else(|| CliError::Usage("missing --socket".to_string()))?,
+        thread_id: parsed
+            .thread_id
+            .filter(|thread_id| !thread_id.is_empty())
+            .ok_or_else(|| CliError::Usage("missing --thread-id".to_string()))?,
+        json: parsed.json,
+    })
+}
+
 fn identity_args(args: &[String], cwd: &Path) -> IdentityArgs {
     let parsed = parse_args(args);
     IdentityArgs {
@@ -1602,6 +1681,8 @@ mod tests {
                     "--workspace",
                     "--team",
                     "--targets",
+                    "--to-name",
+                    "--pane",
                     "--watch-result",
                     "--timeout",
                     "--json",
@@ -1781,6 +1862,33 @@ mod tests {
         let _ = std::fs::remove_dir_all(&cwd);
     }
 
+    #[test]
+    fn send_to_name_positionals_are_message_not_target() {
+        let cwd = tmp_workspace();
+        let args = send_args(&cli_argv(&["--to-name", "team-a/qa", "hello"]), &cwd).unwrap();
+        assert_eq!(args.to_name.as_deref(), Some("team-a/qa"));
+        assert_eq!(args.target, None);
+        assert_eq!(args.targets, None);
+        assert_eq!(args.message, vec!["hello".to_string()]);
+
+        let args = send_args(
+            &cli_argv(&["--to-name=team-a/qa", "multi", "word", "message"]),
+            &cwd,
+        )
+        .unwrap();
+        assert_eq!(args.target, None);
+        assert_eq!(
+            args.message,
+            vec![
+                "multi".to_string(),
+                "word".to_string(),
+                "message".to_string()
+            ]
+        );
+
+        let _ = std::fs::remove_dir_all(&cwd);
+    }
+
     #[test]
     fn send_pane_still_rejects_to_and_empty_message() {
         let cwd = tmp_workspace();

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

@@ -53,19 +53,23 @@ pub(crate) const SEND_REMINDER: &str = "Message delivered. Wait for the worker t
 pub(crate) const STATUS_REMINDER: &str = "To wait for results use --watch-result or team-agent collect. Do not capture-pane worker terminals.";
 
 pub mod adapters;
+pub mod attach_app_server_leader;
 pub mod diagnose;
 pub mod emit;
 pub mod helpers;
 pub mod leader;
+pub mod named_address;
 pub mod profile;
 pub mod send;
 pub mod status;
 pub mod types;
 
 pub use adapters::*;
+pub use attach_app_server_leader::*;
 pub use diagnose::*;
 pub use emit::*;
 pub use leader::*;
+pub use named_address::*;
 pub use profile::*;
 pub use send::*;
 pub use status::*;
@@ -118,14 +122,16 @@ pub mod lifecycle_port {
         team_id: Option<&str>,
         yes: bool,
         open_display: bool,
+        backend: Option<&str>,
     ) -> Result<Value, CliError> {
-        match crate::lifecycle::quick_start_in_workspace_with_display(
+        match crate::lifecycle::quick_start_in_workspace_with_display_and_backend(
             workspace,
             agents_dir,
             name,
             yes,
             team_id,
             open_display,
+            backend,
         ) {
             Ok(report) => Ok(quick_start_value(report)),
             Err(e) => Ok(error_value(e)),
@@ -190,16 +196,40 @@ pub mod lifecycle_port {
         crate::tmux_backend::attach_command_for_workspace(cwd, session, window.as_str())
     }
     /// `runtime.shutdown`(`cmd_shutdown`)。
+    ///
+    /// 0.5.x Phase 1d Batch 5: the workspace-transport branch now routes
+    /// through `transport_factory::resolve_read_only_transport` so a
+    /// conpty team's shutdown reaches the shim rather than a
+    /// no-op tmux backend. Legacy tmux endpoint literal in state still
+    /// takes the `shutdown_transport_for_endpoint` tmux channel helper
+    /// path (intentional — this is the "attached explicit tmux
+    /// endpoint" branch and stays tmux-typed).
+    ///
+    /// `shutdown_with_transport_and_state` is generic over `&dyn
+    /// Transport`, so we hand the boxed factory backend down as
+    /// `&*box`. Factory refusal falls back to the workspace tmux
+    /// backend byte-equivalent to today so daemon liveness paths
+    /// don't crash.
     pub fn shutdown(workspace: &Path, keep_logs: bool, team: Option<&str>) -> Result<Value, CliError> {
         let run_ws = crate::model::paths::canonical_run_workspace(workspace)
             .map_err(|e| CliError::Runtime(e.to_string()))?;
         let state = shutdown_state_for_team(&run_ws, team)?;
-        let transport = if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
-            shutdown_transport_for_endpoint(endpoint)
-        } else {
-            shutdown_workspace_transport(&run_ws)
-        };
-        shutdown_with_transport_and_state(workspace, keep_logs, team, &transport, Some(state))
+        if let Some(endpoint) = legacy_worker_tmux_endpoint(&state) {
+            let transport = shutdown_transport_for_endpoint(endpoint);
+            return shutdown_with_transport_and_state(
+                workspace, keep_logs, team, &transport, Some(state),
+            );
+        }
+        let boxed: Box<dyn crate::transport::Transport> =
+            match crate::transport_factory::resolve_read_only_transport(
+                &run_ws,
+                Some(&state),
+                crate::transport_factory::TransportPurpose::Shutdown,
+            ) {
+                Ok(r) => r.backend,
+                Err(_) => Box::new(shutdown_workspace_transport(&run_ws)),
+            };
+        shutdown_with_transport_and_state(workspace, keep_logs, team, boxed.as_ref(), Some(state))
     }
 
     /// E12 ①:从 state 锚 pane_id(leader_receiver/team_owner,top+teams)映射到其所在 session
@@ -1189,24 +1219,41 @@ pub mod lifecycle_port {
                 }
             }
         }
-        let workspace_transport = shutdown_workspace_transport(workspace);
-        match crate::transport::Transport::has_session(&workspace_transport, session) {
-            Ok(true) => residual = true,
-            Ok(false) => {}
-            Err(err) if tmux_absent_error(&err.to_string()) => {}
-            Err(err) => {
-                error.get_or_insert_with(|| err.to_string());
-                residual = true;
-            }
-        }
-        let default_transport = crate::tmux_backend::TmuxBackend::new();
-        match crate::transport::Transport::has_session(&default_transport, session) {
-            Ok(true) => residual = true,
-            Ok(false) => {}
-            Err(err) if tmux_absent_error(&err.to_string()) => {}
-            Err(err) => {
-                error.get_or_insert_with(|| err.to_string());
-                residual = true;
+        // 0.5.x Phase 1d Batch 5 (design §Batch 5 point 4): a ConPTY
+        // team's residual check MUST NOT read the workspace tmux socket
+        // + shared default tmux socket as evidence for/against ConPTY
+        // residual. Those probes are meaningless for a shim-owned pane
+        // universe: they will always return `has_session=false` (no
+        // tmux session exists) which would look like "no residual" but
+        // gives zero honest information about whether the shim / child
+        // panes have actually been reaped. Skip the tmux fallback
+        // probes when the primary transport is ConPTY; the primary
+        // transport check above already covered the honest question
+        // ("does the shim still have this session?").
+        let primary_is_conpty = matches!(
+            transport.kind(),
+            crate::transport::BackendKind::ConPty
+        );
+        if !primary_is_conpty {
+            let workspace_transport = shutdown_workspace_transport(workspace);
+            match crate::transport::Transport::has_session(&workspace_transport, session) {
+                Ok(true) => residual = true,
+                Ok(false) => {}
+                Err(err) if tmux_absent_error(&err.to_string()) => {}
+                Err(err) => {
+                    error.get_or_insert_with(|| err.to_string());
+                    residual = true;
+                }
+            }
+            let default_transport = crate::tmux_backend::TmuxBackend::new();
+            match crate::transport::Transport::has_session(&default_transport, session) {
+                Ok(true) => residual = true,
+                Ok(false) => {}
+                Err(err) if tmux_absent_error(&err.to_string()) => {}
+                Err(err) => {
+                    error.get_or_insert_with(|| err.to_string());
+                    residual = true;
+                }
             }
         }
         let sessions = if residual {