@mentra/bluetooth-sdk 0.1.0

package/ios/Source/utils/JSCExperiment.swift

@@ -0,0 +1,241 @@
+//
+//  JSCExperiment.swift
+//  MentraOS
+//
+//  Test/benchmark infrastructure. Self-contained file, never invoked in
+//  normal user flow. Triggered only when (a) MENTRA_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 "MentraJS: <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.mentra.mentra", 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.mentra.mentra --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 public class JSCExperiment: NSObject {
+    /// Called from BluetoothSdkModule init. If MENTRA_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 public static func maybeAutoBenchmark() {
+        guard ProcessInfo.processInfo.environment["MENTRA_RUN_JSC_BENCH"] != nil else { return }
+        os_log("🧪 MENTRA_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.mentra.jsc-experiment")
+
+    /// Spawn N JSContexts at once. Each gets its own VM + a representative
+    /// idle workload. Returns the count successfully spawned.
+    @objc public 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 public 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 = "MentraJS: \(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? = { iface, method, args 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.
+                return 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 public 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 public 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 public 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 public 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
+//  MentraOS
+//
+//  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/MessageChunker.swift

@@ -0,0 +1,164 @@
+import Foundation
+
+/**
+ * Handles chunking of large messages that exceed BLE transmission limits.
+ * Messages are split at the JSON layer to work within MCU protocol constraints.
+ *
+ * Uses compact keys to minimize overhead per chunk:
+ *   t  = "ck" (chunk type identifier)
+ *   id = chunk session ID
+ *   c  = chunk index (0-based)
+ *   n  = total number of chunks
+ *   d  = chunk data payload
+ *
+ * Each chunk after C-wrapping + K900 framing must fit within the BES2700's
+ * 253-byte BLE write limit. With compact keys, 80 bytes of raw data produces
+ * a final packed size of ~245 bytes worst-case (with heavy JSON escaping).
+ */
+class MessageChunker {
+    // Threshold: if C-wrapped message exceeds this, chunking is triggered.
+    // BES2700 limit is 253 bytes; anything over ~200 bytes packed needs chunking.
+    private static let MESSAGE_SIZE_THRESHOLD = 200
+
+    /// Maximum raw bytes per chunk. After double JSON escaping + compact envelope
+    /// + C-wrapper + K900 framing, 80 bytes stays under the 253-byte BLE limit.
+    private static let CHUNK_DATA_SIZE = 80
+
+    /**
+     * Check if a message needs to be chunked
+     * @param message The complete message string (already C-wrapped)
+     * @return true if message exceeds threshold and needs chunking
+     */
+    static func needsChunking(_ message: String?) -> Bool {
+        guard let message = message else {
+            return false
+        }
+
+        let messageBytes = message.data(using: .utf8)?.count ?? 0
+        let needsChunking = messageBytes > MESSAGE_SIZE_THRESHOLD
+
+        if needsChunking {
+            print("MessageChunker: Message size \(messageBytes) exceeds threshold \(MESSAGE_SIZE_THRESHOLD), will chunk")
+        }
+
+        return needsChunking
+    }
+
+    /**
+     * Create chunks from a message that's too large for single transmission.
+     * Uses compact keys to minimize per-chunk overhead.
+     * @param originalJson The original JSON string to be sent (before C-wrapping)
+     * @param messageId The message ID for ACK tracking (if applicable)
+     * @return Array of chunk dictionaries ready to be C-wrapped and sent
+     */
+    static func createChunks(originalJson: String, messageId: Int64 = -1) -> [[String: Any]] {
+        guard let messageData = originalJson.data(using: .utf8) else {
+            print("MessageChunker: Failed to convert message to data")
+            return []
+        }
+
+        var chunks: [[String: Any]] = []
+        let totalBytes = messageData.count
+
+        // Compact chunk session ID: messageId_timestamp (no "chunk_" prefix)
+        let chunkId = "\(messageId)_\(Int(Date().timeIntervalSince1970 * 1000))"
+
+        // Calculate total chunks needed
+        let totalChunks = Int(ceil(Double(totalBytes) / Double(CHUNK_DATA_SIZE)))
+
+        print("MessageChunker: Creating \(totalChunks) chunks for message of size \(totalBytes) bytes")
+
+        for i in 0 ..< totalChunks {
+            let startIndex = i * CHUNK_DATA_SIZE
+            let endIndex = min(startIndex + CHUNK_DATA_SIZE, totalBytes)
+            let chunkRange = startIndex ..< endIndex
+
+            // Extract chunk data as string
+            let chunkData = messageData.subdata(in: chunkRange)
+            guard let chunkString = String(data: chunkData, encoding: .utf8) else {
+                print("MessageChunker: Failed to convert chunk \(i) to string")
+                continue
+            }
+
+            // Create chunk dictionary with compact keys
+            var chunk: [String: Any] = [
+                "t": "ck",
+                "id": chunkId,
+                "c": i,
+                "n": totalChunks,
+                "d": chunkString,
+            ]
+
+            // Add message ID to final chunk only for ACK tracking
+            if i == totalChunks - 1, messageId != -1 {
+                chunk["mId"] = messageId
+            }
+
+            chunks.append(chunk)
+
+            print("MessageChunker: Created chunk \(i)/\(totalChunks - 1) with \(chunkData.count) bytes")
+        }
+
+        return chunks
+    }
+
+    /**
+     * Check if a received message is a chunked message.
+     * Supports both verbose ("type":"chunked_msg") and compact ("t":"ck") formats.
+     * @param json The received dictionary (after C-unwrapping)
+     * @return true if this is a chunked message
+     */
+    static func isChunkedMessage(_ json: [String: Any]?) -> Bool {
+        guard let json = json else {
+            return false
+        }
+
+        let type = json["type"] as? String ?? json["t"] as? String ?? ""
+        return type == "chunked_msg" || type == "ck"
+    }
+
+    /**
+     * Extract chunk information from a chunked message.
+     * Supports both verbose and compact key formats.
+     */
+    static func getChunkInfo(_ json: [String: Any]) -> ChunkInfo? {
+        guard isChunkedMessage(json) else {
+            return nil
+        }
+
+        // Support both verbose and compact keys
+        guard let chunkId = (json["chunkId"] as? String) ?? (json["id"] as? String),
+              let chunkIndex = (json["chunk"] as? Int) ?? (json["c"] as? Int),
+              let totalChunks = (json["total"] as? Int) ?? (json["n"] as? Int),
+              let data = (json["data"] as? String) ?? (json["d"] as? String)
+        else {
+            print("MessageChunker: Failed to extract chunk info from JSON")
+            return nil
+        }
+
+        let messageId = json["mId"] as? Int64 ?? -1
+
+        return ChunkInfo(
+            chunkId: chunkId,
+            chunkIndex: chunkIndex,
+            totalChunks: totalChunks,
+            data: data,
+            messageId: messageId
+        )
+    }
+
+    /**
+     * Container for chunk information
+     */
+    struct ChunkInfo {
+        let chunkId: String
+        let chunkIndex: Int
+        let totalChunks: Int
+        let data: String
+        let messageId: Int64
+
+        var isFinalChunk: Bool {
+            return chunkIndex == totalChunks - 1
+        }
+    }
+}

package/ios/Source/utils/Models.swift

@@ -0,0 +1,135 @@
+//
+//  Models.swift
+//  MentraOS_Manager
+//
+//  Created by Matthew Fosse on 3/3/25.
+//
+
+import Foundation
+
+struct AiResponseToG1Model {
+    var lines: [String]
+    var totalPages: UInt8
+    var newScreen: Bool
+    var currentPage: UInt8 {
+        didSet {
+            print("SET : currentPage :\(currentPage)")
+        }
+    }
+
+    var maxPages: UInt8
+    var status: DisplayStatus
+}
+
+struct ThirdPartyCloudApp {
+    let packageName: String
+    let name: String
+    let description: String
+    let webhookURL: String
+    let logoURL: String
+    let isRunning: Bool
+}
+
+/// NCSNotification structure
+struct NCSNotification: Codable {
+    let msgId: Int
+    let type: Int
+    let appIdentifier: String
+    let title: String
+    let subtitle: String
+    let message: String
+    let timeS: Int
+    let date: String
+    let displayName: String
+
+    enum CodingKeys: String, CodingKey {
+        case msgId = "msg_id"
+        case type
+        case appIdentifier = "app_identifier"
+        case title
+        case subtitle
+        case message
+        case timeS = "time_s"
+        case date
+        case displayName = "display_name"
+    }
+
+    init(msgId: Int, appIdentifier: String, title: String, subtitle: String, message: String, displayName: String, type: Int = 1) {
+        self.msgId = msgId
+        self.type = type
+        self.appIdentifier = appIdentifier
+        self.title = title
+        self.subtitle = subtitle
+        self.message = message
+        timeS = Int(Date().timeIntervalSince1970)
+
+        let dateFormatter = DateFormatter()
+        dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
+        date = dateFormatter.string(from: Date())
+
+        self.displayName = displayName
+    }
+}
+
+/// Notification structure
+struct G1Notification: Codable {
+    let ncsNotification: NCSNotification
+    let type: String = "Add"
+
+    enum CodingKeys: String, CodingKey {
+        case ncsNotification = "ncs_notification"
+        case type
+    }
+
+    /// Convert to JSON dictionary
+    func toJson() -> [String: Any] {
+        guard let data = try? JSONEncoder().encode(self) else { return [:] }
+        guard let jsonObject = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return [:]
+        }
+        return jsonObject
+    }
+
+    /// Convert to JSON Data
+    func toData() -> Data? {
+        guard let jsonString = try? JSONEncoder().encode(self) else { return nil }
+        return jsonString
+    }
+
+    /// Build notification chunks
+    func constructNotification() async -> [[UInt8]] {
+        guard let jsonData = toData() else { return [] }
+
+        let maxChunkSize = 176 // 180 - 4 bytes for header
+        var chunks: [Data] = []
+
+        // Split data into chunks
+        var offset = 0
+        while offset < jsonData.count {
+            let endIndex = min(offset + maxChunkSize, jsonData.count)
+            let chunkData = jsonData.subdata(in: offset ..< endIndex)
+            chunks.append(chunkData)
+            offset = endIndex
+        }
+
+        let totalChunks = UInt8(chunks.count)
+        var encodedChunks: [[UInt8]] = []
+
+        // Create packets with headers
+        for (index, chunk) in chunks.enumerated() {
+            let notifyId: UInt8 = 0 // Set appropriate notification ID
+            let header: [UInt8] = [0x4B, notifyId, totalChunks, UInt8(index)]
+
+            // Convert chunk data to array of bytes
+            var chunkBytes = [UInt8](chunk)
+
+            // Combine header and chunk
+            var encodedChunk = header
+            encodedChunk.append(contentsOf: chunkBytes)
+
+            encodedChunks.append(encodedChunk)
+        }
+
+        return encodedChunks
+    }
+}