fix(relay): correct data plane wiring and fix multiple peer management bugs

Relay mode had the instruction/response data flow reversed — instructions
from the entry were looped back instead of fanned out to exit peers, and
exit responses went nowhere instead of upstream. This made relay data
transfer non-functional. Swap the uni-stream wiring so instructions fan
out entry→exits and responses fan in exits→entry.

Also fixes:
- Relay source peer not registered in the registry (invisible in
  `wallhack peers`)
- Exit connect mode never calling `update_capabilities()`, causing
  all peers to show tun=false listen=false connect=false
- Entry connect mode discarding latency measurements (latency always
  showed `—` until manual ping)
- Auto-mode dispatch destructuring ErasedConnectResult into 13 positional
  args instead of passing the struct directly

Verified in range UAT: relay chain (entry ← relay ← exit) stays stable,
peer role correctly shows `relay`, latency auto-populates on connect.
Data flow blocked by a separate issue: SYN proxy uses direct bidi streams
which bypass the relay's uni-stream bridge (tracked in TODO).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: maxholman

crates/core/src/client/client.rs

@@ -44,6 +44,8 @@ pub struct ConnectResult<T: wallhack_transport::Transport + ?Sized> {
     control_tx: mpsc::Sender<ControlMessage>,
     /// Receiver for the server's `Handshake` (delivered via the control loop).
     peer_handshake_rx: Option<oneshot::Receiver<Handshake>>,
+    /// Pong-derived latency measurements from the control loop (milliseconds).
+    latency_rx: Option<mpsc::Receiver<f64>>,
 }
 
 impl<T: wallhack_transport::Transport + ?Sized> ConnectResult<T> {
@@ -55,6 +57,7 @@ impl<T: wallhack_transport::Transport + ?Sized> ConnectResult<T> {
         tasks: ConnectionTasks,
         control_tx: mpsc::Sender<ControlMessage>,
         peer_handshake_rx: Option<oneshot::Receiver<Handshake>>,
+        latency_rx: Option<mpsc::Receiver<f64>>,
     ) -> Self {
         Self {
             channels,
@@ -63,6 +66,7 @@ impl<T: wallhack_transport::Transport + ?Sized> ConnectResult<T> {
             transport,
             control_tx,
             peer_handshake_rx,
+            latency_rx,
         }
     }
 
@@ -106,6 +110,8 @@ pub struct ErasedConnectResult {
     pub control_tx: mpsc::Sender<ControlMessage>,
     pub peer_handshake_rx: Option<oneshot::Receiver<Handshake>>,
     pub peer_addr: String,
+    /// Pong-derived latency measurements from the control loop (milliseconds).
+    pub latency_rx: Option<mpsc::Receiver<f64>>,
 }
 
 impl<T> ConnectResult<T>
@@ -129,6 +135,7 @@ where
             channels: self.channels,
             tasks: self.tasks,
             control_tx: self.control_tx,
+            latency_rx: self.latency_rx,
         }
     }
 }

crates/core/src/client/quic/mod.rs

@@ -169,15 +169,16 @@ impl Client for QuicClient {
 
         // Create oneshot for receiving server's Handshake via the control loop.
         let (handshake_tx, handshake_rx) = tokio::sync::oneshot::channel::<Handshake>();
+        let (latency_tx, latency_rx) = tokio::sync::mpsc::channel::<f64>(4);
 
         // Spawn control stream task
         let transport_ctrl = Arc::clone(&transport);
         let control_handle = tokio::spawn(async move {
             let mut channels = protocol::ControlChannels {
                 outgoing_rx: control_rx,
                 handshake_tx: Some(handshake_tx), // receive server's Handshake
-                latency_tx: None,                 // pong handled inline
-                control_response_tx: None,        // no ControlResponse channel needed now
+                latency_tx: Some(latency_tx),
+                control_response_tx: None,
                 role_transition_tx: None,
             };
             match protocol::run_control_stream_initiator(
@@ -230,6 +231,7 @@ impl Client for QuicClient {
             tasks,
             control_tx,
             Some(handshake_rx),
+            Some(latency_rx),
         ))
     }
 

crates/core/src/client/ws/mod.rs

@@ -386,14 +386,15 @@ impl WsClient {
 
         // Create oneshot for receiving server's Handshake via the control loop.
         let (handshake_tx, handshake_rx) = tokio::sync::oneshot::channel::<Handshake>();
+        let (latency_tx, latency_rx) = tokio::sync::mpsc::channel::<f64>(4);
 
         // Spawn control stream task
         let transport_ctrl = Arc::clone(&transport);
         let control_handle = tokio::spawn(async move {
             let mut channels = protocol::ControlChannels {
                 outgoing_rx: control_rx,
                 handshake_tx: Some(handshake_tx), // receive server's Handshake
-                latency_tx: None,
+                latency_tx: Some(latency_tx),
                 control_response_tx: None,
                 role_transition_tx: None,
             };
@@ -447,6 +448,7 @@ impl WsClient {
             tasks,
             control_tx,
             Some(handshake_rx),
+            Some(latency_rx),
         ))
     }
 }

crates/daemon/src/mode/auto.rs

@@ -259,17 +259,8 @@ async fn run_auto_connector(
                         let r = Arc::clone(&routes);
                         let ru = ru.resubscribe();
                         async move {
-                            let peer_handshake_rx = e.peer_handshake_rx;
-                            let transport = e.transport;
-                            let channels = e.channels;
-                            let tasks = e.tasks;
-                            let control_tx = e.control_tx;
                             run_auto_connect_session_dispatch(
-                                peer_handshake_rx,
-                                transport,
-                                channels,
-                                tasks,
-                                control_tx,
+                                e,
                                 &lhs,
                                 &pa,
                                 metrics,
@@ -319,17 +310,8 @@ async fn run_auto_connector(
                         let r = Arc::clone(&routes);
                         let ru = ru.resubscribe();
                         async move {
-                            let peer_handshake_rx = e.peer_handshake_rx;
-                            let transport = e.transport;
-                            let channels = e.channels;
-                            let tasks = e.tasks;
-                            let control_tx = e.control_tx;
                             run_auto_connect_session_dispatch(
-                                peer_handshake_rx,
-                                transport,
-                                channels,
-                                tasks,
-                                control_tx,
+                                e,
                                 &lhs,
                                 &pa,
                                 metrics,
@@ -354,11 +336,7 @@ async fn run_auto_connector(
 /// Non-generic auto-connector dispatch: negotiates role and runs the session.
 #[allow(clippy::too_many_arguments, clippy::too_many_lines)]
 async fn run_auto_connect_session_dispatch(
-    peer_handshake_rx: Option<tokio::sync::oneshot::Receiver<Handshake>>,
-    transport: Arc<dyn ErasedTransport>,
-    channels: DataChannels,
-    tasks: wallhack_core::client::client::ConnectionTasks,
-    control_tx: tokio::sync::mpsc::Sender<wallhack_wire::control::ControlMessage>,
+    connect_result: wallhack_core::client::client::ErasedConnectResult,
     local_hs: &Handshake,
     peer_addr: &str,
     metrics: Arc<Metrics>,
@@ -369,6 +347,16 @@ async fn run_auto_connect_session_dispatch(
         tokio::sync::broadcast::Receiver<wallhack_core::control::routes::RouteUpdate>,
     >,
 ) -> Result<(), NodeError> {
+    let wallhack_core::client::client::ErasedConnectResult {
+        peer_handshake_rx,
+        transport,
+        channels,
+        tasks,
+        control_tx,
+        peer_addr: _,
+        latency_rx,
+    } = connect_result;
+
     let DataChannels {
         instructions_tx,
         instructions_rx,
@@ -435,6 +423,8 @@ async fn run_auto_connect_session_dispatch(
                 &metrics,
                 peer_addr,
                 Some(peer_name),
+                Some(Arc::clone(&peers)),
+                latency_rx,
                 routes,
                 route_updates,
             )

crates/daemon/src/mode/entry.rs

@@ -316,6 +316,7 @@ pub(crate) async fn run_entry_connect(
     }
 
     let peer_addr = endpoint.to_string();
+    let peers = Arc::clone(&res.peers);
     let security = SecurityParams {
         psk: global.psk.clone(),
         accept_fingerprint: None,
@@ -352,11 +353,12 @@ pub(crate) async fn run_entry_connect(
                     move |connect_result| {
                         let e = connect_result.erase();
                         let m = Arc::clone(&metrics);
+                        let p = Arc::clone(&peers);
                         let r = Arc::clone(&routes);
                         let ru = r_updates.resubscribe();
                         let pa = peer_addr.clone();
                         async move {
-                            run_entry_connected_erased(e, &m, &pa, Some(r), Some(ru)).await
+                            run_entry_connected_erased(e, &m, &pa, Some(p), Some(r), Some(ru)).await
                         }
                     },
                     RECONNECT_DELAY,
@@ -388,11 +390,12 @@ pub(crate) async fn run_entry_connect(
                     move |connect_result| {
                         let e = connect_result.erase();
                         let m = Arc::clone(&metrics);
+                        let p = Arc::clone(&peers);
                         let r = Arc::clone(&routes);
                         let ru = r_updates.resubscribe();
                         let pa = peer_addr.clone();
                         async move {
-                            run_entry_connected_erased(e, &m, &pa, Some(r), Some(ru)).await
+                            run_entry_connected_erased(e, &m, &pa, Some(p), Some(r), Some(ru)).await
                         }
                     },
                     RECONNECT_DELAY,
@@ -429,6 +432,7 @@ pub(crate) async fn run_entry_connected_erased(
     connect_result: wallhack_core::client::client::ErasedConnectResult,
     metrics: &Arc<Metrics>,
     peer_addr: &str,
+    peers: Option<Arc<Registry>>,
     routes: Option<SharedRouteTable>,
     route_updates: Option<
         tokio::sync::broadcast::Receiver<wallhack_core::control::routes::RouteUpdate>,
@@ -443,6 +447,7 @@ pub(crate) async fn run_entry_connected_erased(
         tasks: _tasks,
         control_tx,
         peer_addr: _,
+        latency_rx,
     } = connect_result;
 
     // Wait for the server's handshake to get the peer name
@@ -478,6 +483,8 @@ pub(crate) async fn run_entry_connected_erased(
         metrics,
         peer_addr,
         peer_name.as_deref(),
+        peers,
+        latency_rx,
         routes,
         route_updates,
     )
@@ -495,6 +502,8 @@ pub(crate) async fn run_entry_connected_inner(
     metrics: &Arc<Metrics>,
     peer_addr: &str,
     peer_name: Option<&str>,
+    peers: Option<Arc<Registry>>,
+    latency_rx: Option<tokio::sync::mpsc::Receiver<f64>>,
     routes: Option<SharedRouteTable>,
     route_updates: Option<
         tokio::sync::broadcast::Receiver<wallhack_core::control::routes::RouteUpdate>,
@@ -574,6 +583,19 @@ pub(crate) async fn run_entry_connected_inner(
         tracing::debug!("Initial ping failed: {e}");
     }
 
+    // Consume latency measurements from the control loop and update the registry.
+    if let (Some(mut lat_rx), Some(reg)) = (latency_rx, &peers) {
+        let peer_id = peer_name.map(std::string::ToString::to_string);
+        let reg = Arc::clone(reg);
+        tokio::spawn(async move {
+            while let Some(ms) = lat_rx.recv().await {
+                if let Some(ref id) = peer_id {
+                    reg.update_latency(id, ms);
+                }
+            }
+        });
+    }
+
     let manager_handle = tokio::spawn(async move { manager.run().await });
 
     match manager_handle.await {

crates/daemon/src/mode/exit.rs

@@ -416,9 +416,13 @@ async fn run_exit_loop_inner(
 
     tracing::info!("Connected to {peer_addr}");
 
-    // Resolve the peer's handshake name (delivered asynchronously via the
+    // Resolve the peer's handshake (delivered asynchronously via the
     // control loop). Fall back to the address if unavailable.
-    let peer_name = resolve_peer_name(peer_handshake_rx, peer_addr).await;
+    let peer_handshake = resolve_peer_handshake(peer_handshake_rx).await;
+    let peer_name = peer_handshake
+        .as_ref()
+        .filter(|h| !h.name.is_empty())
+        .map_or_else(|| peer_addr.to_string(), |h| h.name.clone());
 
     // We connected to the entry peer, so side=Connect.
     ctx.peers.register(
@@ -428,6 +432,14 @@ async fn run_exit_loop_inner(
         ConnectionSide::Connect,
     );
 
+    // Apply the peer's advertised capabilities from the handshake.
+    let peer_capabilities = peer_handshake
+        .as_ref()
+        .and_then(|h| h.capabilities)
+        .unwrap_or_default();
+    ctx.peers
+        .update_capabilities(&peer_name, &peer_capabilities);
+
     // Outgoing: open uni stream to entry peer, send responses.
     let transport_out = Arc::clone(&transport);
     tokio::spawn(async move {
@@ -475,20 +487,18 @@ async fn run_exit_loop_inner(
     Ok(())
 }
 
-/// Await the peer's handshake name from a oneshot receiver (with timeout).
+/// Await the peer's handshake from a oneshot receiver (with timeout).
 ///
-/// Returns the handshake name if non-empty, otherwise falls back to the
-/// peer address.
-async fn resolve_peer_name(
+/// Returns the received `Handshake` if available within the timeout, or
+/// `None` if the receiver is absent, the sender dropped, or the timeout
+/// expires.
+async fn resolve_peer_handshake(
     rx: Option<tokio::sync::oneshot::Receiver<wallhack_wire::data::Handshake>>,
-    peer_addr: &str,
-) -> String {
-    let Some(rx) = rx else {
-        return peer_addr.to_string();
-    };
+) -> Option<wallhack_wire::data::Handshake> {
+    let rx = rx?;
     match tokio::time::timeout(std::time::Duration::from_secs(10), rx).await {
-        Ok(Ok(hs)) if !hs.name.is_empty() => hs.name,
-        _ => peer_addr.to_string(),
+        Ok(Ok(hs)) => Some(hs),
+        _ => None,
     }
 }