cli: Improve formatting of Node IDs and addresses — heartwood

Pay more attention to when a Node ID is displayed in compact form. As this was sometimes used to save space, e.g. in rad node status in combination with long node addresses (like .onion names), also implement a compact format for node addresses and use that instead in some cases. Progress notifications in spinners keep the short form.

 ) -> anyhow::Result<()> {
     let spinner = term::spinner(format!(
         "Connecting to {}@{addr}...",
         term::format::node(&nid)
         term::format::node_short(&nid)
     ));
     match node.connect(
         nid,

     for addr in addrs {
         spinner.message(format!(
             "Connecting to {}@{addr}...",
             term::format::node(&nid)
             term::format::node_short(&nid)
         ));
         match node.connect(
             nid,

                 term::Label::blank(),
             ),
             node::State::Attempted => (
                 sess.addr.to_string().into(),
                 term::format::addr_short(&sess.addr).into(),
                 term::Label::from(state_attempted()),
                 term::Label::blank(),
             ),
             node::State::Connected { since, .. } => (
                 sess.addr.to_string().into(),
                 term::format::addr_short(&sess.addr).into(),
                 term::Label::from(state_connected()),
                 term::format::dim(now - since).into(),
             ),
             node::State::Disconnected { since, .. } => (
                 sess.addr.to_string().into(),
                 term::format::addr_short(&sess.addr).into(),
                 term::Label::from(state_disconnected()),
                 term::format::dim(now - since).into(),
             ),

             term::format::secondary(self.preferred_seeds),
             term::format::secondary(progress.succeeded()),
             term::format::secondary(self.replicas.lower_bound()),
             term::format::tertiary(term::format::node(node)),
             term::format::tertiary(addr),
             term::format::tertiary(term::format::node_short(node)),
             term::format::tertiary(term::format::addr_short(addr)),
         ))
     }

             term::format::secondary(self.preferred_seeds),
             term::format::secondary(progress.succeeded()),
             term::format::secondary(self.replicas.lower_bound()),
             term::format::tertiary(term::format::node(node)),
             term::format::tertiary(addr),
             term::format::tertiary(term::format::node_short(node)),
             term::format::tertiary(term::format::addr_short(addr)),
         ))
     }

     match node.announce(rid, settings.timeout, announcer, |node, progress| {
         spinner.message(format!(
             "Synced with {}, {} of {} preferred seeds, and {} of at least {} replica(s).",
             term::format::node(node),
             term::format::node_short(node),
             term::format::secondary(progress.preferred()),
             term::format::secondary(n_preferred_seeds),
             term::format::secondary(progress.synced()),

 use radicle::cob::ObjectId;
 use radicle::identity::Visibility;
 use radicle::node::policy::Policy;
 use radicle::node::{Alias, AliasStore, NodeId};
 use radicle::node::{Address, Alias, AliasStore, HostName, NodeId};
 use radicle::prelude::Did;
 use radicle::profile::{env, Profile};
 use radicle::storage::RefUpdate;

 use crate::terminal as term;
 /// Format a node id to be more compact.
 pub fn node(node: &NodeId) -> Paint<String> {
 /// Format a Node ID in its short form, removing the middle part.
 pub fn node_short(node: &NodeId) -> Paint<String> {
     let node = node.to_human();
     let start = node.chars().take(7).collect::<String>();
     let end = node.chars().skip(node.len() - 7).collect::<String>();

     Paint::new(format!("{start}…{end}"))
 }
 /// Format a Node ID.
 pub fn node(node: &NodeId) -> Paint<String> {
     Paint::new(node.to_human())
 }
 /// Format an Address in a short form, removing the middle part of the host if it's a Tor address.
 pub fn addr_short(address: &Address) -> Paint<String> {
     let host = match address.host() {
         HostName::Ip(ip) => ip.to_string(),
         HostName::Dns(dns) => dns.clone(),
         HostName::Tor(onion) => {
             let onion = onion.to_string();
             let start = onion.chars().take(8).collect::<String>();
             let end = onion
                 .chars()
                 .skip(onion.len() - 8 - ".onion".len())
                 .collect::<String>();
             format!("{start}…{end}")
         }
         _ => unreachable!(),
     };
     let port = address.port().to_string();
     Paint::new(format!("{host}:{port}"))
 }
 /// Format a git Oid.
 pub fn oid(oid: impl Into<radicle::git::Oid>) -> Paint<String> {
     Paint::new(format!("{:.7}", oid.into()))

         let nid = self.profile.id();
         let alias = self.profile.aliases().alias(nid);
         let node_id = match self.short {
             true => self::node(nid).to_string(),
             true => self::node_short(nid).to_string(),
             false => nid.to_human(),
         };

     pub fn labels(self) -> (term::Label, term::Label) {
         let alias = match self.alias.as_ref() {
             Some(alias) => term::format::primary(alias).into(),
             None if self.you => term::format::primary(term::format::node(self.nid))
             None if self.you => term::format::primary(term::format::node_short(self.nid))
                 .dim()
                 .into(),
             None => term::Label::blank(),
         };
         let author = self.you().unwrap_or_else(|| {
             term::format::primary(term::format::node(self.nid))
             term::format::primary(term::format::node_short(self.nid))
                 .dim()
                 .into()
         });

 use bytes::Buf;
 use bytes::BufMut;
 use cyphernet::addr::{tor, Addr, HostName, NetAddr};
 use cyphernet::addr::{tor, HostName, NetAddr};
 use radicle::crypto::Signature;
 use radicle::git::Oid;
 use radicle::identity::RepoId;

             _ => true,
         }
     }
     pub fn host(&self) -> &HostName {
         &self.0.host
     }
     pub fn port(&self) -> u16 {
         self.0.port
     }
 }
 impl cyphernet::addr::Host for Address {