fix(mesh): stop advertising 0.0.0.0 to peers

bindings/python/src/lib.rs

@@ -461,6 +461,7 @@ struct Router {
     enable_mesh: bool,
     mesh_server_name: Option<String>,
     mesh_host: String,
+    mesh_advertise_host: Option<String>,
     mesh_port: u16,
     mesh_peer_urls: Vec<String>,
 }
@@ -475,6 +476,19 @@ impl Router {
         core::ConnectionMode::Http
     }
 
+    fn parse_mesh_socket_addr(
+        host: &str,
+        port: u16,
+        field: &str,
+    ) -> PyResult<std::net::SocketAddr> {
+        let addr = format!("{host}:{port}");
+        addr.parse::<std::net::SocketAddr>().map_err(|e| {
+            pyo3::exceptions::PyValueError::new_err(format!(
+                "Invalid value for {field}='{host}': invalid mesh socket address '{addr}': {e}"
+            ))
+        })
+    }
+
     pub fn to_router_config(&self) -> config::ConfigResult<config::RouterConfig> {
         use config::{
             DiscoveryConfig, MetricsConfig, PolicyConfig as ConfigPolicyConfig, RoutingMode,
@@ -831,6 +845,7 @@ impl Router {
         mesh_host = String::from("0.0.0.0"),
         mesh_port = 39527u16,
         mesh_peer_urls = vec![],
+        mesh_advertise_host = None,
     ))]
     #[expect(clippy::too_many_arguments)]
     #[expect(
@@ -936,6 +951,7 @@ impl Router {
         mesh_host: String,
         mesh_port: u16,
         mesh_peer_urls: Vec<String>,
+        mesh_advertise_host: Option<String>,
     ) -> PyResult<Self> {
         let mut all_urls = worker_urls.clone();
 
@@ -1049,6 +1065,7 @@ impl Router {
             enable_mesh,
             mesh_server_name,
             mesh_host,
+            mesh_advertise_host,
             mesh_port,
             mesh_peer_urls,
         })
@@ -1145,15 +1162,28 @@ impl Router {
                             })
                         })
                         .transpose()?;
-                    let self_addr_str = format!("{}:{}", self.mesh_host, self.mesh_port);
-                    let self_addr = self_addr_str.parse::<std::net::SocketAddr>().map_err(|e| {
-                        pyo3::exceptions::PyValueError::new_err(format!(
-                            "Invalid mesh address '{self_addr_str}': {e}"
-                        ))
-                    })?;
+                    let bind_addr =
+                        Self::parse_mesh_socket_addr(&self.mesh_host, self.mesh_port, "mesh_host")?;
+                    let (advertise_host, advertise_field) =
+                        if let Some(host) = self.mesh_advertise_host.as_deref() {
+                            (host, "mesh_advertise_host")
+                        } else {
+                            (self.mesh_host.as_str(), "mesh_host")
+                        };
+                    let advertise_addr = Self::parse_mesh_socket_addr(
+                        advertise_host,
+                        self.mesh_port,
+                        advertise_field,
+                    )?;
+                    if advertise_addr.ip().is_unspecified() {
+                        return Err(pyo3::exceptions::PyValueError::new_err(format!(
+                            "Invalid value for {advertise_field}='{advertise_host}': mesh advertise address cannot be unspecified; set mesh_advertise_host to a routable node IP"
+                        )));
+                    }
                     Some(smg_mesh::MeshServerConfig {
                         self_name,
-                        self_addr,
+                        bind_addr,
+                        advertise_addr,
                         init_peer: peer,
                         mtls_config: None,
                     })

bindings/python/src/smg/router_args.py

@@ -160,6 +160,7 @@ class RouterArgs:
     enable_mesh: bool = False
     mesh_server_name: str | None = None
     mesh_host: str = "0.0.0.0"
+    mesh_advertise_host: str | None = None
     mesh_port: int = 39527
     mesh_peer_urls: list[str] = dataclasses.field(default_factory=list)
 
@@ -1065,6 +1066,15 @@ def add_cli_args(
             default="0.0.0.0",
             help="Mesh server bind address (default: 0.0.0.0)",
         )
+        mesh_group.add_argument(
+            f"--{prefix}mesh-advertise-host",
+            type=str,
+            default=None,
+            help=(
+                "Routable mesh address to advertise to peers."
+                " Required when --mesh-host binds to 0.0.0.0."
+            ),
+        )
         mesh_group.add_argument(
             f"--{prefix}mesh-port",
             type=int,

bindings/python/tests/test_arg_parser.py

@@ -43,6 +43,7 @@ def test_default_values(self):
         assert args.cb_failure_threshold == 10
         assert args.disable_retries is False
         assert args.disable_circuit_breaker is False
+        assert args.mesh_advertise_host is None
 
     def test_parse_selector_valid(self):
         """Test parsing valid selector arguments."""
@@ -595,6 +596,28 @@ def test_parse_health_check_args(self):
         assert router_args.health_check_interval_secs == 30
         assert router_args.health_check_endpoint == "/healthz"
 
+    def test_parse_mesh_advertise_host_args(self):
+        """Test parsing mesh advertise host arguments."""
+        args = [
+            "--enable-mesh",
+            "--mesh-host",
+            "0.0.0.0",
+            "--mesh-advertise-host",
+            "10.0.0.42",
+            "--mesh-port",
+            "39527",
+            "--mesh-peer-urls",
+            "10.0.0.43:39527",
+        ]
+
+        router_args = parse_router_args(args)
+
+        assert router_args.enable_mesh is True
+        assert router_args.mesh_host == "0.0.0.0"
+        assert router_args.mesh_advertise_host == "10.0.0.42"
+        assert router_args.mesh_port == 39527
+        assert router_args.mesh_peer_urls == ["10.0.0.43:39527"]
+
     def test_parse_cors_args(self):
         """Test parsing CORS arguments."""
         args = [

crates/mesh/src/README.md

@@ -982,7 +982,8 @@ Configure mesh in your router configuration file:
 mesh:
   enabled: true
   self_name: "router-node-1"
-  self_addr: "0.0.0.0:8000"
+  bind_addr: "0.0.0.0:8000"
+  advertise_addr: "10.0.0.11:8000"
   init_peer: "router-node-2:8000"  # Optional: initial peer for bootstrap
 ```
 

crates/mesh/src/controller.rs

@@ -781,6 +781,7 @@ impl MeshController {
                                         let service = GossipService::new(
                                             Arc::new(parking_lot::RwLock::new(BTreeMap::new())),
                                             SocketAddr::from(([0, 0, 0, 0], 0)),
+                                            SocketAddr::from(([0, 0, 0, 0], 0)),
                                             &self_name,
                                         )
                                         .with_stores(stores.clone())

crates/mesh/src/ping_server.rs

@@ -44,7 +44,8 @@ use super::{
 #[derive(Debug)]
 pub struct GossipService {
     state: ClusterState,
-    self_addr: SocketAddr,
+    listen_addr: SocketAddr,
+    advertise_addr: SocketAddr,
     self_name: String,
     stores: Option<Arc<StateStores>>, // Optional state stores for CRDT-based sync
     sync_manager: Option<Arc<MeshSyncManager>>, // Optional sync manager for applying remote updates
@@ -232,10 +233,16 @@ impl GossipService {
 }
 
 impl GossipService {
-    pub fn new(state: ClusterState, self_addr: SocketAddr, self_name: &str) -> Self {
+    pub fn new(
+        state: ClusterState,
+        listen_addr: SocketAddr,
+        advertise_addr: SocketAddr,
+        self_name: &str,
+    ) -> Self {
         Self {
             state,
-            self_addr,
+            listen_addr,
+            advertise_addr,
             self_name: self_name.to_string(),
             stores: None,
             sync_manager: None,
@@ -277,7 +284,7 @@ impl GossipService {
         self,
         signal: F,
     ) -> Result<()> {
-        let listen_addr = self.self_addr;
+        let listen_addr = self.listen_addr;
         let service = GossipServer::new(self)
             .max_decoding_message_size(MAX_MESSAGE_SIZE)
             .max_encoding_message_size(MAX_MESSAGE_SIZE)
@@ -361,7 +368,7 @@ impl Gossip for GossipService {
                 };
                 Ok(Response::new(NodeUpdate {
                     name: self.self_name.clone(),
-                    address: self.self_addr.to_string(),
+                    address: self.advertise_addr.to_string(),
                     status: current_status,
                 }))
             }
@@ -800,7 +807,8 @@ impl Gossip for GossipService {
                                     // Generate and send snapshot chunks
                                     let service = GossipService {
                                         state: state.clone(),
-                                        self_addr: SocketAddr::from(([0, 0, 0, 0], 0)), // Not used in snapshot generation
+                                        listen_addr: SocketAddr::from(([0, 0, 0, 0], 0)), // Not used in snapshot generation
+                                        advertise_addr: SocketAddr::from(([0, 0, 0, 0], 0)), // Not used in snapshot generation
                                         self_name: self_name.clone(),
                                         stores: stores.clone(),
                                         sync_manager: sync_manager.clone(),