fix(ios): add reconnection jitter and max retry limit

Add jitter to exponential backoff in both BufferWebSocketClient and
ReconnectionManager to prevent thundering herd on server restart.
Cap BufferWebSocketClient reconnection at 10 attempts.

Integrates PR amantus-ai#593.

Author: niklassaers

ios/VibeTunnel/Services/BufferWebSocketClient.swift

@@ -836,13 +836,30 @@ class BufferWebSocketClient: NSObject {
         self.scheduleReconnect()
     }
 
+    /// Maximum number of reconnection attempts before giving up
+    private static let maxReconnectAttempts = 10
+
     private func scheduleReconnect() {
         guard self.reconnectTask == nil else { return }
 
-        let delay = min(pow(2.0, Double(reconnectAttempts)), 30.0)
+        // Stop reconnecting after max attempts to prevent infinite retries
+        guard self.reconnectAttempts < Self.maxReconnectAttempts else {
+            self.logger.warning(
+                "Max reconnect attempts (\(Self.maxReconnectAttempts)) reached, stopping")
+            self.connectionError = WebSocketError.connectionFailed
+            return
+        }
+
+        // Calculate exponential backoff with jitter to prevent thundering herd
+        let baseDelay = pow(2.0, Double(self.reconnectAttempts))
+        let cappedDelay = min(baseDelay, 30.0)
+        let jitter = cappedDelay * 0.3 * Double.random(in: 0...1)
+        let delay = cappedDelay + jitter
+
         self.reconnectAttempts += 1
 
-        self.logger.info("Reconnecting in \(delay)s (attempt \(self.reconnectAttempts))")
+        self.logger.info(
+            "Reconnecting in \(String(format: "%.1f", delay))s (attempt \(self.reconnectAttempts)/\(Self.maxReconnectAttempts))")
 
         self.reconnectTask = Task { @MainActor [weak self] in
             let nanoseconds = UInt64(delay * 1_000_000_000)

ios/VibeTunnel/Services/ReconnectionManager.swift

@@ -88,8 +88,12 @@ class ReconnectionManager {
                 self.currentRetry += 1
 
                 if self.currentRetry < self.maxRetries {
-                    // Calculate exponential backoff
-                    let backoffSeconds = min(pow(2.0, Double(currentRetry - 1)), 60.0)
+                    // Calculate exponential backoff with jitter to prevent thundering herd
+                    let backoffSeconds = Self.calculateBackoff(
+                        attempt: self.currentRetry,
+                        baseDelay: 1.0,
+                        maxDelay: 60.0,
+                        jitterFactor: 0.3)
                     self.nextRetryTime = Date().addingTimeInterval(backoffSeconds)
 
                     try? await Task.sleep(for: .seconds(backoffSeconds))
@@ -110,15 +114,33 @@ class ReconnectionManager {
 // MARK: - Exponential Backoff Calculator
 
 extension ReconnectionManager {
-    /// Calculate the next retry delay using exponential backoff
+    /// Calculate the next retry delay using exponential backoff with jitter.
+    ///
+    /// Jitter prevents the "thundering herd" problem where many clients
+    /// reconnect simultaneously after a server restart or network outage.
+    /// The randomized delay spreads reconnection attempts over time,
+    /// reducing server load spikes.
+    ///
+    /// - Parameters:
+    ///   - attempt: The current retry attempt number (1-indexed)
+    ///   - baseDelay: Initial delay in seconds (default: 1.0)
+    ///   - maxDelay: Maximum delay cap in seconds (default: 60.0)
+    ///   - jitterFactor: Randomization factor (0.0-1.0, default: 0.3)
+    /// - Returns: Calculated delay with jitter applied
     static func calculateBackoff(
         attempt: Int,
         baseDelay: TimeInterval = 1.0,
-        maxDelay: TimeInterval = 60.0)
+        maxDelay: TimeInterval = 60.0,
+        jitterFactor: Double = 0.3)
         -> TimeInterval
     {
         let exponentialDelay = baseDelay * pow(2.0, Double(attempt - 1))
-        return min(exponentialDelay, maxDelay)
+        let cappedDelay = min(exponentialDelay, maxDelay)
+
+        // Apply jitter: add random value between 0 and jitterFactor * delay
+        // This spreads reconnection attempts to prevent thundering herd
+        let jitter = cappedDelay * jitterFactor * Double.random(in: 0...1)
+        return cappedDelay + jitter
     }
 }