Merge dev into main

MeshCore/Sources/MeshCore/Events/MeshEvent.swift

@@ -108,7 +108,7 @@ public enum MeshEvent: Sendable {
     /// Indicates that auto-add configuration was received.
     ///
     /// Emitted in response to ``MeshCoreSession/getAutoAddConfig()``.
-    case autoAddConfig(UInt8)
+    case autoAddConfig(AutoAddConfig)
 
     /// Indicates that allowed repeat frequency ranges were received.
     ///
@@ -1053,6 +1053,21 @@ public struct DiscoverResponse: Sendable, Equatable {
     }
 }
 
+/// Auto-add configuration received from the device.
+///
+/// Bundles the bitmask (which node types to auto-add) with the max hops filter.
+public struct AutoAddConfig: Sendable, Equatable {
+    /// Bitmask controlling auto-add behavior (0x01=overwrite, 0x02=contacts, 0x04=repeaters, 0x08=rooms).
+    public let bitmask: UInt8
+    /// Maximum hops for auto-add filtering. 0 = no limit, 1 = direct only, N = up to N-1 hops (max 64).
+    public let maxHops: UInt8
+
+    public init(bitmask: UInt8, maxHops: UInt8 = 0) {
+        self.bitmask = bitmask
+        self.maxHops = maxHops
+    }
+}
+
 /// Represents an allowed frequency range for client repeat mode.
 public struct FrequencyRange: Sendable, Equatable {
     /// The lower bound of the frequency range in kHz.

MeshCore/Sources/MeshCore/Protocol/PacketBuilder.swift

@@ -643,9 +643,9 @@ public enum PacketBuilder: Sendable {
     }
 
     /// Builds a packet to set the auto-add configuration.
-    /// - Parameter config: The bitmask (0x01=overwrite, 0x02=contacts, 0x04=repeaters, 0x08=rooms)
-    public static func setAutoAddConfig(_ config: UInt8) -> Data {
-        Data([CommandCode.setAutoAddConfig.rawValue, config])
+    /// - Parameter config: The auto-add configuration (bitmask + max hops).
+    public static func setAutoAddConfig(_ config: AutoAddConfig) -> Data {
+        Data([CommandCode.setAutoAddConfig.rawValue, config.bitmask, config.maxHops])
     }
 
     /// Builds a getSelfTelemetry command to request current sensor data from the device.

MeshCore/Sources/MeshCore/Protocol/PacketParser.swift

@@ -144,14 +144,14 @@ extension PacketParser {
             return Parsers.TuningParamsResponse.parse(payload)
 
         case .autoAddConfig:
-            // Single byte bitmask
             guard payload.count >= 1 else {
                 return .parseFailure(
                     data: payload,
                     reason: "AutoAddConfig response too short: \(payload.count) < 1"
                 )
             }
-            return .autoAddConfig(payload[0])
+            let maxHops: UInt8 = payload.count >= 2 ? payload[1] : 0
+            return .autoAddConfig(AutoAddConfig(bitmask: payload[0], maxHops: maxHops))
 
         case .allowedRepeatFreq:
             return Parsers.AllowedRepeatFreq.parse(payload)

MeshCore/Sources/MeshCore/Session/MeshCoreSession.swift

@@ -849,6 +849,10 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
     private func performStatusRequest(from publicKey: Data) async throws -> StatusResponse {
         let data = PacketBuilder.binaryRequest(to: publicKey, type: .status)
         let publicKeyPrefix = Data(publicKey.prefix(6))
+        let prefixHex = publicKeyPrefix.map { String(format: "%02x", $0) }.joined()
+        let startTime = ContinuousClock.now
+
+        logger.info("Status request to \(prefixHex): sending")
 
         // Subscribe BEFORE sending to avoid race condition where binaryResponse
         // arrives before we can register the pending request
@@ -861,7 +865,7 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
         return try await withThrowingTaskGroup(of: StatusResponse?.self) { group in
             let (timeoutStream, timeoutContinuation) = AsyncStream<TimeInterval>.makeStream()
 
-            group.addTask {
+            group.addTask { [logger] in
                 var expectedAck: Data?
 
                 for await event in events {
@@ -872,7 +876,8 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                         // Capture the expectedAck from firmware's MSG_SENT response
                         expectedAck = info.expectedAck
                         // Signal dynamic timeout to timeout task
-                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 1.2
+                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 2.0
+                        logger.info("Status request to \(prefixHex): messageSent received, suggestedTimeoutMs=\(info.suggestedTimeoutMs), effective timeout=\(String(format: "%.1f", timeout))s")
                         timeoutContinuation.yield(timeout)
                         timeoutContinuation.finish()
 
@@ -889,10 +894,14 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                         ) else {
                             return nil
                         }
+                        let elapsed = ContinuousClock.now - startTime
+                        logger.info("Status request to \(prefixHex): response received in \(elapsed)")
                         return response
 
                     case .statusResponse(let response):
                         // Handle already-routed response (if routing happens elsewhere)
+                        let elapsed = ContinuousClock.now - startTime
+                        logger.info("Status request to \(prefixHex): routed response received in \(elapsed)")
                         return response
 
                     default:
@@ -903,14 +912,19 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                 return nil
             }
 
-            group.addTask { [clock = self.clock, defaultTimeout = configuration.defaultTimeout] in
+            group.addTask { [logger, clock = self.clock, defaultTimeout = configuration.defaultTimeout] in
                 // Wait for dynamic timeout from event task, or use default
                 var timeout = defaultTimeout
+                var usedFirmwareTimeout = false
                 for await t in timeoutStream {
                     timeout = t
+                    usedFirmwareTimeout = true
                     break
                 }
+                logger.info("Status request to \(prefixHex): timeout task sleeping for \(String(format: "%.1f", timeout))s (\(usedFirmwareTimeout ? "firmware" : "default"))")
                 try await clock.sleep(for: .seconds(timeout))
+                let elapsed = ContinuousClock.now - startTime
+                logger.warning("Status request to \(prefixHex): timed out after \(elapsed)")
                 return nil
             }
 
@@ -1162,10 +1176,10 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
 
     /// Gets the current auto-add configuration from the device.
     ///
-    /// - Returns: The auto-add config bitmask.
+    /// - Returns: The auto-add configuration (bitmask + max hops).
     /// - Throws: ``MeshCoreError/timeout`` if the device doesn't respond.
     ///           ``MeshCoreError/deviceError(code:)`` if the device returns an error.
-    public func getAutoAddConfig() async throws -> UInt8 {
+    public func getAutoAddConfig() async throws -> AutoAddConfig {
         try await sendAndWaitWithError(PacketBuilder.getAutoAddConfig()) { event in
             if case .autoAddConfig(let config) = event { return config }
             return nil
@@ -1174,10 +1188,10 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
 
     /// Sets the auto-add configuration on the device.
     ///
-    /// - Parameter config: The bitmask (0x01=overwrite, 0x02=contacts, 0x04=repeaters, 0x08=rooms).
+    /// - Parameter config: The auto-add configuration (bitmask + max hops).
     /// - Throws: ``MeshCoreError/timeout`` if the device doesn't respond.
     ///           ``MeshCoreError/deviceError(code:)`` if the device returns an error.
-    public func setAutoAddConfig(_ config: UInt8) async throws {
+    public func setAutoAddConfig(_ config: AutoAddConfig) async throws {
         try await sendAndWaitWithError(PacketBuilder.setAutoAddConfig(config)) { event in
             if case .ok = event { return () }
             return nil
@@ -1516,11 +1530,12 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
     /// until `.noMoreMessages` is returned to drain the queue.
     /// Use ``startAutoMessageFetching()`` to automate this process.
     ///
+    /// - Parameter timeout: Optional timeout override in seconds. Uses `configuration.defaultTimeout` when `nil`.
     /// - Returns: A ``MessageResult`` containing either a contact message, channel message,
     ///            or indication that no more messages are waiting.
     /// - Throws: ``MeshCoreError`` if the fetch fails.
-    public func getMessage() async throws -> MessageResult {
-        let timeoutSeconds = configuration.defaultTimeout
+    public func getMessage(timeout: TimeInterval? = nil) async throws -> MessageResult {
+        let timeoutSeconds = timeout ?? configuration.defaultTimeout
 
         let stream = await dispatcher.subscribe { event in
             switch event {
@@ -1800,6 +1815,10 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
         let telemetryPayload = Data([0x00, 0x00, 0x00, 0x00])
         let data = PacketBuilder.binaryRequest(to: publicKey, type: .telemetry, payload: telemetryPayload)
         let publicKeyPrefix = Data(publicKey.prefix(6))
+        let prefixHex = publicKeyPrefix.map { String(format: "%02x", $0) }.joined()
+        let startTime = ContinuousClock.now
+
+        logger.info("Telemetry request to \(prefixHex): sending")
 
         // Subscribe BEFORE sending to avoid race condition where binaryResponse
         // arrives before we can register the pending request
@@ -1812,7 +1831,7 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
         return try await withThrowingTaskGroup(of: TelemetryResponse?.self) { group in
             let (timeoutStream, timeoutContinuation) = AsyncStream<TimeInterval>.makeStream()
 
-            group.addTask {
+            group.addTask { [logger] in
                 var expectedAck: Data?
 
                 for await event in events {
@@ -1823,7 +1842,8 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                         // Capture the expectedAck from firmware's MSG_SENT response
                         expectedAck = info.expectedAck
                         // Signal dynamic timeout to timeout task
-                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 1.2
+                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 2.0
+                        logger.info("Telemetry request to \(prefixHex): messageSent received, suggestedTimeoutMs=\(info.suggestedTimeoutMs), effective timeout=\(String(format: "%.1f", timeout))s")
                         timeoutContinuation.yield(timeout)
                         timeoutContinuation.finish()
 
@@ -1838,10 +1858,14 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                             responseData,
                             publicKeyPrefix: publicKeyPrefix
                         )
+                        let elapsed = ContinuousClock.now - startTime
+                        logger.info("Telemetry request to \(prefixHex): response received in \(elapsed)")
                         return response
 
                     case .telemetryResponse(let response):
                         // Handle already-routed response (if routing happens elsewhere)
+                        let elapsed = ContinuousClock.now - startTime
+                        logger.info("Telemetry request to \(prefixHex): routed response received in \(elapsed)")
                         return response
 
                     default:
@@ -1852,14 +1876,19 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                 return nil
             }
 
-            group.addTask { [clock = self.clock, defaultTimeout = configuration.defaultTimeout] in
+            group.addTask { [logger, clock = self.clock, defaultTimeout = configuration.defaultTimeout] in
                 // Wait for dynamic timeout from event task, or use default
                 var timeout = defaultTimeout
+                var usedFirmwareTimeout = false
                 for await t in timeoutStream {
                     timeout = t
+                    usedFirmwareTimeout = true
                     break
                 }
+                logger.info("Telemetry request to \(prefixHex): timeout task sleeping for \(String(format: "%.1f", timeout))s (\(usedFirmwareTimeout ? "firmware" : "default"))")
                 try await clock.sleep(for: .seconds(timeout))
+                let elapsed = ContinuousClock.now - startTime
+                logger.warning("Telemetry request to \(prefixHex): timed out after \(elapsed)")
                 return nil
             }
 
@@ -1928,7 +1957,7 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                     case .messageSent(let info):
                         expectedAck = info.expectedAck
                         // Signal dynamic timeout to timeout task
-                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 1.2
+                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 2.0
                         timeoutContinuation.yield(timeout)
                         timeoutContinuation.finish()
 
@@ -2004,7 +2033,7 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                     case .messageSent(let info):
                         expectedAck = info.expectedAck
                         // Signal dynamic timeout to timeout task
-                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 1.2
+                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 2.0
                         timeoutContinuation.yield(timeout)
                         timeoutContinuation.finish()
 
@@ -2112,7 +2141,7 @@ public actor MeshCoreSession: MeshCoreSessionProtocol {
                     case .messageSent(let info):
                         expectedAck = info.expectedAck
                         // Signal dynamic timeout to timeout task
-                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 1.2
+                        let timeout = TimeInterval(info.suggestedTimeoutMs) / 1000.0 * 2.0
                         timeoutContinuation.yield(timeout)
                         timeoutContinuation.finish()
 

MeshCore/Tests/MeshCoreTests/Protocol/V112ProtocolTests.swift

@@ -194,23 +194,30 @@ struct V112ProtocolTests {
 
     @Test("setAutoAddConfig packet builder")
     func setAutoAddConfigPacketBuilder() {
-        let packet = PacketBuilder.setAutoAddConfig(0x0F)
+        let packet = PacketBuilder.setAutoAddConfig(AutoAddConfig(bitmask: 0x0F))
 
-        #expect(packet == Data([0x3A, 0x0F]))
+        #expect(packet == Data([0x3A, 0x0F, 0x00]))
     }
 
     @Test("setAutoAddConfig all bits set")
     func setAutoAddConfigAllBitsSet() {
-        let packet = PacketBuilder.setAutoAddConfig(0xFF)
+        let packet = PacketBuilder.setAutoAddConfig(AutoAddConfig(bitmask: 0xFF))
 
-        #expect(packet == Data([0x3A, 0xFF]))
+        #expect(packet == Data([0x3A, 0xFF, 0x00]))
     }
 
     @Test("setAutoAddConfig zero bits")
     func setAutoAddConfigZeroBits() {
-        let packet = PacketBuilder.setAutoAddConfig(0x00)
+        let packet = PacketBuilder.setAutoAddConfig(AutoAddConfig(bitmask: 0x00))
 
-        #expect(packet == Data([0x3A, 0x00]))
+        #expect(packet == Data([0x3A, 0x00, 0x00]))
+    }
+
+    @Test("setAutoAddConfig with maxHops")
+    func setAutoAddConfigWithMaxHops() {
+        let packet = PacketBuilder.setAutoAddConfig(AutoAddConfig(bitmask: 0x0F, maxHops: 3))
+
+        #expect(packet == Data([0x3A, 0x0F, 0x03]))
     }
 
     // MARK: - Auto-Add Config Response Parser Tests
@@ -227,14 +234,29 @@ struct V112ProtocolTests {
         #expect(ResponseCode.autoAddConfig.category == .device)
     }
 
-    @Test("autoAddConfig parses valid payload")
-    func autoAddConfigParsesValidPayload() {
+    @Test("autoAddConfig parses single-byte payload with default maxHops")
+    func autoAddConfigParsesSingleBytePayload() {
         let packet = Data([0x19, 0x0F])
 
         let event = PacketParser.parse(packet)
 
         if case .autoAddConfig(let config) = event {
-            #expect(config == 0x0F)
+            #expect(config.bitmask == 0x0F)
+            #expect(config.maxHops == 0)
+        } else {
+            Issue.record("Expected .autoAddConfig event, got \(event)")
+        }
+    }
+
+    @Test("autoAddConfig parses two-byte payload with maxHops")
+    func autoAddConfigParsesTwoBytePayload() {
+        let packet = Data([0x19, 0x0F, 0x05])
+
+        let event = PacketParser.parse(packet)
+
+        if case .autoAddConfig(let config) = event {
+            #expect(config.bitmask == 0x0F)
+            #expect(config.maxHops == 5)
         } else {
             Issue.record("Expected .autoAddConfig event, got \(event)")
         }
@@ -253,14 +275,15 @@ struct V112ProtocolTests {
         }
     }
 
-    @Test("autoAddConfig ignores extra bytes")
+    @Test("autoAddConfig ignores extra bytes beyond maxHops")
     func autoAddConfigIgnoresExtraBytes() {
-        let packet = Data([0x19, 0x0E, 0xFF, 0xFF])
+        let packet = Data([0x19, 0x0E, 0x03, 0xFF, 0xFF])
 
         let event = PacketParser.parse(packet)
 
         if case .autoAddConfig(let config) = event {
-            #expect(config == 0x0E)
+            #expect(config.bitmask == 0x0E)
+            #expect(config.maxHops == 3)
         } else {
             Issue.record("Expected .autoAddConfig event, got \(event)")
         }

MeshCore/Tests/MeshCoreTests/Session/GetMessageTimeoutTests.swift

@@ -15,4 +15,40 @@ struct GetMessageTimeoutTests {
             _ = try await session.getMessage()
         }
     }
+
+    @Test("getMessage timeout override can be shorter than the session default")
+    func getMessageRespectsShortTimeoutOverride() async {
+        let transport = MockTransport()
+        try? await transport.connect()
+
+        let configuration = SessionConfiguration(defaultTimeout: 0.2, clientIdentifier: "MeshCore-Tests")
+        let session = MeshCoreSession(transport: transport, configuration: configuration)
+        let clock = ContinuousClock()
+        let start = clock.now
+
+        await #expect(throws: MeshCoreError.self) {
+            _ = try await session.getMessage(timeout: 0.02)
+        }
+
+        let elapsed = start.duration(to: clock.now)
+        #expect(elapsed < .milliseconds(100))
+    }
+
+    @Test("getMessage timeout override can extend beyond the session default")
+    func getMessageRespectsLongTimeoutOverride() async {
+        let transport = MockTransport()
+        try? await transport.connect()
+
+        let configuration = SessionConfiguration(defaultTimeout: 0.02, clientIdentifier: "MeshCore-Tests")
+        let session = MeshCoreSession(transport: transport, configuration: configuration)
+        let clock = ContinuousClock()
+        let start = clock.now
+
+        await #expect(throws: MeshCoreError.self) {
+            _ = try await session.getMessage(timeout: 0.12)
+        }
+
+        let elapsed = start.duration(to: clock.now)
+        #expect(elapsed >= .milliseconds(80))
+    }
 }