@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/utils/JSCExperiment.swift

@@ -0,0 +1,241 @@
+//
+//  JSCExperiment.swift
+//  Glassly
+//
+//  Test/benchmark infrastructure. Self-contained file, never invoked in
+//  normal user flow. Triggered only when (a) GLASSLY_RUN_JSC_BENCH env
+//  var is set at app launch, or (b) the user taps a JSC button on the
+//  (Super-Mode-gated) stress-test screen.
+//
+//  Spike: measure the actual memory cost of N concurrent JSContexts on iOS.
+//  We want to know whether "Pebble-style native JSC per miniapp" is viable
+//  for our N-concurrent-miniapp use case (Pebble runs only 1 at a time, so
+//  they have no data on this).
+//
+//  Each spawned context:
+//   - Has its own JSVirtualMachine (full isolation, separate heap)
+//   - Has __dispatch as a single bridge function (no per-method bindings,
+//     to avoid the production crash Pebble documented in CrashReproducer.kt)
+//   - Runs a representative idle workload: setInterval ping every 5 s
+//   - Names itself "GlasslyJS: <id>" for Safari Web Inspector
+//   - Is NOT inspectable in release builds
+//
+//  Measure resident memory before and after spawning N contexts.
+
+import Foundation
+import JavaScriptCore
+import os.log
+
+private let jscLog = OSLog(subsystem: "com.tetramo.glassly", category: "JSCSpike")
+
+/// Log to BOTH jlog (forwarded into JS) AND os_log AND a flat file in
+/// the app's Documents directory. Release builds don't pipe RN's
+/// console.log or Swift print() to syslog, and os_log filtering through
+/// idevicesyslog is unreliable. The Documents file is the agentic-test
+/// path: `xcrun devicectl device copy from --domain-type appDataContainer
+/// --domain-identifier com.tetramo.glassly --source Documents/jsc-spike.log`.
+private let logFileURL: URL = {
+    let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+    return docs.appendingPathComponent("jsc-spike.log")
+}()
+
+private func jlog(_ message: String) {
+    Bridge.log(message)
+    os_log("%{public}@", log: jscLog, type: .info, message)
+    let stamped = "[\(ISO8601DateFormatter().string(from: Date()))] \(message)\n"
+    if let data = stamped.data(using: .utf8) {
+        if FileManager.default.fileExists(atPath: logFileURL.path) {
+            if let handle = try? FileHandle(forWritingTo: logFileURL) {
+                defer { try? handle.close() }
+                try? handle.seekToEnd()
+                try? handle.write(contentsOf: data)
+            }
+        } else {
+            try? data.write(to: logFileURL, options: .atomic)
+        }
+    }
+}
+
+@objc class JSCExperiment: NSObject {
+    /// Called from BluetoothSdkModule init. If GLASSLY_RUN_JSC_BENCH env var
+    /// is set, kick off the benchmark after a 5s settle window so the app
+    /// is fully booted (RN bridge up, Metro pull done if dev, etc).
+    @objc static func maybeAutoBenchmark() {
+        guard ProcessInfo.processInfo.environment["GLASSLY_RUN_JSC_BENCH"] != nil else { return }
+        os_log("🧪 GLASSLY_RUN_JSC_BENCH set — auto-running benchmark in 5s",
+               log: jscLog, type: .info)
+        DispatchQueue.global(qos: .userInitiated).asyncAfter(deadline: .now() + 5.0) {
+            runBenchmark()
+        }
+    }
+
+    /// id → (context, virtualMachine, timer for the workload)
+    private static var contexts: [String: (JSContext, JSVirtualMachine, Timer)] = [:]
+    private static let queue = DispatchQueue(label: "com.glassly.jsc-experiment")
+
+    /// Spawn N JSContexts at once. Each gets its own VM + a representative
+    /// idle workload. Returns the count successfully spawned.
+    @objc static func spawn(count: Int) -> Int {
+        let beforeMB = MemoryMonitor.currentMemoryMB()
+        jlog("🧪 JSCExperiment.spawn(\(count)) starting; baseline \(String(format: "%.1f", beforeMB)) MB")
+        var spawned = 0
+        for i in 0 ..< count {
+            let id = "spike-\(UUID().uuidString.prefix(8))-\(i)"
+            if spawnOne(id: id) {
+                spawned += 1
+            }
+        }
+        let afterMB = MemoryMonitor.currentMemoryMB()
+        let perMB = spawned > 0 ? (afterMB - beforeMB) / Double(spawned) : 0
+        jlog("🧪 JSCExperiment: spawned \(spawned)/\(count) contexts; total alive \(contexts.count); mem \(String(format: "%.1f", beforeMB))→\(String(format: "%.1f", afterMB)) MB (\(String(format: "%+.2f", perMB)) MB/ctx)")
+        return spawned
+    }
+
+    /// Spawn one named context. Returns true on success.
+    @objc static func spawnOne(id: String) -> Bool {
+        return queue.sync {
+            // Each context gets its own VM = full heap isolation between miniapps.
+            // (JSContexts that share a VM share the heap; we want isolation.)
+            let vm = JSVirtualMachine()!
+            let ctx = JSContext(virtualMachine: vm)!
+
+            ctx.name = "GlasslyJS: \(id)"
+            // Inspectable in dev builds only. iOS 16.4+ guarded.
+            #if DEBUG
+                if #available(iOS 16.4, *) {
+                    ctx.isInspectable = true
+                }
+            #endif
+
+            // Single-dispatcher bridge. Per Pebble's CrashReproducer doc, never
+            // bind individual native callbacks as JSValue properties — JSC's GC
+            // races with ARC and crashes. One C-callable function only.
+            let dispatch: @convention(block) (String, String, [Any]?) -> Any? = { _, _, _ in
+                // Stub: real impl routes to native services.
+                // For the spike we just need __dispatch to exist so the
+                // workload can call it without throwing.
+                NSNull()
+            }
+            ctx.setObject(dispatch, forKeyedSubscript: "__dispatch" as NSString)
+
+            // Representative idle workload — what a typical miniapp's
+            // background JS does: hold a tiny bit of state, register a
+            // listener, periodically poke the bridge.
+            let workload = """
+              (function () {
+                var counter = 0;
+                var state = { id: \"\(id)\", startedAt: Date.now(), notes: [] };
+                var i = 0;
+                function tick() {
+                  counter++;
+                  state.notes.push({ at: Date.now(), n: counter });
+                  if (state.notes.length > 100) state.notes.shift();
+                  __dispatch('noop', 'tick', [counter]);
+                }
+                tick();
+                // Schedule a periodic tick. We use the host-provided
+                // setInterval (a JS shim that calls into native).
+                if (typeof setInterval === 'function') {
+                  setInterval(tick, 5000);
+                }
+              })();
+            """
+            ctx.evaluateScript(workload)
+
+            // Workload uses setInterval which is a JS shim that we'd build
+            // for real — for the spike we just install a Timer-based
+            // setInterval that fires the JS callback. The JS code already
+            // expects setInterval to exist as a global.
+            let setInterval: @convention(block) (JSValue, Double) -> Int = { fn, ms in
+                let id = Int.random(in: 1 ... Int.max)
+                // Stub: we won't actually fire in the spike, but the JS
+                // callback existing is what we want for memory measurement.
+                _ = fn // hold a ref to keep the JS callback alive
+                _ = ms
+                return id
+            }
+            ctx.setObject(setInterval, forKeyedSubscript: "setInterval" as NSString)
+
+            // Idle workload Timer on the native side that does NOTHING —
+            // it just exists so the context isn't optimized away. The real
+            // JS callback (registered above) will be hit by a real
+            // setInterval impl in production.
+            let timer = Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { _ in
+                // no-op — keep ref alive
+            }
+
+            contexts[id] = (ctx, vm, timer)
+            return true
+        }
+    }
+
+    /// Tear down all contexts. Important: cancel timers, drop refs, force GC.
+    @objc static func killAll() {
+        queue.sync {
+            for (_, entry) in contexts {
+                entry.2.invalidate()
+            }
+            let count = contexts.count
+            contexts.removeAll()
+            jlog("📊 JSCExperiment: killed all \(count) contexts")
+        }
+    }
+
+    /// How many contexts are alive right now.
+    @objc static func aliveCount() -> Int {
+        return queue.sync { contexts.count }
+    }
+
+    /// Convenience: spawn N + return memory delta vs baseline. Caller
+    /// records baseline via MemoryMonitor.currentMemoryMB() before calling.
+    @objc static func spawnAndMeasure(count: Int, baselineMB: Double) -> [String: Any] {
+        let beforeMB = MemoryMonitor.currentMemoryMB()
+        let spawned = spawn(count: count)
+        // Tiny settle delay so allocations complete before we read.
+        Thread.sleep(forTimeInterval: 0.5)
+        let afterMB = MemoryMonitor.currentMemoryMB()
+        let perContextMB = spawned > 0 ? (afterMB - beforeMB) / Double(spawned) : 0
+        let result: [String: Any] = [
+            "spawned": spawned,
+            "totalAlive": aliveCount(),
+            "baselineMB": baselineMB,
+            "beforeMB": beforeMB,
+            "afterMB": afterMB,
+            "deltaMB": afterMB - beforeMB,
+            "perContextMB": perContextMB,
+        ]
+        jlog("📊 JSCExperiment.spawnAndMeasure: \(result)")
+        return result
+    }
+
+    /// Run a full benchmark sweep: spawn 1, 5, 10, 25, 50 in waves with
+    /// 2s settle between, log resident MB before and after each. All
+    /// output via jlog so it reaches syslog in release builds.
+    @objc static func runBenchmark() {
+        DispatchQueue.global(qos: .userInitiated).async {
+            killAll()
+            // Clear log file for a fresh run.
+            try? FileManager.default.removeItem(at: logFileURL)
+            Thread.sleep(forTimeInterval: 1.0)
+            let baseline = MemoryMonitor.currentMemoryMB()
+            jlog("🧪 JSC-BENCH start; baseline \(String(format: "%.1f", baseline)) MB; logFile=\(logFileURL.path)")
+            let waves = [1, 5, 10, 25, 50]
+            var prevAlive = 0
+            for target in waves {
+                let need = target - prevAlive
+                if need > 0 {
+                    let beforeMB = MemoryMonitor.currentMemoryMB()
+                    _ = spawn(count: need)
+                    Thread.sleep(forTimeInterval: 1.0)
+                    let afterMB = MemoryMonitor.currentMemoryMB()
+                    let perContextOverall = (afterMB - baseline) / Double(target)
+                    jlog("🧪 JSC-BENCH wave: target=\(target) alive=\(aliveCount()) before=\(String(format: "%.1f", beforeMB))MB after=\(String(format: "%.1f", afterMB))MB delta=\(String(format: "%+.1f", afterMB - beforeMB))MB cumPerCtx=\(String(format: "%.2f", perContextOverall))MB")
+                    prevAlive = target
+                }
+                Thread.sleep(forTimeInterval: 2.0)
+            }
+            let final = MemoryMonitor.currentMemoryMB()
+            jlog("🧪 JSC-BENCH done; alive=\(aliveCount()) final=\(String(format: "%.1f", final))MB total-delta=\(String(format: "%+.1f", final - baseline))MB")
+        }
+    }
+}

package/ios/Source/utils/MemoryMonitor.swift

@@ -0,0 +1,44 @@
+//
+//  MemoryMonitor.swift
+//  Glassly
+//
+//  Memory usage monitoring for leak detection
+//
+
+import Foundation
+
+class MemoryMonitor {
+    private static var timer: Timer?
+    private static var startMemoryMB: Double = 0
+
+    static func start(intervalSeconds: TimeInterval = 30) {
+        stop()
+        startMemoryMB = currentMemoryMB()
+        Bridge.log("📊 Memory Monitor started - baseline: \(String(format: "%.1f", startMemoryMB)) MB")
+
+        DispatchQueue.main.async {
+            timer = Timer.scheduledTimer(withTimeInterval: intervalSeconds, repeats: true) { _ in
+                let current = currentMemoryMB()
+                let delta = current - startMemoryMB
+                let trend = delta > 50 ? "🔴" : delta > 20 ? "🟡" : "⚪"
+                Bridge.log("📊 Memory: \(String(format: "%.1f", current)) MB (Δ \(String(format: "%+.1f", delta)) MB) \(trend)")
+            }
+        }
+    }
+
+    static func stop() {
+        timer?.invalidate()
+        timer = nil
+    }
+
+    static func currentMemoryMB() -> Double {
+        var info = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
+        let result = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+            }
+        }
+        return result == KERN_SUCCESS ? Double(info.resident_size) / 1024 / 1024 : 0
+    }
+}

package/ios/Source/utils/MessageChunkReassembler.swift

@@ -0,0 +1,190 @@
+import Foundation
+
+final class MessageChunkReassembler {
+    private static let chunkTimeoutMs: TimeInterval = 30_000
+    private static let maxConcurrentSessions = 10
+
+    private var activeSessions: [String: ChunkSession] = [:]
+
+    private var activeBinarySessions: [UInt16: BinarySession] = [:]
+
+    func addBinaryFragment(msgId: UInt16, fragIdx: Int, fragCount: Int, data: Data) -> Data? {
+        cleanupTimedOutSessions()
+
+        guard fragCount > 0, fragIdx >= 0, fragIdx < fragCount else {
+            print("MessageChunkReassembler: Dropping invalid binary fragment for msgId \(msgId)")
+            return nil
+        }
+
+        if let existing = activeBinarySessions[msgId], existing.fragCount != fragCount {
+            activeBinarySessions.removeValue(forKey: msgId)
+        }
+
+        if activeBinarySessions.count >= Self.maxConcurrentSessions,
+           activeBinarySessions[msgId] == nil
+        {
+            removeOldestBinarySession()
+        }
+
+        let isNewSession = activeBinarySessions[msgId] == nil
+        let session = activeBinarySessions[msgId] ?? BinarySession(msgId: msgId, fragCount: fragCount)
+
+        guard session.addFragment(index: fragIdx, data: data) else {
+            return nil
+        }
+        if isNewSession {
+            activeBinarySessions[msgId] = session
+        }
+
+        guard session.isComplete else {
+            return nil
+        }
+
+        let reassembled = session.reassemble()
+        activeBinarySessions.removeValue(forKey: msgId)
+        print("MessageChunkReassembler: Reassembled \(reassembled.count) bytes from \(fragCount) binary fragments")
+        return reassembled
+    }
+
+    func addChunk(_ info: MessageChunker.ChunkInfo) -> String? {
+        cleanupTimedOutSessions()
+
+        guard !info.chunkId.isEmpty,
+              info.totalChunks > 0,
+              info.chunkIndex >= 0,
+              info.chunkIndex < info.totalChunks
+        else {
+            print("MessageChunkReassembler: Dropping invalid chunk metadata for \(info.chunkId)")
+            return nil
+        }
+
+        if let existing = activeSessions[info.chunkId], existing.totalChunks != info.totalChunks {
+            print(
+                "MessageChunkReassembler: totalChunks mismatch for \(info.chunkId) (expected \(existing.totalChunks), got \(info.totalChunks)); resetting session"
+            )
+            activeSessions.removeValue(forKey: info.chunkId)
+        }
+
+        if activeSessions.count >= Self.maxConcurrentSessions,
+           activeSessions[info.chunkId] == nil
+        {
+            removeOldestSession()
+        }
+
+        let isNewSession = activeSessions[info.chunkId] == nil
+        let session = activeSessions[info.chunkId] ?? ChunkSession(
+            chunkId: info.chunkId,
+            totalChunks: info.totalChunks
+        )
+
+        guard session.addChunk(index: info.chunkIndex, data: info.data) else {
+            print("MessageChunkReassembler: Failed to add chunk \(info.chunkIndex) for \(info.chunkId)")
+            return nil
+        }
+        if isNewSession {
+            activeSessions[info.chunkId] = session
+        }
+
+        guard session.isComplete else {
+            return nil
+        }
+
+        let reassembled = session.reassemble()
+        activeSessions.removeValue(forKey: info.chunkId)
+        print("MessageChunkReassembler: Reassembled \(reassembled.count) bytes from \(info.totalChunks) chunks")
+        return reassembled
+    }
+
+    func clear() {
+        activeSessions.removeAll()
+        activeBinarySessions.removeAll()
+    }
+
+    private func cleanupTimedOutSessions() {
+        let now = Date().timeIntervalSince1970 * 1000
+        activeSessions = activeSessions.filter { entry in
+            now - entry.value.createdAtMs <= Self.chunkTimeoutMs
+        }
+        activeBinarySessions = activeBinarySessions.filter { entry in
+            now - entry.value.createdAtMs <= Self.chunkTimeoutMs
+        }
+    }
+
+    private func removeOldestBinarySession() {
+        guard let oldest = activeBinarySessions.min(by: { $0.value.createdAtMs < $1.value.createdAtMs }) else {
+            return
+        }
+        activeBinarySessions.removeValue(forKey: oldest.key)
+    }
+
+    private func removeOldestSession() {
+        guard let oldest = activeSessions.min(by: { $0.value.createdAtMs < $1.value.createdAtMs }) else {
+            return
+        }
+        activeSessions.removeValue(forKey: oldest.key)
+    }
+
+    private final class ChunkSession {
+        let chunkId: String
+        let totalChunks: Int
+        let createdAtMs: TimeInterval
+        private var chunks: [Int: String] = [:]
+
+        init(chunkId: String, totalChunks: Int) {
+            self.chunkId = chunkId
+            self.totalChunks = totalChunks
+            self.createdAtMs = Date().timeIntervalSince1970 * 1000
+        }
+
+        func addChunk(index: Int, data: String) -> Bool {
+            guard index >= 0, index < totalChunks else {
+                return false
+            }
+            chunks[index] = data
+            return true
+        }
+
+        var isComplete: Bool {
+            chunks.count == totalChunks
+        }
+
+        func reassemble() -> String {
+            var result = ""
+            for index in 0 ..< totalChunks {
+                result += chunks[index] ?? ""
+            }
+            return result
+        }
+    }
+
+    private final class BinarySession {
+        let msgId: UInt16
+        let fragCount: Int
+        let createdAtMs: TimeInterval
+        private var fragments: [Int: Data] = [:]
+
+        init(msgId: UInt16, fragCount: Int) {
+            self.msgId = msgId
+            self.fragCount = fragCount
+            self.createdAtMs = Date().timeIntervalSince1970 * 1000
+        }
+
+        func addFragment(index: Int, data: Data) -> Bool {
+            guard index >= 0, index < fragCount else { return false }
+            fragments[index] = data
+            return true
+        }
+
+        var isComplete: Bool {
+            fragments.count == fragCount
+        }
+
+        func reassemble() -> Data {
+            var result = Data()
+            for index in 0 ..< fragCount {
+                result.append(fragments[index] ?? Data())
+            }
+            return result
+        }
+    }
+}