@bota.dev/react-native-app-sdk 2.0.0-beta.1 → 2.0.0-beta.10

package/ios/BotaDeviceSDK.mm

@@ -569,6 +569,46 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                 }];
 }
 
+- (void)listPendingRecordings:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      listPendingRecordingsWithID:device.id_()
+                     serialNumber:device.serialNumber()
+                       deviceType:device.deviceType()
+                  firmwareVersion:device.firmwareVersion()
+                 hardwareRevision:device.hardwareRevision()
+                    isProvisioned:device.isProvisioned()
+                  connectionState:device.connectionState()
+                              mtu:device.mtu()
+                       completion:^(NSArray<NSDictionary *> *_Nullable values, NSError *_Nullable error) {
+                         if (error != nil) { BotaRejectEncryptedUploadV2Error(reject); return; }
+                         resolve(values);
+                       }];
+}
+
+- (void)cancelEncryptedRecordingV2:(NSString *)operationId
+                          resolve:(RCTPromiseResolveBlock)resolve
+                           reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      cancelEncryptedRecordingV2WithOperationID:operationId
+                                     completion:^(NSError *_Nullable error) {
+                                       if (error != nil) { BotaRejectEncryptedUploadV2Error(reject); return; }
+                                       resolve(nil);
+                                     }];
+}
+
+- (void)releaseEncryptedUploadV2Material:(NSString *)materialRegistrationId
+                               resolve:(RCTPromiseResolveBlock)resolve
+                                reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      releaseEncryptedUploadV2MaterialWithRegistrationID:materialRegistrationId
+                                              completion:^{ resolve(nil); }];
+}
+
 - (void)syncRecording:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
              recording:(JS::NativeBotaDeviceSDK::NativeDeviceRecording &)recording
                 sinkId:(NSString *)sinkId
@@ -626,6 +666,10 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                            generation:recording.generation()
                      ciphertextLength:recording.ciphertextLength()
                      ciphertextSHA256:recording.ciphertextSha256()
+                          startedAtMs:recording.startedAtMs()
+                           durationMs:recording.durationMs()
+                      plaintextLength:recording.plaintextLength()
+                        storageFormat:recording.storageFormat().has_value() ? @(recording.storageFormat().value()) : nil
                           operationID:operationId
                      onProfileRequest:^(NSDictionary *request) {
                        [weakSelf emitOnEncryptedUploadV2ProfileRequested:request];
@@ -807,6 +851,7 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
       uploadRecordingFileWithTaskID:request.taskId()
                           recordingID:request.recordingId()
                              localPath:request.localPath()
+                         fileSizeBytes:request.fileSizeBytes().has_value() ? @(request.fileSizeBytes().value()) : nil
                              uploadURL:request.uploadUrl()
                            uploadToken:request.uploadToken()
                             completeURL:request.completeUrl()
@@ -826,6 +871,23 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                               }];
 }
 
+- (void)releaseRecordingFile:(NSString *)taskId
+                   localPath:(NSString *)localPath
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      releaseRecordingFileWithTaskID:taskId
+                           localPath:localPath
+                          completion:^(NSError *error) {
+                            if (error != nil) {
+                              BotaRejectAppleError(error, reject);
+                              return;
+                            }
+                            resolve(nil);
+                          }];
+}
+
 - (void)cancelRecordingUpload:(NSString *)taskId
                       resolve:(RCTPromiseResolveBlock)resolve
                        reject:(__unused RCTPromiseRejectBlock)reject
@@ -966,6 +1028,46 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
                 }];
 }
 
+- (void)readDiagnosticEvents:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
+                     resolve:(RCTPromiseResolveBlock)resolve
+                      reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      readDiagnosticEventsWithID:device.id_()
+                    serialNumber:device.serialNumber()
+                      deviceType:device.deviceType()
+                 firmwareVersion:device.firmwareVersion()
+                hardwareRevision:device.hardwareRevision()
+                   isProvisioned:device.isProvisioned()
+                 connectionState:device.connectionState()
+                             mtu:device.mtu()
+                      completion:^(NSDictionary *_Nullable batch, NSError *_Nullable error) {
+                        if (error != nil) { BotaRejectAppleError(error, reject); return; }
+                        resolve(batch);
+                      }];
+}
+
+- (void)acknowledgeDiagnosticEvents:(JS::NativeBotaDeviceSDK::NativeConnectedDevice &)device
+                  acceptedEventIds:(NSArray *)acceptedEventIds
+                           resolve:(RCTPromiseResolveBlock)resolve
+                            reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared]
+      acknowledgeDiagnosticEventsWithID:device.id_()
+                           serialNumber:device.serialNumber()
+                             deviceType:device.deviceType()
+                        firmwareVersion:device.firmwareVersion()
+                       hardwareRevision:device.hardwareRevision()
+                          isProvisioned:device.isProvisioned()
+                        connectionState:device.connectionState()
+                                    mtu:device.mtu()
+                       acceptedEventIds:acceptedEventIds
+                             completion:^(NSError *_Nullable error) {
+                               if (error != nil) { BotaRejectAppleError(error, reject); return; }
+                               resolve(nil);
+                             }];
+}
+
 - (void)stopDeviceLogs:(RCTPromiseResolveBlock)resolve
                  reject:(__unused RCTPromiseRejectBlock)reject
 {
@@ -974,6 +1076,18 @@ RCT_EXPORT_MODULE(BotaDeviceSDK)
   }];
 }
 
+- (void)nextClientPresence:(NSString *)deviceId resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [[BotaDeviceSDKAppleBridge shared] nextClientPresenceWithDeviceID:deviceId
+      completion:^(NSDictionary *_Nullable report, NSError *_Nullable error) {
+        if (error != nil) {
+          reject(@"client_presence_failed", error.localizedDescription, error);
+        } else {
+          resolve(report);
+        }
+      }];
+}
+
 - (void)readStatus:(RCTPromiseResolveBlock)resolve
              reject:(RCTPromiseRejectBlock)reject
 {

package/ios/BotaDeviceSDKAppleBridge.swift

@@ -801,6 +801,48 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    @objc(listPendingRecordingsWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:completion:)
+    public func listPendingRecordings(
+        id: String, serialNumber: String, deviceType: String, firmwareVersion: String,
+        hardwareRevision: String?, isProvisioned: Bool, connectionState: String, mtu: Double,
+        completion: @escaping @Sendable ([[String: Any]]?, NSError?) -> Void
+    ) {
+        Task {
+            do {
+                let values = try await recordings.listPendingRecordings(Self.connectedDevice(
+                    id: id, serialNumber: serialNumber, deviceType: deviceType,
+                    firmwareVersion: firmwareVersion, hardwareRevision: hardwareRevision,
+                    isProvisioned: isProvisioned, connectionState: connectionState, mtu: mtu
+                ))
+                completion(values.map { value in
+                    switch value {
+                    case let .legacy(recording):
+                        ["profile": "legacy", "legacy": Self.recording(recording)]
+                    case let .encryptedV2(recording):
+                        ["profile": "encrypted_upload_v2", "encrypted": BotaDeviceSDKAppleRecordings.encryptedUploadV2Recording(recording)]
+                    }
+                }, nil)
+            } catch { completion(nil, error as NSError) }
+        }
+    }
+
+    @objc(cancelEncryptedRecordingV2WithOperationID:completion:)
+    public func cancelEncryptedRecordingV2(
+        operationID: String, completion: @escaping @Sendable (NSError?) -> Void
+    ) {
+        Task {
+            do { try await recordings.cancelEncryptedRecordingV2(operationID); completion(nil) }
+            catch { completion(error as NSError) }
+        }
+    }
+
+    @objc(releaseEncryptedUploadV2MaterialWithRegistrationID:completion:)
+    public func releaseEncryptedUploadV2Material(
+        registrationID: String, completion: @escaping @Sendable () -> Void
+    ) {
+        Task { await BotaDeviceSDKEncryptedUploadV2Materials.release(registrationID); completion() }
+    }
+
     @objc(syncRecordingWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:startedAtMilliseconds:durationMilliseconds:fileSize:codec:isEncrypted:sinkID:onProgress:completion:)
     public func syncRecording(
         id: String,
@@ -855,6 +897,7 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                 var value: [String: Any] = [
                     "localPath": result.localPath,
                     "e2eEncrypted": result.isE2EEncrypted,
+                    "fileSizeBytes": result.fileSizeBytes,
                 ]
                 if let contentSHA256Hex = result.contentSHA256Hex {
                     value["contentSha256"] = contentSHA256Hex
@@ -866,7 +909,7 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
-    @objc(syncEncryptedRecordingV2WithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:generation:ciphertextLength:ciphertextSHA256:operationID:onProfileRequest:onProgress:completion:)
+    @objc(syncEncryptedRecordingV2WithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:recordingUUID:generation:ciphertextLength:ciphertextSHA256:startedAtMs:durationMs:plaintextLength:storageFormat:operationID:onProfileRequest:onProgress:completion:)
     public func syncEncryptedRecordingV2(
         id: String,
         serialNumber: String,
@@ -880,6 +923,10 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         generation: Double,
         ciphertextLength: String,
         ciphertextSHA256: String,
+        startedAtMs: String?,
+        durationMs: String?,
+        plaintextLength: String?,
+        storageFormat: NSNumber?,
         operationID: String,
         onProfileRequest: @escaping @Sendable ([String: Any]) -> Void,
         onProgress: @escaping @Sendable ([String: Any]) -> Void,
@@ -895,6 +942,9 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                     throw BotaDeviceSDKAppleBridgeInputError.invalidUnsignedInteger
                 }
                 let digest = try Self.sha256Data(ciphertextSHA256)
+                guard let format = UInt8(exactly: try Self.unsignedInteger(storageFormat?.doubleValue ?? 3)) else {
+                    throw BotaDeviceSDKAppleBridgeInputError.invalidUnsignedInteger
+                }
                 try await recordings.syncEncryptedRecordingV2(
                     Self.connectedDevice(
                         id: id,
@@ -910,7 +960,11 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                         uuid: recordingUUID,
                         generation: generationValue,
                         ciphertextLength: length,
-                        ciphertextSHA256: digest
+                        ciphertextSHA256: digest,
+                        startedAtMs: try Self.catalogDecimal(startedAtMs),
+                        durationMs: try Self.catalogDecimal(durationMs),
+                        plaintextLength: try Self.catalogDecimal(plaintextLength),
+                        storageFormat: format
                     ),
                     operationID: operationID,
                     onProfileRequest: onProfileRequest,
@@ -923,6 +977,14 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    private static func catalogDecimal(_ text: String?) throws -> UInt64 {
+        guard let text else { return 0 }
+        guard let value = UInt64(text), String(value) == text else {
+            throw BotaDeviceSDKAppleBridgeInputError.invalidUnsignedInteger
+        }
+        return value
+    }
+
     @objc(resolveEncryptedUploadV2ProfileWithRequestID:profile:uploadSessionID:ownerRevision:securityPolicy:materialRegistrationID:completion:)
     public func resolveEncryptedUploadV2Profile(
         requestID: String,
@@ -1126,11 +1188,12 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
-    @objc(uploadRecordingFileWithTaskID:recordingID:localPath:uploadURL:uploadToken:completeURL:contentType:contentSHA256:relayURL:relayBearerToken:onProgress:completion:)
+    @objc(uploadRecordingFileWithTaskID:recordingID:localPath:fileSizeBytes:uploadURL:uploadToken:completeURL:contentType:contentSHA256:relayURL:relayBearerToken:onProgress:completion:)
     public func uploadRecordingFile(
         taskID: String,
         recordingID: String,
         localPath: String,
+        fileSizeBytes: NSNumber?,
         uploadURL: String,
         uploadToken: String?,
         completeURL: String?,
@@ -1143,6 +1206,11 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
     ) {
         Task {
             do {
+                let expectedSize = try fileSizeBytes.map { value -> Int64 in
+                    let integer = try Self.unsignedInteger(value.doubleValue)
+                    guard integer <= UInt64(Int64.max) else { throw CocoaError(.fileReadCorruptFile) }
+                    return Int64(integer)
+                }
                 try await recordingUploads.upload(.init(
                     taskID: taskID,
                     recordingID: recordingID,
@@ -1153,7 +1221,8 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
                     contentType: contentType,
                     contentSHA256: contentSHA256,
                     relayURL: relayURL,
-                    relayBearerToken: relayBearerToken
+                    relayBearerToken: relayBearerToken,
+                    fileSizeBytes: expectedSize
                 )) { progress in
                     onProgress([
                         "taskId": progress.taskID,
@@ -1168,6 +1237,22 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    @objc(releaseRecordingFileWithTaskID:localPath:completion:)
+    public func releaseRecordingFile(
+        taskID: String,
+        localPath: String,
+        completion: @escaping @Sendable (NSError?) -> Void
+    ) {
+        Task {
+            do {
+                try await recordingUploads.release(taskID: taskID, localPath: localPath)
+                completion(nil)
+            } catch {
+                completion(error as NSError)
+            }
+        }
+    }
+
     @objc(cancelRecordingUploadWithTaskID:completion:)
     public func cancelRecordingUpload(
         taskID: String,
@@ -1359,6 +1444,43 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    @objc(readDiagnosticEventsWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:completion:)
+    public func readDiagnosticEvents(
+        id: String, serialNumber: String, deviceType: String, firmwareVersion: String,
+        hardwareRevision: String?, isProvisioned: Bool, connectionState: String, mtu: Double,
+        completion: @escaping @Sendable ([String: Any]?, NSError?) -> Void
+    ) {
+        Task {
+            do {
+                let device = try Self.connectedDevice(
+                    id: id, serialNumber: serialNumber, deviceType: deviceType,
+                    firmwareVersion: firmwareVersion, hardwareRevision: hardwareRevision,
+                    isProvisioned: isProvisioned, connectionState: connectionState, mtu: mtu
+                )
+                completion(diagnosticBatchPayload(try await logs.readDiagnosticEvents(device)), nil)
+            } catch { completion(nil, error as NSError) }
+        }
+    }
+
+    @objc(acknowledgeDiagnosticEventsWithID:serialNumber:deviceType:firmwareVersion:hardwareRevision:isProvisioned:connectionState:mtu:acceptedEventIds:completion:)
+    public func acknowledgeDiagnosticEvents(
+        id: String, serialNumber: String, deviceType: String, firmwareVersion: String,
+        hardwareRevision: String?, isProvisioned: Bool, connectionState: String, mtu: Double,
+        acceptedEventIds: [String], completion: @escaping @Sendable (NSError?) -> Void
+    ) {
+        Task {
+            do {
+                let device = try Self.connectedDevice(
+                    id: id, serialNumber: serialNumber, deviceType: deviceType,
+                    firmwareVersion: firmwareVersion, hardwareRevision: hardwareRevision,
+                    isProvisioned: isProvisioned, connectionState: connectionState, mtu: mtu
+                )
+                try await logs.acknowledgeDiagnosticEvents(device, acceptedEventIds: acceptedEventIds)
+                completion(nil)
+            } catch { completion(error as NSError) }
+        }
+    }
+
     @objc(stopDeviceLogsWithCompletion:)
     public func stopDeviceLogs(completion: @escaping @Sendable () -> Void) {
         Task {
@@ -1367,6 +1489,21 @@ public final class BotaDeviceSDKAppleBridge: NSObject, @unchecked Sendable {
         }
     }
 
+    @objc(nextClientPresenceWithDeviceID:completion:)
+    public func nextClientPresence(deviceID: String, completion: @escaping @Sendable (NSDictionary?, NSError?) -> Void) {
+        Task {
+            do {
+                guard let report = try await devices.nextClientPresence(deviceID: deviceID) else {
+                    completion(nil, nil)
+                    return
+                }
+                completion(["schemaVersion": report.schemaVersion, "sessionId": report.sessionID,
+                            "sequence": report.sequence, "platform": report.platform,
+                            "sdkPackage": report.sdkPackage, "sdkVersion": report.sdkVersion], nil)
+            } catch { completion(nil, error as NSError) }
+        }
+    }
+
     @objc(readStatusWithCompletion:)
     public func readStatus(
         completion: @escaping @Sendable ([String: Any]?, NSError?) -> Void

package/ios/BotaDeviceSDKAppleDevices.swift

@@ -14,14 +14,17 @@ protocol BotaDeviceSDKAppleDeviceClient: Sendable {
     ) async throws -> ConnectedDevice
     func disconnect() async throws
     func readStatus() async throws -> DeviceStatus
+    func nextClientPresence(deviceID: String) async throws -> SDKClientContext?
     func statusUpdates() async throws -> AsyncThrowingStream<DeviceStatus, Error>
 }
 
 struct BotaDeviceSDKSharedAppleDeviceClient: BotaDeviceSDKAppleDeviceClient {
     private let devices: DeviceManager
+    private let presence: ClientPresence
 
     init(client: BotaDeviceClient = .shared) {
         devices = client.devices
+        presence = client.clientPresence
     }
 
     func startScan(
@@ -57,6 +60,10 @@ struct BotaDeviceSDKSharedAppleDeviceClient: BotaDeviceSDKAppleDeviceClient {
         try await devices.readStatus()
     }
 
+    func nextClientPresence(deviceID: String) async throws -> SDKClientContext? {
+        try await presence.nextReport(deviceID: deviceID)
+    }
+
     func statusUpdates() async throws -> AsyncThrowingStream<DeviceStatus, Error> {
         try await devices.statusUpdates()
     }
@@ -142,6 +149,10 @@ actor BotaDeviceSDKAppleDevices {
         try await client.readStatus()
     }
 
+    func nextClientPresence(deviceID: String) async throws -> SDKClientContext? {
+        try await client.nextClientPresence(deviceID: deviceID)
+    }
+
     func startStatusUpdates(
         onStatus: @escaping @Sendable (DeviceStatus) -> Void,
         onError: @escaping @Sendable (Error) -> Void = { _ in }

package/ios/BotaDeviceSDKAppleDiagnostics.swift

@@ -0,0 +1,40 @@
+import BotaAppSDK
+import Foundation
+
+func diagnosticBatchPayload(_ batch: DeviceDiagnosticsBatch) -> [String: Any] {
+    ["schema_version": batch.schemaVersion, "events": batch.events.map(diagnosticEventPayload)]
+}
+
+private func diagnosticEventPayload(_ event: DeviceDiagnosticEvent) -> [String: Any] {
+    var payload: [String: Any] = [
+        "event_id": event.eventId, "event_type": event.eventType,
+        "reason_code": event.reasonCode, "uptime_ms": event.uptimeMs,
+        "signature": event.signature, "firmware_build_id": event.firmwareBuildId,
+        "subsystem": event.subsystem, "state_before_event": event.stateBeforeEvent,
+    ]
+    if let report = event.report {
+        var execution: [String: Any] = ["pc_trace": report.execution.pcTrace]
+        execution["task"] = report.execution.task
+        execution["reti"] = report.execution.reti
+        execution["rets"] = report.execution.rets
+        var value: [String: Any] = [
+            "fault": [
+                "cpu_id": report.fault.cpuId, "cpu_emu": report.fault.cpuEmu,
+                "core_emu": report.fault.coreEmu, "hsb_emu": report.fault.hsbEmu,
+                "audio_emu": report.fault.audioEmu, "wireless_emu": report.fault.wirelessEmu,
+            ],
+            "execution": execution,
+        ]
+        if let runtime = report.runtime {
+            var fields: [String: Any] = [:]
+            fields["heap_free_bytes"] = runtime.heapFreeBytes
+            fields["task_stack_remaining_bytes"] = runtime.taskStackRemainingBytes
+            value["runtime"] = fields
+        }
+        if let breadcrumbs = report.breadcrumbs {
+            value["breadcrumbs"] = breadcrumbs.map { ["delta_ms": $0.deltaMs, "code": $0.code, "arg0": $0.arg0] as [String: Any] }
+        }
+        payload["report"] = value
+    }
+    return payload
+}

package/ios/BotaDeviceSDKAppleLogs.swift

@@ -2,6 +2,8 @@ import BotaAppSDK
 import Foundation
 
 protocol BotaDeviceSDKAppleLogClient: Sendable {
+    func readDiagnosticEvents(_ device: ConnectedDevice) async throws -> DeviceDiagnosticsBatch
+    func acknowledgeDiagnosticEvents(_ device: ConnectedDevice, acceptedEventIds: [String]) async throws
     func streamLogs(
         _ device: ConnectedDevice
     ) async throws -> AsyncThrowingStream<DeviceLogLine, Error>
@@ -24,6 +26,14 @@ struct BotaDeviceSDKSharedAppleLogClient: BotaDeviceSDKAppleLogClient {
     func stop() async throws {
         try await logs.stop()
     }
+
+    func readDiagnosticEvents(_ device: ConnectedDevice) async throws -> DeviceDiagnosticsBatch {
+        try await logs.readDiagnosticEvents(device)
+    }
+
+    func acknowledgeDiagnosticEvents(_ device: ConnectedDevice, acceptedEventIds: [String]) async throws {
+        try await logs.acknowledgeDiagnosticEvents(device, acceptedEventIds: acceptedEventIds)
+    }
 }
 
 actor BotaDeviceSDKAppleLogs {
@@ -39,6 +49,14 @@ actor BotaDeviceSDKAppleLogs {
         self.client = client
     }
 
+    func readDiagnosticEvents(_ device: ConnectedDevice) async throws -> DeviceDiagnosticsBatch {
+        try await client.readDiagnosticEvents(device)
+    }
+
+    func acknowledgeDiagnosticEvents(_ device: ConnectedDevice, acceptedEventIds: [String]) async throws {
+        try await client.acknowledgeDiagnosticEvents(device, acceptedEventIds: acceptedEventIds)
+    }
+
     func start(
         _ device: ConnectedDevice,
         onLine: @escaping @Sendable (DeviceLogLine) -> Void,