daemon-cli: move multicast transport verbs into daemon-cli crate (#4037)

## Summary of Changes
* Move the multicast transport verbs (`multicast
subscribe`/`unsubscribe`/`publish`/`unpublish`) from the `doublezero`
binary into the `doublezero-daemon-cli` crate per
[RFC-20](https://github.com/malbeclabs/doublezero/blob/main/rfcs/rfc20-cli-standardization.md)
— PR 7 of the daemon-cli extraction stack (parent:
malbeclabs/infra#1458).
* The verbs use the RFC-20 execute signature (`CliContext` + generic
`DaemonClient` + `LedgerClient` + writer) but are **not**
`DaemonCommand` variants — the binary's `MulticastCommands` enum nests
them so `doublezero multicast <verb>` invocations are unchanged. Onchain
`multicast group` CRUD still routes to the serviceability crate.
* Delete the binary's `command/helpers.rs` and the
`servicecontroller.rs` remnant (these verbs were their last users; the
crate's `resolve_client_ip`/`DaemonClient` survive), and drop the
now-orphaned deps (`hyper` stack, `chrono`, `indicatif`) from the
binary. Dedupe `init_spinner` into the crate's `helpers.rs` (was copied
verbatim in connect/disconnect/multicast).
* Behavior parity: message text, skip semantics, role-carry flags,
warning conditions, per-group failure aggregation, and exit codes are
unchanged. Informational lines now route through the stdout writer
instead of the stderr spinner, matching the connect/disconnect
migrations.
* Fixes malbeclabs/infra#1493

## Testing Verification
* All 21 binary unit tests ported to the crate and strengthened: they
now exercise the full `execute` path through `MockDaemonClient` (the old
tests bypassed IP resolution via `execute_inner`) and assert rendered
writer output. Added `unsubscribe_errors_when_daemon_has_no_client_ip`
and a publish partial-failure aggregation test (one group fails onchain
→ remaining groups still attempted, aggregated non-zero exit).
* CLI surface verified with the built binary: `doublezero multicast
--help` shows the same five subcommands, `multicast subscribe --help`
unchanged, and no transport verb leaks to the top level.
* Checked e2e usages (`e2e/main_test.go`, `multicast_register_test.go`):
they assert exit codes only, so the stderr→stdout message move is safe.
* Four independent reviews (architecture, security, and two style/domain
reviewers) found no critical/high issues; the `init_spinner` dedup and
publish failure test came out of them.

## Follow-ups (pre-existing behavior deliberately preserved for parity)
* The four verbs skip `check_requirements()`/`check_daemon` preflights
that `connect`/`disconnect` run — a missing keypair or env mismatch
surfaces mid-loop instead of upfront.
* `finish_update` prints the "✅ Updated." line even when every per-group
call failed (exit code is still non-zero).
* Duplicate group args (`subscribe g g`) issue the onchain update twice;
multiple multicast users on one IP are picked in HashMap order.

Author: ben-dz

CHANGELOG.md

@@ -32,6 +32,7 @@ All notable changes to this project will be documented in this file.
 - Onchain programs
   - Restrict granting the `FOUNDATION` permission flag: a plain `PERMISSION_ADMIN` holder can no longer grant `FOUNDATION` (a privilege escalation). Only a `foundation_allowlist` member or an existing `FOUNDATION` holder may grant it, enforced independently of `RequirePermissionAccounts` so foundation members are never locked out.
 - CLI
+  - Move the multicast transport verbs (`multicast subscribe`/`unsubscribe`/`publish`/`unpublish`) into the `doublezero-daemon-cli` crate per RFC-20. Each now takes `&CliContext` + generic `&D: DaemonClient` + `&L: LedgerClient` + `&mut W` writer; informational/result lines route through the shared writer (stdout, previously the stderr spinner). They stay nested under `doublezero multicast` (not hoisted as top-level daemon verbs); onchain `multicast group` CRUD is unchanged. The binary's `command/helpers.rs` (`resolve_client_ip`) and the `servicecontroller.rs` remnant are deleted — the crate copies survive. Flags, output content, and exit codes are unchanged. (#4037)
   - Move the `connect` verb into the `doublezero-daemon-cli` crate per RFC-20. It now takes `&CliContext` + generic `&D: DaemonClient` + `&L: LedgerClient` + `&mut W` writer; informational/result lines route through the shared writer (stdout, previously the stderr spinner), spinners stay on stderr, pre-flight diagnostics route through `tracing`, and device selection uses the crate's latency utilities (from #3995). The binary's `dzd_latency.rs` and the orphaned `check_doublezero` pre-flight are deleted. Flags, output content, `--verbose`, exit codes, and version-check semantics are unchanged. (#4010)
   - Move the `disconnect` verb into the `doublezero-daemon-cli` crate per RFC-20. It now takes `&CliContext` + generic `&D: DaemonClient` + `&L: LedgerClient` + `&mut W` writer; informational/result lines route through the shared writer, spinners stay on stderr, and diagnostics route through `tracing`. Behavior (flags, output, `--verbose`, `--no-wait`, version-check) is unchanged. (#4008)
   - Move the `latency` and `routes` verbs, plus the device-selection/latency-polling utilities and `resolve_client_ip`, into the `doublezero-daemon-cli` crate per RFC-20. Both verbs now take `&CliContext` + generic `&D: DaemonClient` + `&L: LedgerClient` + `&mut W` writer; diagnostics route through `tracing` and output through the shared writer helper. Behavior (flags, output, `--json`, version-check) is unchanged. (#3995)

Cargo.lock

@@ -14,20 +14,13 @@ repository.workspace = true
 [dependencies]
 anyhow.workspace = true
 backon.workspace = true
-chrono.workspace = true
 clap.workspace = true
 clap_complete.workspace = true
 console.workspace = true
 eyre.workspace = true
 futures.workspace = true
 futures-util.workspace = true
 libc.workspace = true
-http.workspace = true
-http-body-util.workspace = true
-hyper.workspace = true
-hyper-util.workspace = true
-hyperlocal.workspace = true
-indicatif.workspace = true
 mockall.workspace = true
 serde.workspace = true
 serde_json.workspace = true

client/doublezero/Cargo.toml

@@ -15,8 +15,9 @@ use crate::cli::{multicast::MulticastCliCommand, sentinel::SentinelCliCommand};
 /// `doublezero_daemon_cli`. The binary retains the
 /// `doublezero-geolocation-cli` module crate's geolocation subtree (via
 /// `GeolocationArgs`), the binary-only `Completion` generator, and `Multicast`
-/// (whose `Subscribe`/`Unsubscribe`/`Publish`/`Unpublish` arms depend on
-/// binary-local daemon-control infrastructure).
+/// (whose `Subscribe`/`Unsubscribe`/`Publish`/`Unpublish` arms route to
+/// `doublezero-daemon-cli` but stay nested to preserve the
+/// `doublezero multicast <verb>` invocation).
 #[derive(Subcommand, Debug)]
 pub enum Command {
     /// Daemon-control verbs migrated to `doublezero-daemon-cli` (RFC-20).

client/doublezero/src/cli/command.rs

@@ -1,5 +1,6 @@
 use clap::{Args, Subcommand};
 
+use doublezero_daemon_cli::multicast::{Publish, Subscribe, Unpublish, Unsubscribe};
 use doublezero_serviceability_cli::cli::multicastgroup::MulticastGroupCliCommand;
 
 #[derive(Args, Debug)]
@@ -8,49 +9,26 @@ pub struct MulticastCliCommand {
     pub command: MulticastCommands,
 }
 
+/// Multicast subtree: `Group` CRUD dispatches to the serviceability module
+/// crate; the transport verbs (`Subscribe`/`Unsubscribe`/`Publish`/`Unpublish`)
+/// dispatch to `doublezero-daemon-cli`. They are nested here — not hoisted as
+/// `DaemonCommand` variants — to preserve the `doublezero multicast <verb>`
+/// invocation.
 #[derive(Debug, Subcommand)]
 pub enum MulticastCommands {
     /// Manage multicast groups
     #[clap()]
     Group(MulticastGroupCliCommand),
     /// Subscribe to one or more multicast groups (user must already be connected)
     #[clap()]
-    Subscribe(MulticastSubscribeCliCommand),
+    Subscribe(Subscribe),
     /// Unsubscribe from one or more multicast groups
     #[clap()]
-    Unsubscribe(MulticastUnsubscribeCliCommand),
+    Unsubscribe(Unsubscribe),
     /// Publish to one or more multicast groups (user must already be connected)
     #[clap()]
-    Publish(MulticastPublishCliCommand),
+    Publish(Publish),
     /// Stop publishing to one or more multicast groups
     #[clap()]
-    Unpublish(MulticastUnpublishCliCommand),
-}
-
-#[derive(Args, Debug)]
-pub struct MulticastSubscribeCliCommand {
-    /// Multicast group code(s) to subscribe to
-    #[arg(num_args = 1..)]
-    pub groups: Vec<String>,
-}
-
-#[derive(Args, Debug)]
-pub struct MulticastUnsubscribeCliCommand {
-    /// Multicast group code(s) to unsubscribe from
-    #[arg(num_args = 1..)]
-    pub groups: Vec<String>,
-}
-
-#[derive(Args, Debug)]
-pub struct MulticastPublishCliCommand {
-    /// Multicast group code(s) to publish to
-    #[arg(num_args = 1..)]
-    pub groups: Vec<String>,
-}
-
-#[derive(Args, Debug)]
-pub struct MulticastUnpublishCliCommand {
-    /// Multicast group code(s) to stop publishing to
-    #[arg(num_args = 1..)]
-    pub groups: Vec<String>,
+    Unpublish(Unpublish),
 }

client/doublezero/src/cli/multicast.rs

@@ -2,11 +2,9 @@ use clap::{CommandFactory, Parser};
 use clap_complete::generate;
 use std::path::PathBuf;
 mod cli;
-mod command;
-use doublezero_config::Environment;
-mod servicecontroller;
 use crate::cli::{command::Command, multicast::MulticastCommands, sentinel::SentinelCommands};
 use doublezero_cli_core::LogLevel;
+use doublezero_config::Environment;
 use doublezero_daemon_cli::{DaemonClientImpl, DaemonCommand};
 use doublezero_geolocation_cli::GeoCliCommandImpl;
 use doublezero_sdk::{
@@ -20,7 +18,6 @@ use doublezero_serviceability_cli::{
     doublezerocommand::{CliCommand, CliCommandImpl},
     requirements::{check_requirements, CHECK_BALANCE, CHECK_ID_JSON},
 };
-use servicecontroller::ServiceControllerImpl;
 
 /// Adapter bridging the binary's `CliCommand` to the daemon-cli crate's
 /// `LedgerClient` trait. Holds the client so ledger-backed reads/writes (e.g.
@@ -266,7 +263,6 @@ async fn main() -> eyre::Result<()> {
     doublezero_cli_core::init_logging(app.log_level);
 
     if let Some(sock_file) = &app.sock_file {
-        ServiceControllerImpl::set_global_socket_path(sock_file.to_string_lossy());
         DaemonClientImpl::set_global_socket_path(sock_file.to_string_lossy());
     }
 
@@ -447,18 +443,38 @@ async fn main() -> eyre::Result<()> {
         }
 
         // Multicast: the `Group` subtree is module-crate business and dispatched by
-        // `MulticastGroupCommands::execute`; the daemon-coupled async verbs
-        // (Subscribe/Unsubscribe/Publish/Unpublish) stay binary-local because
-        // they depend on `ServiceControllerImpl` and `resolve_client_ip`.
-        Command::Multicast(args) => match args.command {
-            MulticastCommands::Group(args) => {
-                args.command.execute(&ctx, &client, &mut handle).await
+        // `MulticastGroupCommands::execute`; the daemon-coupled transport verbs
+        // (Subscribe/Unsubscribe/Publish/Unpublish) route to
+        // `doublezero-daemon-cli`, nested here to keep the
+        // `doublezero multicast <verb>` invocation.
+        Command::Multicast(args) => {
+            let daemon = DaemonClientImpl::new(
+                ctx.daemon_socket_path
+                    .as_ref()
+                    .map(|p| p.to_string_lossy().into_owned()),
+            );
+            let ledger = LedgerAdapter {
+                env: client.get_environment(),
+                client: &client,
+            };
+            match args.command {
+                MulticastCommands::Group(args) => {
+                    args.command.execute(&ctx, &client, &mut handle).await
+                }
+                MulticastCommands::Subscribe(cmd) => {
+                    cmd.execute(&ctx, &daemon, &ledger, &mut handle).await
+                }
+                MulticastCommands::Unsubscribe(cmd) => {
+                    cmd.execute(&ctx, &daemon, &ledger, &mut handle).await
+                }
+                MulticastCommands::Publish(cmd) => {
+                    cmd.execute(&ctx, &daemon, &ledger, &mut handle).await
+                }
+                MulticastCommands::Unpublish(cmd) => {
+                    cmd.execute(&ctx, &daemon, &ledger, &mut handle).await
+                }
             }
-            MulticastCommands::Subscribe(args) => args.execute(&client).await,
-            MulticastCommands::Unsubscribe(args) => args.execute(&client).await,
-            MulticastCommands::Publish(args) => args.execute(&client).await,
-            MulticastCommands::Unpublish(args) => args.execute(&client).await,
-        },
+        }
 
         // Clap shell-completion generator (binary-local)
         Command::Completion(args) => {