httpd: `rad web --connect` takes an argument

To be able to connect to any running httpd, have `--connect` take the
address of the running daemon.

radicle-cli/src/terminal/args.rs

@@ -1,4 +1,5 @@
 use std::ffi::OsString;
+use std::net::SocketAddr;
 use std::str::FromStr;
 use std::time;
 
@@ -128,6 +129,11 @@ pub fn pubkey(val: &OsString) -> anyhow::Result<NodeId> {
     Ok(did.as_key().to_owned())
 }
 
+pub fn socket_addr(val: &OsString) -> anyhow::Result<SocketAddr> {
+    let val = val.to_string_lossy();
+    SocketAddr::from_str(&val).map_err(|_| anyhow!("invalid socket address '{}'", val))
+}
+
 pub fn addr(val: &OsString) -> anyhow::Result<Address> {
     let val = val.to_string_lossy();
     Address::from_str(&val).map_err(|_| anyhow!("invalid address '{}'", val))

radicle-httpd/src/commands/web.rs

@@ -26,10 +26,10 @@ Usage
 
 Options
 
-    --listen, -l           Address to bind the HTTP daemon to (default: 127.0.0.1:8080)
+    --listen, -l  <addr>     Address to bind the HTTP daemon to (default: 127.0.0.1:8080)
-    --connect, -c          Connect the explorer to an already running daemon
+    --connect, -c [<addr>]   Connect the explorer to an already running daemon (default: 127.0.0.1:8080)
-    --no-open              Don't open the authentication URL automatically
+    --[no-]open              Open the authentication URL automatically (default: open)
-    --help                 Print help
+    --help                   Print help
 "#,
 };
 
@@ -44,7 +44,7 @@ pub struct SessionInfo {
 pub struct Options {
     pub app_url: Url,
     pub listen: SocketAddr,
-    pub connect: bool,
+    pub connect: Option<SocketAddr>,
     pub open: bool,
 }
 
@@ -54,27 +54,29 @@ impl Args for Options {
 
         let mut parser = lexopt::Parser::from_args(args);
         let mut listen = None;
+        let mut connect = None;
         // SAFETY: This is a valid URL.
         #[allow(clippy::unwrap_used)]
         let mut app_url = Url::parse("https://app.radicle.xyz").unwrap();
-        let mut connect = false;
         let mut open = true;
 
         while let Some(arg) = parser.next()? {
             match arg {
-                Long("listen") | Short('l') => {
+                Long("listen") | Short('l') if listen.is_none() => {
-                    listen = Some(
+                    let val = parser.value()?;
-                        parser
+                    listen = Some(term::args::socket_addr(&val)?);
-                            .value()?
-                            .to_string_lossy()
-                            .as_ref()
-                            .parse::<SocketAddr>()
-                            .context("argument for '--listen' is not a valid socket address")?,
-                    )
                 }
-                Long("connect") | Short('c') => {
+                Long("connect") | Short('c') if connect.is_none() => {
-                    connect = true;
+                    if let Ok(val) = parser.value() {
+                        connect = Some(term::args::socket_addr(&val)?);
+                    } else {
+                        connect = Some(SocketAddr::new(
+                            IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
+                            8080,
+                        ));
+                    }
                 }
+                Long("open") => open = true,
                 Long("no-open") => open = false,
                 Long("help") | Short('h') => {
                     return Err(Error::Help.into());
@@ -112,8 +114,7 @@ pub fn sign(signer: Box<dyn Signer>, session: &SessionInfo) -> Result<Signature,
 
 pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
     let profile = ctx.profile()?;
-
+    let runtime_and_handle = if options.connect.is_none() {
-    let runtime_and_handle = if !options.connect {
         tracing_subscriber::fmt::init();
 
         let runtime = tokio::runtime::Builder::new_multi_thread()
@@ -130,16 +131,18 @@ pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {
         None
     };
 
-    let mut num_retries = 30;
+    let mut retries = 30;
+    let connect = options.connect.unwrap_or(options.listen);
     let response = loop {
-        num_retries -= 1;
+        retries -= 1;
         sleep(Duration::from_millis(100));
-        match ureq::post(&format!("http://{}/api/v1/sessions", options.listen)).call() {
+
+        match ureq::post(&format!("http://{connect}/api/v1/sessions")).call() {
             Ok(response) => {
                 break response;
             }
             Err(err) => {
-                if err.kind() == ureq::ErrorKind::ConnectionFailed && num_retries > 0 {
+                if err.kind() == ureq::ErrorKind::ConnectionFailed && retries > 0 {
                     continue;
                 } else {
                     anyhow::bail!(err);