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

package/android/src/main/java/dev/bota/sdk/reactnative/upload/UploadModels.kt

@@ -0,0 +1,171 @@
+package dev.bota.sdk.reactnative.upload
+
+import java.net.URI
+import java.security.MessageDigest
+import java.time.Instant
+import java.util.Base64
+import org.json.JSONArray
+import org.json.JSONObject
+
+internal class UploadFailure(val code: String) : Exception(code)
+internal fun fail(code: String): Nothing = throw UploadFailure("BOTA_UPLOAD_$code")
+internal fun demand(value: Boolean, code: String = "INVALID_INPUT") { if (!value) fail(code) }
+internal inline fun <T> sanitized(code: String, block: () -> T): T = try { block() }
+  catch (error: UploadFailure) { throw error }
+  catch (_: Exception) { fail(code) }
+internal fun digest(value: ByteArray): String = MessageDigest.getInstance("SHA-256").digest(value)
+  .joinToString("") { "%02x".format(it.toInt() and 255) }
+internal fun hex(value: String): ByteArray {
+  demand(value.length % 2 == 0 && value.matches(Regex("[0-9a-fA-F]*")))
+  return value.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+}
+internal fun encoded(value: ByteArray): String = Base64.getEncoder().encodeToString(value)
+internal fun opaque(value: String, length: Int, hash: String? = null): ByteArray = sanitized("INVALID_DOCUMENT") {
+  val bytes = Base64.getDecoder().decode(value)
+  demand(bytes.size == length && encoded(bytes) == value && (hash == null || digest(bytes) == hash), "INVALID_DOCUMENT")
+  bytes
+}
+internal fun JSONObject.string(key: String): String = (opt(key) as? String)?.also {
+  demand(it.isNotEmpty() && it.length <= 8192)
+} ?: fail("INVALID_INPUT")
+internal fun JSONObject.integer(key: String, minimum: Long = 0, maximum: Long = 9007199254740991L): Long {
+  val raw = opt(key) as? Number ?: fail("INVALID_INPUT")
+  val text = raw.toString()
+  demand(text.matches(Regex("0|[1-9][0-9]*")))
+  val number = text.toLongOrNull() ?: fail("INVALID_INPUT")
+  demand(number in minimum..maximum)
+  return number
+}
+internal fun JSONObject.decimal(key: String, minimum: Long = 0): Long {
+  val value = string(key)
+  demand(value.matches(Regex("0|[1-9][0-9]*")))
+  return (value.toLongOrNull() ?: fail("INVALID_INPUT")).also { demand(it in minimum..9007199254740991L) }
+}
+internal fun uuid(value: String): String = value.also {
+  demand(it.matches(Regex("[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}")))
+}
+internal fun hashString(value: String): String = value.also { demand(it.matches(Regex("[0-9a-f]{64}"))) }
+internal fun JSONObject.optionalObject(key: String): JSONObject? {
+  if (!has(key) || isNull(key)) return null
+  return opt(key) as? JSONObject ?: fail("INVALID_INPUT")
+}
+internal fun timestamp(value: String): Long = sanitized("INVALID_DOCUMENT") { Instant.parse(value).toEpochMilli() }
+
+internal data class UploadScope(
+  val apiOrigin: String, val accountId: String, val projectId: String, val organizationId: String,
+  val environment: String, val endUserId: String, val deviceId: String,
+  val bindingGeneration: Long, val serialNumber: String, val nativeDeviceId: String, val scopeKey: String,
+  val apiBasePath: String = "/v1",
+) {
+  fun identity(includeTransport: Boolean = false): List<Any> = listOf(apiOrigin, accountId, projectId, organizationId, environment, endUserId,
+    deviceId, bindingGeneration, serialNumber, if (includeTransport) nativeDeviceId else "", scopeKey, apiBasePath)
+
+  companion object {
+    fun parse(json: JSONObject): UploadScope {
+      val origin = json.string("apiOrigin")
+      val url = URI(origin)
+      demand(url.scheme == "https" && !url.host.isNullOrEmpty() && url.rawUserInfo == null &&
+        url.rawQuery == null && url.rawFragment == null && (url.rawPath.isNullOrEmpty() || url.rawPath == "/"))
+      fun identifier(key: String) = json.string(key).also { demand(it.matches(Regex("[A-Za-z0-9_-]{1,256}"))) }
+      return UploadScope(origin.trimEnd('/'), identifier("accountId"), identifier("projectId"), json.optString("organizationId", "").also { demand(it.isEmpty() || it.matches(Regex("[A-Za-z0-9_-]{1,256}"))) },
+        identifier("environment"), identifier("endUserId"), identifier("deviceId"), json.integer("bindingGeneration"),
+        json.string("serialNumber"), json.string("nativeDeviceId"), json.string("scopeKey"),
+        json.optString("apiBasePath", "/v1").also { demand(it.matches(Regex("(/[A-Za-z0-9_-]+)+"))) })
+    }
+  }
+}
+
+internal data class UploadRecording(
+  val uuid: String, val generation: Long, val ciphertextLength: Long, val ciphertextSha256: String,
+  val startedAtMs: Long, val durationMs: Long, val plaintextLength: Long, val storageFormat: Long,
+) {
+  fun identity(): List<Any> = listOf(uuid, generation, ciphertextLength.toString(), ciphertextSha256,
+    startedAtMs.toString(), durationMs.toString(), plaintextLength.toString(), storageFormat)
+
+  companion object {
+    fun parse(json: JSONObject): UploadRecording = UploadRecording(uuid(json.string("uuid")),
+      json.integer("generation", 1, 4294967295), json.decimal("ciphertextLength", 1),
+      hashString(json.string("ciphertextSha256")), json.decimal("startedAtMs"), json.decimal("durationMs"),
+      json.decimal("plaintextLength"), json.integer("storageFormat", 3, 3)).also {
+      demand(it.startedAtMs + it.durationMs <= 8640000000000000L)
+    }
+  }
+}
+
+internal data class UploadPointer(val recordingId: String, val sessionId: String? = null, val ownerRevision: Long? = null) {
+  fun fingerprint(): String = digest(JSONArray(listOf(recordingId, sessionId ?: JSONObject.NULL,
+    ownerRevision ?: JSONObject.NULL)).toString().toByteArray(Charsets.UTF_8))
+  fun json(): JSONObject = JSONObject().put("recordingId", recordingId).apply {
+    if (sessionId != null) put("sessionId", sessionId).put("ownerRevision", ownerRevision)
+  }
+  companion object {
+    fun parse(json: JSONObject): UploadPointer {
+      val id = json.string("recordingId")
+      demand(id.matches(Regex("rec_[A-Za-z0-9_-]+")))
+      val hasSession = json.has("sessionId") && !json.isNull("sessionId")
+      val hasRevision = json.has("ownerRevision") && !json.isNull("ownerRevision")
+      demand(hasSession == hasRevision)
+      return UploadPointer(id, if (hasSession) uuid(json.string("sessionId")) else null,
+        if (hasRevision) json.integer("ownerRevision", 1, Int.MAX_VALUE.toLong()) else null)
+    }
+  }
+}
+
+internal data class UploadInput(
+  val operationId: String, val scope: UploadScope, val recording: UploadRecording,
+  val capability: ByteArray, val flags: Long, val journalKey: String, val identitySha256: String,
+  val prior: UploadPointer?, val checkpoint: JSONObject?,
+) {
+  val legacyIdentitySha256: String get() = digest(JSONArray(scope.identity(includeTransport = true) +
+    recording.identity()).toString().toByteArray(Charsets.UTF_8))
+
+  fun validateCheckpoint(pointer: UploadPointer?) {
+    val cp = checkpoint ?: return
+    sanitized("IDENTITY_CONFLICT") {
+      demand(pointer?.sessionId != null && pointer.ownerRevision != null, "IDENTITY_CONFLICT")
+      val session = uuid(cp.string("uploadSessionId"))
+      cp.integer("version", 1, 1)
+      val revision = cp.integer("ownerRevision", 1, Int.MAX_VALUE.toLong())
+      demand(revision <= pointer!!.ownerRevision!! &&
+        ((revision == pointer.ownerRevision) == (session == pointer.sessionId)), "IDENTITY_CONFLICT")
+      demand(cp.decimal("nextCiphertextOffset") <= recording.ciphertextLength, "IDENTITY_CONFLICT")
+      hashString(cp.string("prefixSha256"))
+      cp.integer("revision", 1, 4294967295)
+      val transport = cp.string("transportSessionId")
+      demand(transport.matches(Regex("[1-9][0-9]*")) && transport.toULongOrNull() != null)
+      cp.string("sinkRegistrationId")
+      cp.integer("windowPackets", 1, 65535)
+      cp.integer("dataPayloadBytes", 1, 65535)
+      if (cp.has("highestContiguousSequence") && !cp.isNull("highestContiguousSequence"))
+        cp.integer("highestContiguousSequence", 0, 4294967295)
+      // Legacy identity fields, if supplied during migration, cannot contradict this recording.
+      if (cp.has("recordingUuid")) demand(cp.string("recordingUuid") == recording.uuid, "IDENTITY_CONFLICT")
+      if (cp.has("recordingGeneration")) demand(cp.integer("recordingGeneration") == recording.generation, "IDENTITY_CONFLICT")
+      if (cp.has("ciphertextLength")) demand(cp.decimal("ciphertextLength") == recording.ciphertextLength, "IDENTITY_CONFLICT")
+      if (cp.has("ciphertextSha256")) demand(cp.string("ciphertextSha256") == recording.ciphertextSha256, "IDENTITY_CONFLICT")
+    }
+  }
+
+  companion object {
+    fun parse(text: String): UploadInput = sanitized("INVALID_INPUT") {
+      demand(text.length <= 32768)
+      val json = JSONObject(text)
+      val operation = json.string("operationId").also { demand(it.length <= 256) }
+      val scope = UploadScope.parse(json.getJSONObject("scope"))
+      val recording = UploadRecording.parse(json.getJSONObject("recording"))
+      val capability = json.getJSONObject("capability")
+      val bytes = hex(capability.string("rawValueHex"))
+      demand(bytes.size == 24)
+
+      val keyFields = listOf(scope.scopeKey, scope.deviceId, scope.bindingGeneration, recording.uuid,
+        recording.generation, recording.ciphertextLength.toString(), recording.ciphertextSha256)
+      // Android org.json escapes slashes; the existing JS journal key uses JSON.stringify.
+      val keyJson = JSONArray(keyFields).toString().replace("\\/", "/")
+      val key = digest(keyJson.toByteArray(Charsets.UTF_8))
+      if (json.has("journalKey")) demand(hashString(json.string("journalKey")) == key, "IDENTITY_CONFLICT")
+      val identity = digest(JSONArray(scope.identity() + recording.identity()).toString().toByteArray(Charsets.UTF_8))
+      UploadInput(operation, scope, recording, bytes, capability.integer("flags", 0, 4294967295), key, identity,
+        json.optionalObject("priorJournalEntry")?.let(UploadPointer::parse), json.optionalObject("checkpoint"))
+    }
+  }
+}

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidDevicesTest.kt

@@ -22,6 +22,38 @@ import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class BotaDeviceSDKAndroidDevicesTest {
+    @Test
+    fun transportLossIsForwardedWithoutAStatusSubscription() = runTest {
+        val verified = ConnectedDevice(
+            id = "selected", serialNumber = "EVFXXW67KP", deviceType = DeviceType.BotaPin,
+            firmwareVersion = "1.0.19", isProvisioned = false,
+            connectionState = ConnectionState.Connected, mtu = 247,
+        )
+        val stopped = CompletableDeferred<Unit>()
+        val client = FakeDeviceClient(
+            DiscoveredDevice("selected", rssi = -30), verified,
+            connections = flow {
+                try {
+                    emit(null)
+                    emit(verified)
+                    emit(null)
+                    emit(null)
+                    awaitCancellation()
+                } finally {
+                    stopped.complete(Unit)
+                }
+            },
+        )
+        val devices = BotaDeviceSDKAndroidDevices(client, backgroundScope)
+        var losses = 0
+        devices.startConnectionUpdates { losses += 1 }
+        assertEquals(1, losses)
+        assertEquals(0, client.statusReadCount)
+        devices.stopAll()
+        stopped.await()
+        assertEquals(1, losses)
+    }
+
     @Test
     fun unknownPairingStateUsesTheFrozenUnpairedFallback() {
         assertEquals("unpaired", PairingState.Unknown(0xFFu).toBridgeValue())
@@ -134,7 +166,10 @@ class BotaDeviceSDKAndroidDevicesTest {
         private val connected: ConnectedDevice,
         private val scanFailure: Throwable? = null,
         private val status: DeviceStatus = testDeviceStatus(),
+        private val connections: Flow<ConnectedDevice?> = kotlinx.coroutines.flow.emptyFlow(),
     ) : BotaDeviceSDKAndroidDeviceClient {
+        override fun connectionUpdates(): Flow<ConnectedDevice?> = connections
+        override suspend fun nextClientPresence(deviceId: String): dev.bota.sdk.SDKClientContext? = null
         val scanOptions = mutableListOf<Pair<ULong, Boolean>>()
         val selectedIds = mutableListOf<String>()
         val reconnectSerials = mutableListOf<String>()

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidLogsTest.kt

@@ -4,6 +4,8 @@ import dev.bota.sdk.model.ConnectedDevice
 import dev.bota.sdk.model.ConnectionState
 import dev.bota.sdk.model.DeviceLogLine
 import dev.bota.sdk.model.DeviceType
+import dev.bota.sdk.model.DeviceDiagnosticEvent
+import dev.bota.sdk.model.DeviceDiagnosticsBatch
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.awaitCancellation
@@ -16,6 +18,23 @@ import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class BotaDeviceSDKAndroidLogsTest {
+    @Test
+    fun diagnosticReadDoesNotAcknowledgeAndPreservesEventIDs() = runTest {
+        val client = TestAndroidLogClient()
+        val logs = BotaDeviceSDKAndroidLogs(client, CoroutineScope(coroutineContext))
+        val device = ConnectedDevice(
+            id = "selected", serialNumber = "EVFXXW67KP", deviceType = DeviceType.BotaPin,
+            firmwareVersion = "1.0.11", isProvisioned = true,
+            connectionState = ConnectionState.Connected, mtu = 247,
+        )
+        val batch = logs.readDiagnosticEvents(device)
+        assertTrue(client.acceptedIDs.isEmpty())
+        assertEquals("ffffffffffffffff", batch.events.single().eventId)
+        assertEquals(UInt.MAX_VALUE, batch.events.single().uptimeMs)
+        logs.acknowledgeDiagnosticEvents(device, listOf("ffffffffffffffff"))
+        assertEquals(listOf("ffffffffffffffff"), client.acceptedIDs)
+    }
+
     @OptIn(ExperimentalCoroutinesApi::class)
     @Test
     fun logStreamEmitsSanitizedLinesAndOwnsStop() = runTest {
@@ -44,6 +63,20 @@ class BotaDeviceSDKAndroidLogsTest {
 
     private class TestAndroidLogClient : BotaDeviceSDKAndroidLogClient {
         var stopped = false
+        val acceptedIDs = mutableListOf<String>()
+
+        override suspend fun readDiagnosticEvents(device: ConnectedDevice) = DeviceDiagnosticsBatch(
+            schemaVersion = 1,
+            events = listOf(DeviceDiagnosticEvent(
+                eventId = "ffffffffffffffff", eventType = "crash", reasonCode = "exception",
+                uptimeMs = UInt.MAX_VALUE, signature = "0123456789abcdef", firmwareBuildId = "1.0.11",
+                subsystem = "system", stateBeforeEvent = "idle",
+            )),
+        )
+
+        override suspend fun acknowledgeDiagnosticEvents(device: ConnectedDevice, acceptedEventIds: List<String>) {
+            acceptedIDs.addAll(acceptedEventIds)
+        }
 
         override fun streamLogs(device: ConnectedDevice): Flow<DeviceLogLine> = flow {
             emit(DeviceLogLine("boot pass", isBacklog = true))

package/android/src/test/java/dev/bota/sdk/reactnative/BotaDeviceSDKAndroidRecordingUploadsTest.kt

@@ -10,11 +10,12 @@ import okhttp3.Response
 import okhttp3.ResponseBody.Companion.toResponseBody
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
 import org.junit.Test
 
 class BotaDeviceSDKAndroidRecordingUploadsTest {
     @Test
-    fun plaintextUploadUsesPutCompletesAndDeletesNativeFile() = runTest {
+    fun plaintextUploadRetainsNativeFileUntilDurableHostCompletion() = runTest {
         val fixture = UploadFixture()
         val requests = Collections.synchronizedList(mutableListOf<CapturedRequest>())
         val uploads = BotaDeviceSDKAndroidRecordingUploads(
@@ -32,7 +33,7 @@ class BotaDeviceSDKAndroidRecordingUploadsTest {
             progress::add,
         )
 
-        assertFalse(fixture.recordingFile.exists())
+        assertTrue(fixture.recordingFile.exists())
         assertEquals(
             listOf(
                 CapturedRequest("PUT", "https://s3.example/recording", null),
@@ -87,10 +88,134 @@ class BotaDeviceSDKAndroidRecordingUploadsTest {
             stubbedClient(mutableListOf()),
         )
 
-        uploads.saveQueue("[{\"id\":\"first\"}]")
-        uploads.saveQueue("[{\"id\":\"second\"}]")
+        uploads.saveQueue(fixture.journal("pending"))
+        uploads.saveQueue(fixture.journal("failed"))
+
+        val tasks = org.json.JSONArray(uploads.loadQueue())
+        assertEquals(1, tasks.length())
+        assertEquals("failed", tasks.getJSONObject(0).getString("status"))
+    }
+
+    @Test
+    fun releaseRequiresExactCompletedJournalAndIsIdempotent() = runTest {
+        val fixture = UploadFixture()
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile)
+        uploads.saveQueue(fixture.journal("uploading"))
+        assertTrue(runCatching { uploads.release("task-1", fixture.recordingFile.path) }.isFailure)
+        assertTrue(fixture.recordingFile.exists())
+        uploads.saveQueue(fixture.journal("completed"))
+        assertTrue(runCatching { uploads.release("other-task", fixture.recordingFile.path) }.isFailure)
+        uploads.release("task-1", fixture.recordingFile.path)
+        uploads.release("task-1", fixture.recordingFile.path)
+        assertFalse(fixture.recordingFile.exists())
+    }
+
+    @Test
+    fun loadIsReadOnlyUntilValidatedSaveAndRelease() = runTest {
+        val fixture = UploadFixture()
+        fixture.queueFile.writeText(fixture.journal("completed"))
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile)
+        val loaded = uploads.loadQueue()
+        assertEquals(fixture.journal("completed"), loaded)
+        assertTrue(fixture.recordingFile.exists())
+        uploads.saveQueue(loaded)
+        uploads.release("task-1", fixture.recordingFile.path)
+        assertFalse(fixture.recordingFile.exists())
+        assertFalse(fixture.queueFile.readText().contains("secret"))
+    }
+
+    @Test
+    fun corruptJournalIsNotOverwritten() = runTest {
+        val fixture = UploadFixture()
+        fixture.queueFile.writeText("{broken")
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile)
+        assertEquals("{broken", uploads.loadQueue())
+        assertEquals("{broken", fixture.queueFile.readText())
+    }
 
-        assertEquals("[{\"id\":\"second\"}]", uploads.loadQueue())
+    @Test
+    fun parseableInvalidJournalNeverMutatesOrDeletesFiles() = runTest {
+        for ((old, invalid) in listOf(
+            "\"retryCount\":0" to "\"retryCount\":-1",
+            "\"createdAt\":\"2026-09-24T00:00:00Z\"" to "\"createdAt\":\"invalid\"",
+            "\"status\":\"completed\"" to "\"status\":\"completed\",\"fileSizeBytes\":\"4\"",
+            "\"status\":\"completed\"" to "\"status\":\"completed\",\"recoveryScope\":123",
+        )) {
+            val fixture = UploadFixture()
+            val contents = fixture.journal("completed").replace(old, invalid)
+            fixture.queueFile.writeText(contents)
+            val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile)
+            assertEquals(contents, uploads.loadQueue())
+            assertTrue(runCatching { uploads.saveQueue(contents) }.isFailure)
+            assertEquals(contents, fixture.queueFile.readText())
+            assertTrue(fixture.recordingFile.exists())
+        }
+    }
+
+    @Test
+    fun directorySyncFailurePreventsRelease() = runTest {
+        val fixture = UploadFixture()
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile, syncDirectory = { directory ->
+            if (directory == fixture.queueFile.parentFile) error("directory sync failed")
+        })
+        assertTrue(runCatching { uploads.saveQueue(fixture.journal("completed")) }.isFailure)
+        assertTrue(runCatching { uploads.release("task-1", fixture.recordingFile.path) }.isFailure)
+        assertTrue(fixture.recordingFile.exists())
+    }
+
+    @Test
+    fun cleanupDirectorySyncFailureRetainsJournalAndRetriesMissingFile() = runTest {
+        val fixture = UploadFixture()
+        val failure = java.io.IOException("cleanup directory sync failed")
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile, syncDirectory = { directory ->
+            if (directory == fixture.recordingFile.parentFile) throw failure
+        })
+        uploads.saveQueue(fixture.journal("completed"))
+        val journal = fixture.queueFile.readText()
+
+        repeat(2) {
+            val result = runCatching { uploads.release("task-1", fixture.recordingFile.path) }
+            assertTrue(result.exceptionOrNull() is java.io.IOException)
+            assertEquals(failure.message, result.exceptionOrNull()?.message)
+            assertFalse(fixture.recordingFile.exists())
+            assertEquals(journal, fixture.queueFile.readText())
+        }
+
+        val restarted = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile)
+        restarted.release("task-1", fixture.recordingFile.path)
+        assertFalse(fixture.recordingFile.exists())
+        assertEquals(journal, fixture.queueFile.readText())
+    }
+
+    @Test
+    fun cancelledAttemptCannotStartLate() = runTest {
+        val fixture = UploadFixture()
+        val requests = Collections.synchronizedList(mutableListOf<CapturedRequest>())
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile, stubbedClient(requests))
+        uploads.cancel("cancelled-attempt")
+        assertTrue(runCatching { uploads.upload(fixture.request("cancelled-attempt")) {} }.isFailure)
+        assertTrue(requests.isEmpty())
+        assertTrue(fixture.recordingFile.exists())
+    }
+
+    @Test
+    fun releaseNeverDeletesADirectory() = runTest {
+        val fixture = UploadFixture()
+        val child = File(fixture.recordingFile.parentFile, "must-retain").apply { mkdir() }
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile)
+        uploads.saveQueue(fixture.journal("completed").replace(fixture.recordingFile.path, child.path))
+        assertTrue(runCatching { uploads.release("task-1", child.path) }.isFailure)
+        assertTrue(child.isDirectory)
+    }
+
+    @Test
+    fun completedJournalCannotReleaseForeignFile() = runTest {
+        val fixture = UploadFixture()
+        val foreign = File(fixture.queueFile.parentFile, "${java.util.UUID.randomUUID()}.recording").apply { writeText("keep") }
+        val uploads = BotaDeviceSDKAndroidRecordingUploads(fixture.queueFile)
+        uploads.saveQueue(fixture.journal("completed").replace(fixture.recordingFile.path, foreign.path))
+        assertTrue(runCatching { uploads.release("task-1", foreign.path) }.isFailure)
+        assertTrue(foreign.exists())
     }
 
     private fun stubbedClient(requests: MutableList<CapturedRequest>): OkHttpClient =
@@ -121,11 +246,15 @@ private data class CapturedRequest(
 
 private class UploadFixture {
     private val directory = Files.createTempDirectory("bota-recording-upload").toFile()
-    val recordingFile = File(directory, "recording.bin").apply {
+    val recordingFile = File(File(directory, "recordings").apply { mkdir() }, "${java.util.UUID.randomUUID()}.recording").apply {
         writeBytes(byteArrayOf(1, 2, 3, 4))
     }
     val queueFile = File(directory, "queue.json")
 
+    fun journal(status: String): String = """
+        [{"id":"task-1","recordingId":"rec-1","deviceId":"device-1","localPath":"${recordingFile.path}","status":"$status","retryCount":0,"createdAt":"2026-09-24T00:00:00Z","updatedAt":"2026-09-24T00:00:00Z","uploadUrl":"https://secret","uploadToken":"secret","completeUrl":"https://secret","errorMessage":"secret","relay":{"url":"https://secret","bearerToken":"secret"}}]
+    """.trimIndent()
+
     fun request(
         taskId: String,
         completeUrl: String? = null,