fix: reconnect mobile relay after returning from background

On foreground, the app called relay.connect(), which bails when a socket
is still assigned (`guard task == nil`). iOS suspends the process in the
background, so the WebSocket can die without the receive/ping failure
callbacks ever firing to clear `task` and schedule a reconnect — leaving a
stale dead socket that made connect() a permanent no-op.

- Add RelayClient.reconnect(): tears down any existing socket, resets the
  backoff counter, and reopens. SyncClient.start() now uses it (at launch
  task is nil, so it behaves like a plain connect).
- Serialize background/foreground transitions in MobileAppState via a
  lifecycleTask chain so a delayed stop() can't land after a later start()
  and disable the relay for good.

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

Author: sirily11

Packages/Sources/RxCodeSync/SyncClient.swift

@@ -46,9 +46,18 @@ public actor SyncClient: PeerManagerHost {
     }
 
     public func start() async {
-        await relay.connect()
+        // `reconnect()` (not `connect()`) so a stale socket left behind by an
+        // OS suspend is torn down and reopened. At initial startup `task` is nil,
+        // so this behaves exactly like a plain connect.
+        await relay.reconnect()
         guard directPathsEnabled else { return }
         startHubIfNeeded()
+        // `stop()` cancelled every per-peer event pump and dropped the managers;
+        // rebuild them from the persisted peer set so direct-path links — and the
+        // inbound data (snapshots, history) they carry — come back after a
+        // background cycle. Without this the LAN link re-promotes but its events
+        // reach no subscriber, and the app appears connected yet loads nothing.
+        for (hex, key) in peers { startManager(forHex: hex, key: key) }
     }
 
     public func stop() async {
@@ -59,6 +68,12 @@ public actor SyncClient: PeerManagerHost {
         pathMonitor?.cancel(); pathMonitor = nil
         await advertiser?.stop()
         await browser?.stop()
+        // Drop the per-peer managers. Their event pumps were just cancelled and
+        // their direct sockets die when the OS suspends us; tearing them down and
+        // rebuilding on `start()` avoids reusing a manager stuck with a dead
+        // `active` transport (which blocks redial and silently swallows data).
+        for manager in managers.values { await manager.teardown() }
+        managers.removeAll()
         hubStarted = false
     }
 
@@ -77,6 +92,13 @@ public actor SyncClient: PeerManagerHost {
         guard let raw = Data(hexString: pubkeyHex) else { throw SyncError.invalidPubkey }
         let key = try Curve25519.KeyAgreement.PublicKey(rawRepresentation: raw)
         peers[pubkeyHex] = key
+        startManager(forHex: pubkeyHex, key: key)
+    }
+
+    /// Create the per-peer manager and its event pump, unless direct paths are
+    /// disabled or one is already running. Idempotent: called both when a peer is
+    /// added and when `start()` rebuilds managers after a background cycle.
+    private func startManager(forHex pubkeyHex: String, key: Curve25519.KeyAgreement.PublicKey) {
         guard directPathsEnabled, managers[pubkeyHex] == nil else { return }
         let manager = PeerConnectionManager(peerHex: pubkeyHex, peerKey: key, identity: identity, relay: relay, host: self)
         managers[pubkeyHex] = manager
@@ -85,8 +107,9 @@ public actor SyncClient: PeerManagerHost {
             for await event in stream { await self?.emitUp(event) }
         }
         // A peer added while the relay is already connected (e.g. right after
-        // pairing) would otherwise miss the `.stateChanged(.connected)` that
-        // triggers the first candidate offer. Offer immediately in that case.
+        // pairing, or on a foreground rebuild) would otherwise miss the
+        // `.stateChanged(.connected)` that triggers the first candidate offer.
+        // Offer immediately in that case.
         track { [weak self, weak manager] in
             guard let self, let manager else { return }
             if await self.relayIsConnected { await manager.offerLocalCandidates() }

Packages/Sources/RxCodeSync/Transport/PeerConnectionManager.swift

@@ -81,6 +81,20 @@ public actor PeerConnectionManager {
 
     public var currentPath: ConnectionPathKind { activePath }
 
+    /// Disconnect every link and clear connection state. Called when the hub
+    /// stops (app backgrounding); the hub then drops this manager and builds a
+    /// fresh one on the next start, so we close sockets cleanly rather than
+    /// leaking dead `NWConnection`s across a suspend.
+    public func teardown() async {
+        retryTask?.cancel(); retryTask = nil
+        for info in probing.values { await info.transport.disconnect() }
+        probing.removeAll()
+        await active?.disconnect()
+        active = nil
+        activePath = .relay
+        knownTargets.removeAll()
+    }
+
     public func events() -> AsyncStream<TransportEvent> {
         AsyncStream { continuation in
             let id = UUID()

Packages/Sources/RxCodeSync/Transport/RelayClient.swift

@@ -56,12 +56,30 @@ public actor RelayClient: Transport {
     }
 
     public func connect() {
-        guard task == nil else { return }
+        guard task == nil else {
+            logger.info("[Relay] connect skipped — socket already assigned relay=\(self.relayURL.absoluteString, privacy: .public) state=\(String(describing: self.state), privacy: .public)")
+            return
+        }
         shouldReconnect = true
         logger.info("[Relay] connect requested relay=\(self.relayURL.absoluteString, privacy: .public) localKey=\(String(self.identity.publicKeyHex.prefix(12)), privacy: .public)")
         openSocket()
     }
 
+    /// Force a clean reconnect. Unlike `connect()`, this does not bail when a
+    /// socket is still assigned — it tears down any existing (possibly stale)
+    /// socket first, then reopens. This is the correct entry point on app
+    /// foreground: iOS suspends the process in the background, so the socket can
+    /// die without `receiveOne`/`sendPing` ever firing the failure callback that
+    /// would clear `task`. On resume `task` may still reference a dead socket,
+    /// which would make a plain `connect()` no-op forever.
+    public func reconnect() {
+        shouldReconnect = true
+        logger.info("[Relay] reconnect requested relay=\(self.relayURL.absoluteString, privacy: .public) localKey=\(String(self.identity.publicKeyHex.prefix(12)), privacy: .public)")
+        closeSocketLocally()
+        reconnectAttempt = 0
+        openSocket()
+    }
+
     public func disconnect() {
         shouldReconnect = false
         logger.info("[Relay] disconnect requested relay=\(self.relayURL.absoluteString, privacy: .public) localKey=\(String(self.identity.publicKeyHex.prefix(12)), privacy: .public)")
@@ -105,10 +123,16 @@ public actor RelayClient: Transport {
         // the race. Opening another would register a second connection for the
         // same pubkey on the relay — the cause of duplicate registrations when
         // resuming from background. Never stack sockets.
-        guard task == nil else { return }
+        guard task == nil else {
+            logger.info("[Relay] openSocket skipped — socket already assigned relay=\(self.relayURL.absoluteString, privacy: .public) state=\(String(describing: self.state), privacy: .public)")
+            return
+        }
         // A disconnect() may have landed while a scheduled reconnect was still
         // sleeping; honour it instead of reopening.
-        guard shouldReconnect else { return }
+        guard shouldReconnect else {
+            logger.info("[Relay] openSocket skipped — shouldReconnect=false relay=\(self.relayURL.absoluteString, privacy: .public)")
+            return
+        }
 
         updateState(.connecting)
 

RxCodeMobile/RxCodeMobileApp.swift

@@ -41,7 +41,8 @@ struct RxCodeMobileApp: App {
                     handlePairingURL(url)
                 }
         }
-        .onChange(of: scenePhase) { _, newPhase in
+        .onChange(of: scenePhase) { oldPhase, newPhase in
+            NSLog("[Lifecycle] scenePhase \(String(describing: oldPhase)) -> \(String(describing: newPhase))")
             state.handleScenePhase(newPhase)
         }
     }

RxCodeMobile/State/MobileAppState.swift

@@ -270,6 +270,10 @@ final class MobileAppState: ObservableObject {
     var client: SyncClient
     let logger = Logger(subsystem: "com.idealapp.RxCodeMobile", category: "MobileAppState")
     var eventTask: Task<Void, Never>?
+    /// Serializes background/foreground relay transitions so a delayed
+    /// `stop()` can never land after a later `start()` and leave the relay
+    /// permanently disconnected.
+    var lifecycleTask: Task<Void, Never>?
     var pairingTimeoutTask: Task<Void, Never>?
     var apnsTokenHex: String?
     var apnsEnvironment: String?
@@ -394,21 +398,39 @@ final class MobileAppState: ObservableObject {
     /// relay's registration table in sync with reality and gives a clean,
     /// single re-register on the next foreground.
     func handleScenePhase(_ phase: ScenePhase) {
-        guard clientStarted else { return }
+        guard clientStarted else {
+            logger.info("[Lifecycle] handleScenePhase \(String(describing: phase), privacy: .public) ignored — clientStarted=false")
+            return
+        }
         switch phase {
         case .background:
             logger.info("[Lifecycle] entering background — disconnecting relay")
-            Task { await client.stop() }
+            enqueueLifecycle(label: "background/stop") { [client] in await client.stop() }
         case .active:
             logger.info("[Lifecycle] entering foreground — reconnecting relay")
-            Task { await client.start() }
+            enqueueLifecycle(label: "foreground/start") { [client] in await client.start() }
         case .inactive:
             break
         @unknown default:
             break
         }
     }
 
+    /// Chain a relay lifecycle transition after any in-flight one so they run
+    /// strictly in the order the scene phases arrived. Two bare `Task {}`s race:
+    /// a background `stop()` could otherwise complete after a foreground
+    /// `start()` and disable the relay for good.
+    private func enqueueLifecycle(label: String, _ work: @escaping @Sendable () async -> Void) {
+        let previous = lifecycleTask
+        lifecycleTask = Task { [logger] in
+            logger.info("[Lifecycle] \(label, privacy: .public) queued — awaiting previous transition")
+            await previous?.value
+            logger.info("[Lifecycle] \(label, privacy: .public) running")
+            await work()
+            logger.info("[Lifecycle] \(label, privacy: .public) done")
+        }
+    }
+
     func startClient() async {
         clientStarted = true
         for desktop in pairedDesktops {