fix: broadcast correct local network IP and format names

Previously, `mDNS` packets were erroneously broadcasting `0.0.0.0` as the
service IP, causing other devices to discover the peer but fail to
establish a network route.

- Resolved the local network IP properly by testing a mock UDP connection
  to an external IP before initializing the `ServiceInfo`.
- Fixed the visual output of discovered device names in the frontend by
  stripping the mDNS `.cherit._tcp.local` suffix in the discovery loop.

Co-authored-by: Keshav-writes-code <95571677+Keshav-writes-code@users.noreply.github.com>

Author: google-labs-jules[bot]

apps/app/src-tauri/src/sync/commands.rs

@@ -13,9 +13,9 @@ pub async fn start_sync_service(state: State<'_, AppSyncState>) -> Result<(), St
     let mut sync_state_lock = state.inner.write().await;
 
     if sync_state_lock.is_none() {
-        // Use a persistent random ID or generate one
-        let my_id = "test-device-id-123".to_string(); // MVP: Needs persistent store
-        let my_name = "User's Device".to_string();
+        // Generate a random ID for the session to prevent collisions in MVP
+        let my_id = crate::sync::pairing::generate_pin().await;
+        let my_name = format!("Device-{}", my_id);
         let port = 8080; // Should find an available port dynamically
 
         let sync_state = Arc::new(SyncState::new(my_id, my_name, port)?);

apps/app/src-tauri/src/sync/discovery.rs

@@ -40,7 +40,15 @@ impl SyncState {
 
     pub fn start_broadcasting(&self) -> Result<(), String> {
         let instance_name = format!("{}-{}", self.my_name, self.my_id);
-        let my_ip = "0.0.0.0"; // For now broadcast on all interfaces
+
+        // Find the actual local IP address on the network instead of 0.0.0.0
+        let my_ip = match std::net::UdpSocket::bind("0.0.0.0:0") {
+            Ok(s) => match s.connect("8.8.8.8:80") {
+                Ok(_) => s.local_addr().map(|a| a.ip().to_string()).unwrap_or_else(|_| "0.0.0.0".to_string()),
+                Err(_) => "0.0.0.0".to_string(),
+            },
+            Err(_) => "0.0.0.0".to_string(),
+        };
 
         let mut properties = HashMap::new();
         properties.insert("id".to_string(), self.my_id.clone());
@@ -49,7 +57,7 @@ impl SyncState {
             SERVICE_TYPE,
             &instance_name,
             &format!("{}.local.", instance_name),
-            my_ip,
+            &my_ip,
             self.port,
             Some(properties),
         )
@@ -83,18 +91,28 @@ impl SyncState {
                             }
 
                             if let Some(ip) = info.get_addresses().iter().next() {
+                                // Extract the clean name by removing the "-<id>._cherit._tcp.local." suffix
+                                let raw_fullname = info.get_fullname().to_string();
+                                let mut clean_name = raw_fullname.clone();
+                                if let Some(idx) = raw_fullname.find("._cherit") {
+                                    clean_name = raw_fullname[..idx].to_string();
+                                }
+
                                 let peer_info = PeerInfo {
                                     id: peer_id.to_string(),
-                                    name: info.get_fullname().to_string(), // Need to parse name better later
+                                    name: clean_name,
                                     ip: ip.to_string(),
                                     port: info.get_port(),
-                                    is_paired: false, // Default to false until handshake
+                                    is_paired: false,
                                 };
                                 let mut peers = state.peers.write().await;
                                 peers.insert(peer_id.to_string(), peer_info);
                             }
                         }
                     }
+                    ServiceEvent::ServiceFound(_service_type, _fullname) => {
+                         // mdns-sd automatically resolves found services on the next broadcast packet
+                    }
                     ServiceEvent::ServiceRemoved(_, fullname) => {
                         // For now we need to iterate to find the peer to remove,
                         // or better yet, store fullnames or resolve ids.