@mentra/bluetooth-sdk 0.1.21-beta.5 → 3.1.0-dev.7

package/android/src/main/java/com/mentra/bluetoothsdk/MentraLocalNetworkModule.kt

@@ -5,7 +5,8 @@ import android.net.Network
 import android.net.NetworkCapabilities
 import android.net.NetworkRequest
 import android.net.wifi.WifiNetworkSpecifier
-import android.os.Build
+import android.os.Handler
+import android.os.Looper
 import android.util.Base64
 import android.util.Log
 import expo.modules.kotlin.Promise
@@ -14,6 +15,7 @@ import expo.modules.kotlin.modules.ModuleDefinition
 import java.io.File
 import java.io.FileOutputStream
 import java.net.HttpURLConnection
+import java.net.Inet4Address
 import java.net.URL
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.Executors
@@ -22,14 +24,18 @@ import java.util.concurrent.Executors
 class MentraLocalNetworkModule : Module() {
     private companion object {
         const val TAG = "MentraLocalNetwork"
+        const val NETWORK_READINESS_TIMEOUT_MS = 5_000L
     }
 
     private val lock = Any()
     private val executor = Executors.newCachedThreadPool()
+    private val handler = Handler(Looper.getMainLooper())
     private val activeConnections = ConcurrentHashMap<String, HttpURLConnection>()
+    private val networkReadiness = ScopedNetworkReadiness<Network>()
     private var localNetwork: Network? = null
     private var networkCallback: ConnectivityManager.NetworkCallback? = null
     private var pendingConnectPromise: Promise? = null
+    private var pendingReadinessTimeout: Runnable? = null
 
     override fun definition() = ModuleDefinition {
         Name("MentraLocalNetwork")
@@ -74,7 +80,9 @@ class MentraLocalNetworkModule : Module() {
         AsyncFunction("cancel") { requestId: String -> cancel(requestId) }
         AsyncFunction("disconnect") { disconnect() }
 
-        OnDestroy { disconnect() }
+        OnDestroy {
+            disconnect()
+        }
     }
 
     private fun connectivityManager(): ConnectivityManager =
@@ -83,11 +91,6 @@ class MentraLocalNetworkModule : Module() {
         }
 
     private fun connect(ssid: String, password: String, promise: Promise) {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-            promise.reject("ERR_UNSUPPORTED_ANDROID", "Scoped local WiFi requires Android 10 or newer", null)
-            return
-        }
-
         disconnect()
         val manager = connectivityManager()
         val specifier =
@@ -105,21 +108,55 @@ class MentraLocalNetworkModule : Module() {
         val callback =
             object : ConnectivityManager.NetworkCallback() {
                 override fun onAvailable(network: Network) {
-                    val connectPromise: Promise?
                     synchronized(lock) {
                         if (networkCallback !== this) {
                             Log.d(TAG, "Ignoring onAvailable from a stale network request")
                             return
                         }
+                        networkReadiness.onAvailable(network)
+                    }
+                    Log.i(
+                        TAG,
+                        "Captured glasses WiFi network=$network; waiting for foreground capability " +
+                            "processBoundNetwork=${manager.boundNetworkForProcess}",
+                    )
+                    scheduleReadinessTimeout(this, ssid)
+                }
+
+                override fun onCapabilitiesChanged(network: Network, capabilities: NetworkCapabilities) {
+                    val connectPromise: Promise?
+                    synchronized(lock) {
+                        if (networkCallback !== this || localNetwork != null || pendingConnectPromise == null) return
+                        if (!networkReadiness.isReady(
+                                network,
+                                capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_FOREGROUND),
+                            )
+                        ) {
+                            return
+                        }
                         localNetwork = network
                         connectPromise = pendingConnectPromise
                         pendingConnectPromise = null
+                        cancelReadinessTimeoutLocked()
                     }
                     Log.i(
                         TAG,
-                        "Captured glasses WiFi network=$network processBoundNetwork=${manager.boundNetworkForProcess}",
+                        "Glasses WiFi network=$network is foreground and ready " +
+                            "processBoundNetwork=${manager.boundNetworkForProcess}",
+                    )
+                    val localAddress =
+                        manager.getLinkProperties(network)
+                            ?.linkAddresses
+                            ?.firstOrNull { it.address is Inet4Address }
+                            ?.address
+                            ?.hostAddress
+                    connectPromise?.resolve(
+                        buildMap<String, Any> {
+                            put("connected", true)
+                            put("ssid", ssid)
+                            if (!localAddress.isNullOrBlank()) put("localAddress", localAddress)
+                        },
                     )
-                    connectPromise?.resolve(mapOf("connected" to true, "ssid" to ssid))
                 }
 
                 override fun onUnavailable() {
@@ -135,13 +172,17 @@ class MentraLocalNetworkModule : Module() {
 
                 override fun onLost(network: Network) {
                     synchronized(lock) {
-                        if (networkCallback !== this || localNetwork != network) {
+                        if (networkCallback !== this ||
+                            (localNetwork != network && !networkReadiness.contains(network))
+                        ) {
                             Log.d(TAG, "Ignoring onLost from a stale network request")
                             return
                         }
                         localNetwork = null
+                        networkReadiness.clear()
                     }
                     cancelAll()
+                    rejectPendingConnect("ERR_LOCAL_WIFI_LOST", "Lost connection to $ssid")
                     clearNetworkCallback(this)
                     sendEvent("networkLost", mapOf("ssid" to ssid))
                 }
@@ -289,6 +330,39 @@ class MentraLocalNetworkModule : Module() {
         activeConnections.keys.toList().forEach(::cancel)
     }
 
+    private fun scheduleReadinessTimeout(
+        callback: ConnectivityManager.NetworkCallback,
+        ssid: String,
+    ) {
+        val timeout =
+            Runnable {
+                val connectPromise = synchronized(lock) {
+                    if (networkCallback !== callback || pendingConnectPromise == null) return@Runnable
+                    pendingReadinessTimeout = null
+                    val promise = pendingConnectPromise
+                    pendingConnectPromise = null
+                    promise
+                }
+                connectPromise?.reject(
+                    "ERR_LOCAL_WIFI_NOT_READY",
+                    "Connected to $ssid but the network did not become ready",
+                    null,
+                )
+                clearNetworkCallback(callback)
+            }
+        synchronized(lock) {
+            if (networkCallback !== callback || pendingConnectPromise == null) return
+            cancelReadinessTimeoutLocked()
+            pendingReadinessTimeout = timeout
+        }
+        handler.postDelayed(timeout, NETWORK_READINESS_TIMEOUT_MS)
+    }
+
+    private fun cancelReadinessTimeoutLocked() {
+        pendingReadinessTimeout?.let(handler::removeCallbacks)
+        pendingReadinessTimeout = null
+    }
+
     private fun disconnect() {
         cancelAll()
         val manager = appContext.reactContext?.getSystemService(ConnectivityManager::class.java)
@@ -297,6 +371,8 @@ class MentraLocalNetworkModule : Module() {
             callback = networkCallback
             networkCallback = null
             localNetwork = null
+            networkReadiness.clear()
+            cancelReadinessTimeoutLocked()
         }
         if (callback != null && manager != null) {
             try {
@@ -311,7 +387,12 @@ class MentraLocalNetworkModule : Module() {
     private fun clearNetworkCallback(callback: ConnectivityManager.NetworkCallback) {
         val manager = appContext.reactContext?.getSystemService(ConnectivityManager::class.java)
         synchronized(lock) {
-            if (networkCallback == callback) networkCallback = null
+            if (networkCallback == callback) {
+                networkCallback = null
+                localNetwork = null
+                networkReadiness.clear()
+                cancelReadinessTimeoutLocked()
+            }
         }
         if (manager != null) {
             try {

package/android/src/main/java/com/mentra/bluetoothsdk/OtaManifest.kt

@@ -7,21 +7,19 @@ import org.json.JSONArray
 import org.json.JSONObject
 
 internal object OtaManifestDefaults {
-    private const val SDK_OTA_RELEASE_BASE_URL =
-        "https://github.com/Mentra-Community/MentraOS/releases/download/bluetooth-sdk-ota"
     // ASG builds before 39 ignore ota_start.ota_version_url, so SDK checks must
     // use the same legacy production manifest those glasses will install from.
     const val LEGACY_PROD_OTA_VERSION_URL = "https://ota.mentraglass.com/prod_live_version.json"
 
     fun defaultOtaVersionUrl(): String {
-        val sdkVersion = BuildConfig.SDK_VERSION.trim()
-        if (sdkVersion.isBlank() || sdkVersion == "unspecified") {
+        val manifestUrl = GeneratedReleaseMetadata.OTA_MANIFEST_URL.trim()
+        if (manifestUrl.isBlank()) {
             throw BluetoothSdkException(
-                "missing_sdk_version",
-                "Cannot determine Bluetooth SDK version for the default OTA manifest URL.",
+                "ota_manifest_unconfigured",
+                "This source-built Bluetooth SDK has no embedded OTA manifest. Configure one with the debug API.",
             )
         }
-        return "$SDK_OTA_RELEASE_BASE_URL/bluetooth-sdk-$sdkVersion-version.json"
+        return manifestUrl
     }
 }
 

package/android/src/main/java/com/mentra/bluetoothsdk/ScopedNetworkReadiness.kt

@@ -0,0 +1,17 @@
+package com.mentra.bluetoothsdk
+
+internal class ScopedNetworkReadiness<T> {
+    private var candidate: T? = null
+
+    fun onAvailable(network: T) {
+        candidate = network
+    }
+
+    fun isReady(network: T, isForeground: Boolean): Boolean = candidate == network && isForeground
+
+    fun contains(network: T): Boolean = candidate == network
+
+    fun clear() {
+        candidate = null
+    }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/audio/AudioModels.kt

@@ -94,6 +94,21 @@ data class MicLc3Event(
     }
 }
 
+internal data class MicHealth(
+    val sequenceGapEvents: Long,
+    val decodeFailures: Long,
+    val lastLc3ReceivedAt: Long?,
+    val lastPcmProducedAt: Long?,
+) {
+    fun toMap(): Map<String, Any> =
+        buildMap {
+            put("sequenceGapEvents", sequenceGapEvents)
+            put("decodeFailures", decodeFailures)
+            lastLc3ReceivedAt?.let { put("lastLc3ReceivedAt", it) }
+            lastPcmProducedAt?.let { put("lastPcmProducedAt", it) }
+        }
+}
+
 data class LocalTranscriptionEvent(
     val text: String,
     val isFinal: Boolean,

package/android/src/main/java/com/mentra/bluetoothsdk/events/BluetoothEvents.kt

@@ -39,6 +39,29 @@ data class SpeakingStatusEvent(
     val values: Map<String, Any>,
 )
 
+data class MicHealthEvent(
+    val reason: String,
+    val sequenceGapEvents: Long,
+    val decodeFailures: Long,
+    val lastLc3ReceivedAt: Long?,
+    val lastPcmProducedAt: Long?,
+    val timestamp: Long,
+    val values: Map<String, Any>,
+) {
+    companion object {
+        internal fun fromMap(values: Map<String, Any>): MicHealthEvent =
+            MicHealthEvent(
+                reason = stringValue(values, "reason") ?: "",
+                sequenceGapEvents = longValue(values, "sequenceGapEvents") ?: 0,
+                decodeFailures = longValue(values, "decodeFailures") ?: 0,
+                lastLc3ReceivedAt = longValue(values, "lastLc3ReceivedAt"),
+                lastPcmProducedAt = longValue(values, "lastPcmProducedAt"),
+                timestamp = longValue(values, "timestamp") ?: System.currentTimeMillis(),
+                values = values,
+            )
+    }
+}
+
 data class OtaStartAckEvent(
     val timestamp: Long?,
     val values: Map<String, Any>,
@@ -144,6 +167,7 @@ interface MentraBluetoothSdkListener {
     fun onVersionInfo(event: VersionInfoResult) {}
     fun onMicPcm(event: MicPcmEvent) {}
     fun onMicLc3(event: MicLc3Event) {}
+    fun onMicHealth(event: MicHealthEvent) {}
     fun onLocalTranscription(event: LocalTranscriptionEvent) {}
     fun onDefaultDeviceChanged(device: Device?) {}
     fun onLog(message: String) {}

package/android/src/main/java/com/mentra/bluetoothsdk/net/LocalIpv4.kt

@@ -0,0 +1,57 @@
+package com.mentra.bluetoothsdk.net
+
+import java.net.Inet4Address
+import java.net.NetworkInterface
+
+/**
+ * Best-effort local IPv4 discovery for phone-hosted servers the glasses reach over WiFi
+ * (photo upload receiver, hotspot-served OTA). Prefers WiFi-ish interfaces carrying RFC1918
+ * addresses — under a glasses-hotspot session wlan0 holds the 192.168.43.x client address.
+ */
+object LocalIpv4 {
+  fun bestLocalIpv4Address(): String? {
+    val wifiPrivateCandidates = mutableListOf<Inet4Address>()
+    val wifiCandidates = mutableListOf<Inet4Address>()
+    val privateCandidates = mutableListOf<Inet4Address>()
+    val otherCandidates = mutableListOf<Inet4Address>()
+    val interfaces = NetworkInterface.getNetworkInterfaces()?.toList().orEmpty()
+    for (networkInterface in interfaces) {
+      if (!networkInterface.isUp || networkInterface.isLoopback) {
+        continue
+      }
+      val addresses = networkInterface.inetAddresses.toList()
+        .filterIsInstance<Inet4Address>()
+        .filter { address ->
+          !address.isLoopbackAddress &&
+            !address.isLinkLocalAddress
+        }
+      if (isWifiInterface(networkInterface.name)) {
+        wifiPrivateCandidates += addresses.filter { isPrivateIpv4(it.hostAddress.orEmpty()) }
+        wifiCandidates += addresses
+      } else {
+        privateCandidates += addresses.filter { isPrivateIpv4(it.hostAddress.orEmpty()) }
+        otherCandidates += addresses
+      }
+    }
+
+    return (
+      wifiPrivateCandidates.firstOrNull() ?:
+        wifiCandidates.firstOrNull() ?:
+        privateCandidates.firstOrNull() ?:
+        otherCandidates.firstOrNull()
+      )?.hostAddress
+  }
+
+  private fun isWifiInterface(name: String): Boolean {
+    return name.startsWith("wlan") ||
+      name.startsWith("p2p") ||
+      name.startsWith("ap") ||
+      name.startsWith("swlan")
+  }
+
+  private fun isPrivateIpv4(host: String): Boolean {
+    return host.startsWith("192.168.") ||
+      host.startsWith("10.") ||
+      host.matches(Regex("^172\\.(1[6-9]|2[0-9]|3[0-1])\\..*"))
+  }
+}

package/android/src/main/java/com/mentra/bluetoothsdk/otaserver/LocalOtaServer.kt

@@ -0,0 +1,304 @@
+package com.mentra.bluetoothsdk.otaserver
+
+import com.mentra.bluetoothsdk.debug.BleTraceLogger
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import java.io.BufferedInputStream
+import java.io.ByteArrayOutputStream
+import java.io.EOFException
+import java.io.File
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.InetSocketAddress
+import java.net.ServerSocket
+import java.net.Socket
+import java.net.SocketException
+import java.nio.charset.StandardCharsets
+import java.util.Locale
+import java.util.concurrent.Semaphore
+import org.json.JSONObject
+
+/**
+ * Static HTTP server for hotspot-served glasses OTA (OS-1676).
+ *
+ * Serves the rewritten OTA manifest at /version.json and pre-downloaded artifacts at
+ * /artifacts/<sha256> to the glasses over the glasses-hotspot link. Same hand-rolled
+ * socket structure as [LocalPhotoUploadServer] —
+ * no third-party HTTP dependency in the SDK.
+ */
+class LocalOtaServer(
+    private val onLog: (String) -> Unit,
+) : AutoCloseable {
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private var serverSocket: ServerSocket? = null
+    private var serverJob: Job? = null
+    private val clientSlots = Semaphore(MAX_ACTIVE_CLIENTS)
+
+    @Volatile
+    private var manifestJson: String = "{}"
+
+    @Volatile
+    private var artifacts: Map<String, File> = emptyMap()
+
+    @Volatile
+    var running: Boolean = false
+        private set
+
+    val activePort: Int?
+        get() = serverSocket
+            ?.takeIf { running && !it.isClosed }
+            ?.localPort
+
+    /** Swap the served manifest and artifact set. Safe while the server is running. */
+    fun configure(manifestJson: String, artifacts: Map<String, File>) {
+        this.manifestJson = manifestJson
+        this.artifacts = artifacts
+    }
+
+    fun start(host: String, port: Int): Int {
+        val activeSocket = serverSocket
+        if (running && activeSocket != null && !activeSocket.isClosed && activeSocket.localPort == port) {
+            onLog("Already listening on $host:${activeSocket.localPort}")
+            return activeSocket.localPort
+        }
+        stop()
+        val socket = ServerSocket()
+        try {
+            socket.reuseAddress = true
+            socket.bind(InetSocketAddress(host, port))
+            serverSocket = socket
+            running = true
+            serverJob = scope.launch {
+                acceptLoop(socket)
+            }
+        } catch (error: Throwable) {
+            try {
+                socket.close()
+            } catch (_: Throwable) {
+            }
+            throw error
+        }
+        onLog("OTA server listening on $host:${socket.localPort}")
+        return socket.localPort
+    }
+
+    fun stop() {
+        running = false
+        serverJob?.cancel()
+        serverJob = null
+        try {
+            serverSocket?.close()
+        } catch (_: Throwable) {
+        }
+        serverSocket = null
+    }
+
+    override fun close() {
+        stop()
+        scope.cancel()
+    }
+
+    private fun acceptLoop(socket: ServerSocket) {
+        while (scope.isActive && !socket.isClosed) {
+            try {
+                val client = socket.accept()
+                if (!clientSlots.tryAcquire()) {
+                    rejectClient(client)
+                    continue
+                }
+                scope.launch {
+                    try {
+                        handleClient(client)
+                    } finally {
+                        clientSlots.release()
+                    }
+                }
+            } catch (error: SocketException) {
+                if (running) onLog("Accept failed: ${error.message}")
+            } catch (error: Throwable) {
+                if (running) onLog("Accept failed: ${error.message ?: error::class.java.simpleName}")
+            }
+        }
+    }
+
+    private fun handleClient(socket: Socket) {
+        socket.use { client ->
+            val requestStartMs = System.currentTimeMillis()
+            client.soTimeout = SOCKET_TIMEOUT_MS
+            val input = BufferedInputStream(client.getInputStream())
+            val output = client.getOutputStream()
+            var request: HttpRequest? = null
+            var status = 0
+            var responseBytes = 0L
+
+            try {
+                val headerText = readHeaders(input).toString(StandardCharsets.ISO_8859_1)
+                request = HttpRequest.parse(headerText)
+                onLog("${request.method} ${request.path} from ${client.inetAddress.hostAddress}")
+
+                if (request.method != "GET") {
+                    status = 405
+                    writeJson(output, status, """{"ok":false,"error":"method_not_allowed"}""")
+                    return
+                }
+
+                when {
+                    request.path == "/version.json" -> {
+                        val body = manifestJson.toByteArray(StandardCharsets.UTF_8)
+                        status = 200
+                        responseBytes = body.size.toLong()
+                        writeBody(output, status, "application/json", body)
+                    }
+                    request.path.startsWith("/artifacts/") -> {
+                        val key = request.path.removePrefix("/artifacts/")
+                        val file = artifacts[key]
+                        if (file == null || !file.isFile) {
+                            status = 404
+                            writeJson(output, status, """{"ok":false,"error":"artifact_not_found"}""")
+                        } else {
+                            status = 200
+                            responseBytes = file.length()
+                            writeFile(output, file)
+                        }
+                    }
+                    else -> {
+                        status = 404
+                        writeJson(output, status, """{"ok":false,"error":"not_found"}""")
+                    }
+                }
+            } catch (error: Throwable) {
+                onLog("request failed: ${error.message ?: error::class.java.simpleName}")
+                if (status == 0) {
+                    status = 500
+                    try {
+                        writeJson(output, status, """{"ok":false,"error":"server_error"}""")
+                    } catch (_: Throwable) {
+                    }
+                }
+            } finally {
+                trace(client, request, status, responseBytes, requestStartMs)
+            }
+        }
+    }
+
+    private fun writeFile(output: OutputStream, file: File) {
+        val fileLength = file.length()
+        output.write("HTTP/1.1 200 OK\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Type: application/octet-stream\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Length: $fileLength\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Connection: close\r\n\r\n".toByteArray(StandardCharsets.US_ASCII))
+        file.inputStream().use { fileInput ->
+            val buffer = ByteArray(STREAM_CHUNK_BYTES)
+            var remaining = fileLength
+            while (remaining > 0) {
+                val read = fileInput.read(buffer, 0, minOf(buffer.size.toLong(), remaining).toInt())
+                if (read <= 0) throw EOFException("artifact truncated while streaming")
+                output.write(buffer, 0, read)
+                remaining -= read
+            }
+        }
+        output.flush()
+    }
+
+    private fun rejectClient(socket: Socket) {
+        socket.use { client ->
+            try {
+                writeJson(client.getOutputStream(), 503, """{"ok":false,"error":"too_many_connections"}""")
+            } catch (_: Throwable) {
+            }
+        }
+    }
+
+    private fun readHeaders(input: InputStream): ByteArray {
+        val out = ByteArrayOutputStream()
+        val delimiter = byteArrayOf(13, 10, 13, 10)
+        var matched = 0
+        while (true) {
+            val byte = input.read()
+            if (byte == -1) throw EOFException("Socket closed before HTTP headers completed")
+            out.write(byte)
+            matched = if (byte.toByte() == delimiter[matched]) {
+                matched + 1
+            } else if (byte.toByte() == delimiter[0]) {
+                1
+            } else {
+                0
+            }
+            if (matched == delimiter.size) return out.toByteArray()
+            if (out.size() > MAX_HEADER_BYTES) throw IllegalArgumentException("HTTP headers too large")
+        }
+    }
+
+    private fun writeJson(output: OutputStream, status: Int, body: String) {
+        writeBody(output, status, "application/json", body.toByteArray(StandardCharsets.UTF_8))
+    }
+
+    private fun writeBody(
+        output: OutputStream,
+        status: Int,
+        contentType: String,
+        body: ByteArray,
+    ) {
+        val reason = when (status) {
+            200 -> "OK"
+            404 -> "Not Found"
+            405 -> "Method Not Allowed"
+            503 -> "Service Unavailable"
+            else -> "Internal Server Error"
+        }
+        output.write("HTTP/1.1 $status $reason\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Type: $contentType\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Content-Length: ${body.size}\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write("Connection: close\r\n\r\n".toByteArray(StandardCharsets.US_ASCII))
+        output.write(body)
+        output.flush()
+    }
+
+    private fun trace(
+        client: Socket,
+        request: HttpRequest?,
+        status: Int,
+        responseBytes: Long,
+        startMs: Long,
+    ) {
+        val payload = JSONObject()
+        try {
+            payload.put("type", "ota_server_request")
+            payload.put("remoteHost", client.inetAddress?.hostAddress ?: "")
+            payload.put("method", request?.method ?: "")
+            payload.put("path", request?.path ?: "")
+            payload.put("statusCode", status)
+            payload.put("responseBytes", responseBytes)
+            payload.put("durationMs", System.currentTimeMillis() - startMs)
+            BleTraceLogger.logJson("phone_to_wifi", "wifi_http_output", payload, null)
+        } catch (_: Throwable) {
+        }
+    }
+
+    private data class HttpRequest(
+        val method: String,
+        val path: String,
+    ) {
+        companion object {
+            fun parse(headerText: String): HttpRequest {
+                val lines = headerText.split("\r\n").filter { it.isNotBlank() }
+                val requestParts = lines.firstOrNull()?.split(" ").orEmpty()
+                val method = requestParts.getOrNull(0)?.uppercase(Locale.US).orEmpty()
+                val path = requestParts.getOrNull(1)?.substringBefore("?").orEmpty()
+                return HttpRequest(method, path)
+            }
+        }
+    }
+
+    companion object {
+        private const val MAX_HEADER_BYTES = 64 * 1024
+        private const val MAX_ACTIVE_CLIENTS = 2
+        private const val SOCKET_TIMEOUT_MS = 20_000
+        private const val STREAM_CHUNK_BYTES = 64 * 1024
+    }
+}