@runanywhere/core 0.16.0

package/ios/HybridRunAnywhereDeviceInfo.swift

@@ -0,0 +1,214 @@
+import Foundation
+import NitroModules
+import UIKit
+
+/// Swift implementation of RunAnywhereDeviceInfo HybridObject
+/// Mirrors: sdk/runanywhere-swift/Sources/RunAnywhere/Infrastructure/Device/Models/Domain/DeviceInfo.swift
+class HybridRunAnywhereDeviceInfo: HybridRunAnywhereDeviceInfoSpec {
+
+    // MARK: - Model Lookup Tables (from Swift SDK)
+
+    private static let deviceModels: [String: String] = [
+        // iPhone 17 (2025)
+        "iPhone18,1": "iPhone 17 Pro", "iPhone18,2": "iPhone 17 Pro Max",
+        "iPhone18,3": "iPhone 17", "iPhone18,4": "iPhone 17 Plus",
+        // iPhone 16 (2024)
+        "iPhone17,1": "iPhone 16 Pro", "iPhone17,2": "iPhone 16 Pro Max",
+        "iPhone17,3": "iPhone 16", "iPhone17,4": "iPhone 16 Plus",
+        // iPhone 15 (2023)
+        "iPhone16,1": "iPhone 15 Pro", "iPhone16,2": "iPhone 15 Pro Max",
+        "iPhone15,4": "iPhone 15", "iPhone15,5": "iPhone 15 Plus",
+        // iPhone 14 (2022)
+        "iPhone15,2": "iPhone 14 Pro", "iPhone15,3": "iPhone 14 Pro Max",
+        "iPhone14,7": "iPhone 14", "iPhone14,8": "iPhone 14 Plus",
+        // iPhone 13 (2021)
+        "iPhone14,2": "iPhone 13 Pro", "iPhone14,3": "iPhone 13 Pro Max",
+        "iPhone14,4": "iPhone 13 mini", "iPhone14,5": "iPhone 13",
+        // iPhone 12 (2020)
+        "iPhone13,1": "iPhone 12 mini", "iPhone13,2": "iPhone 12",
+        "iPhone13,3": "iPhone 12 Pro", "iPhone13,4": "iPhone 12 Pro Max",
+        // iPhone SE
+        "iPhone14,6": "iPhone SE (3rd gen)", "iPhone12,8": "iPhone SE (2nd gen)",
+        // iPad Pro M4 (2024)
+        "iPad16,3": "iPad Pro 11-inch (M4)", "iPad16,4": "iPad Pro 11-inch (M4)",
+        "iPad16,5": "iPad Pro 13-inch (M4)", "iPad16,6": "iPad Pro 13-inch (M4)",
+        // iPad Pro M2 (2022)
+        "iPad14,3": "iPad Pro 11-inch (M2)", "iPad14,4": "iPad Pro 11-inch (M2)",
+        "iPad14,5": "iPad Pro 12.9-inch (M2)", "iPad14,6": "iPad Pro 12.9-inch (M2)",
+        // iPad Air
+        "iPad14,8": "iPad Air (M2)", "iPad14,9": "iPad Air (M2)",
+        "iPad13,16": "iPad Air (5th gen)", "iPad13,17": "iPad Air (5th gen)"
+    ]
+
+    // MARK: - Get Machine Identifier
+
+    private static func getMachineIdentifier() -> String {
+        var sysinfo = utsname()
+        uname(&sysinfo)
+        return withUnsafePointer(to: &sysinfo.machine) {
+            $0.withMemoryRebound(to: CChar.self, capacity: 1) {
+                String(validatingUTF8: $0) ?? "Unknown"
+            }
+        }
+    }
+
+    // MARK: - Chip Name Lookup (from Swift SDK)
+
+    private static func getChipNameForModel(_ identifier: String) -> String {
+        if identifier.hasPrefix("iPhone18,") { return "A19 Pro" }
+        if identifier.hasPrefix("iPhone17,1") || identifier.hasPrefix("iPhone17,2") { return "A18 Pro" }
+        if identifier.hasPrefix("iPhone17,") { return "A18" }
+        if identifier.hasPrefix("iPhone16,") { return "A17 Pro" }
+        if identifier.hasPrefix("iPhone15,2") || identifier.hasPrefix("iPhone15,3") { return "A16 Bionic" }
+        if identifier.hasPrefix("iPhone15,") { return "A16 Bionic" }
+        if identifier.hasPrefix("iPhone14,") { return "A15 Bionic" }
+        if identifier.hasPrefix("iPhone13,") { return "A14 Bionic" }
+        if identifier.hasPrefix("iPhone12,") { return "A13 Bionic" }
+        if identifier.hasPrefix("iPad16,") { return "M4" }
+        if identifier.hasPrefix("iPad14,3") || identifier.hasPrefix("iPad14,4") ||
+           identifier.hasPrefix("iPad14,5") || identifier.hasPrefix("iPad14,6") { return "M2" }
+        if identifier.hasPrefix("iPad14,8") || identifier.hasPrefix("iPad14,9") { return "M2" }
+        if identifier.hasPrefix("iPad13,") { return "M1" }
+
+        #if arch(arm64)
+        return "Apple Silicon"
+        #else
+        return "Intel"
+        #endif
+    }
+
+    // MARK: - HybridObject Implementation
+
+    func getDeviceModel() throws -> Promise<String> {
+        return Promise.async {
+            let machineId = Self.getMachineIdentifier()
+
+            // Check simulator
+            #if targetEnvironment(simulator)
+            if let simModelId = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] {
+                return Self.deviceModels[simModelId] ?? "iOS Simulator"
+            }
+            return "iOS Simulator"
+            #else
+            // Look up friendly model name
+            return Self.deviceModels[machineId] ?? UIDevice.current.model
+            #endif
+        }
+    }
+
+    func getOSVersion() throws -> Promise<String> {
+        return Promise.async {
+            return UIDevice.current.systemVersion
+        }
+    }
+
+    func getPlatform() throws -> Promise<String> {
+        return Promise.async {
+            return "ios"
+        }
+    }
+
+    func getTotalRAM() throws -> Promise<Double> {
+        return Promise.async {
+            return Double(ProcessInfo.processInfo.physicalMemory)
+        }
+    }
+
+    func getAvailableRAM() throws -> Promise<Double> {
+        return Promise.async {
+            var info = mach_task_basic_info()
+            var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4
+            let kerr: kern_return_t = 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)
+                }
+            }
+            if kerr == KERN_SUCCESS {
+                let usedMemory = Double(info.resident_size)
+                let totalMemory = Double(ProcessInfo.processInfo.physicalMemory)
+                return totalMemory - usedMemory
+            }
+            return Double(ProcessInfo.processInfo.physicalMemory) / 2
+        }
+    }
+
+    func getCPUCores() throws -> Promise<Double> {
+        return Promise.async {
+            return Double(ProcessInfo.processInfo.processorCount)
+        }
+    }
+
+    func hasGPU() throws -> Promise<Bool> {
+        return Promise.async {
+            // iOS devices always have GPU
+            return true
+        }
+    }
+
+    func hasNPU() throws -> Promise<Bool> {
+        return Promise.async {
+            // Check for Neural Engine (A11 Bionic and later = iPhone X and later)
+            // All arm64 iOS devices since 2017 have Neural Engine
+            #if arch(arm64)
+            return true
+            #else
+            return false
+            #endif
+        }
+    }
+
+    func getChipName() throws -> Promise<String> {
+        return Promise.async {
+            let machineId = Self.getMachineIdentifier()
+
+            #if targetEnvironment(simulator)
+            if let simModelId = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] {
+                return Self.getChipNameForModel(simModelId)
+            }
+            return "Simulated"
+            #else
+            return Self.getChipNameForModel(machineId)
+            #endif
+        }
+    }
+
+    func getThermalState() throws -> Promise<Double> {
+        return Promise.async {
+            let state = ProcessInfo.processInfo.thermalState
+            switch state {
+            case .nominal: return 0.0
+            case .fair: return 1.0
+            case .serious: return 2.0
+            case .critical: return 3.0
+            @unknown default: return 0.0
+            }
+        }
+    }
+
+    func getBatteryLevel() throws -> Promise<Double> {
+        return Promise.async {
+            await MainActor.run {
+                UIDevice.current.isBatteryMonitoringEnabled = true
+            }
+            let level = UIDevice.current.batteryLevel
+            // batteryLevel is -1.0 if monitoring not enabled or on simulator
+            return level >= 0 ? Double(level) : -1.0
+        }
+    }
+
+    func isCharging() throws -> Promise<Bool> {
+        return Promise.async {
+            await MainActor.run {
+                UIDevice.current.isBatteryMonitoringEnabled = true
+            }
+            let state = UIDevice.current.batteryState
+            return state == .charging || state == .full
+        }
+    }
+
+    func isLowPowerMode() throws -> Promise<Bool> {
+        return Promise.async {
+            return ProcessInfo.processInfo.isLowPowerModeEnabled
+        }
+    }
+}

package/ios/KeychainManager.swift

@@ -0,0 +1,116 @@
+/**
+ * KeychainManager.swift
+ *
+ * iOS Keychain manager for secure storage of sensitive data.
+ * Matches Swift SDK's KeychainManager pattern.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Foundation/Security/KeychainManager.swift
+ */
+
+import Foundation
+import Security
+
+/// Keychain manager for secure storage (singleton)
+@objc public class KeychainManager: NSObject {
+    
+    // MARK: - Singleton
+    
+    @objc public static let shared = KeychainManager()
+    
+    // MARK: - Properties
+    
+    private let serviceName = "com.runanywhere.sdk"
+    
+    // MARK: - Initialization
+    
+    private override init() {
+        super.init()
+    }
+    
+    // MARK: - Public API
+    
+    /// Store a value in the keychain
+    /// - Parameters:
+    ///   - value: Value to store
+    ///   - key: Key to store under
+    /// - Returns: true if successful
+    @objc public func set(_ value: String, forKey key: String) -> Bool {
+        guard let data = value.data(using: .utf8) else {
+            return false
+        }
+        
+        // Delete existing item first (update by delete + add)
+        _ = delete(forKey: key)
+        
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: serviceName,
+            kSecAttrAccount as String: key,
+            kSecValueData as String: data,
+            kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+        ]
+        
+        let status = SecItemAdd(query as CFDictionary, nil)
+        return status == errSecSuccess
+    }
+    
+    /// Retrieve a value from the keychain
+    /// - Parameter key: Key to retrieve
+    /// - Returns: Stored value or nil
+    @objc public func get(forKey key: String) -> String? {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: serviceName,
+            kSecAttrAccount as String: key,
+            kSecReturnData as String: true,
+            kSecMatchLimit as String: kSecMatchLimitOne
+        ]
+        
+        var dataTypeRef: AnyObject?
+        let status = SecItemCopyMatching(query as CFDictionary, &dataTypeRef)
+        
+        guard status == errSecSuccess,
+              let data = dataTypeRef as? Data,
+              let value = String(data: data, encoding: .utf8) else {
+            return nil
+        }
+        
+        return value
+    }
+    
+    /// Delete a value from the keychain
+    /// - Parameter key: Key to delete
+    /// - Returns: true if successful or item didn't exist
+    @objc public func delete(forKey key: String) -> Bool {
+        let query: [String: Any] = [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: serviceName,
+            kSecAttrAccount as String: key
+        ]
+        
+        let status = SecItemDelete(query as CFDictionary)
+        return status == errSecSuccess || status == errSecItemNotFound
+    }
+    
+    /// Check if a key exists in the keychain
+    /// - Parameter key: Key to check
+    /// - Returns: true if key exists
+    @objc public func exists(forKey key: String) -> Bool {
+        return get(forKey: key) != nil
+    }
+    
+    // MARK: - Device UUID Convenience
+    
+    private let deviceUUIDKey = "com.runanywhere.sdk.device.uuid"
+    
+    /// Store device UUID
+    @objc public func storeDeviceUUID(_ uuid: String) -> Bool {
+        return set(uuid, forKey: deviceUUIDKey)
+    }
+    
+    /// Retrieve device UUID
+    @objc public func retrieveDeviceUUID() -> String? {
+        return get(forKey: deviceUUIDKey)
+    }
+}
+

package/ios/PlatformAdapter.swift

@@ -0,0 +1,100 @@
+/**
+ * PlatformAdapter.swift
+ *
+ * iOS platform adapter for C++ callbacks.
+ * Bridges iOS-specific implementations (Keychain, FileManager) to C++ layer.
+ *
+ * Reference: sdk/runanywhere-swift/Sources/RunAnywhere/Foundation/Bridge/Extensions/CppBridge+State.swift
+ */
+
+import Foundation
+
+/// Platform adapter that provides iOS implementations for C++ callbacks
+@objc public class PlatformAdapter: NSObject {
+    
+    // MARK: - Singleton
+    
+    @objc public static let shared = PlatformAdapter()
+    
+    private override init() {
+        super.init()
+    }
+    
+    // MARK: - Secure Storage (Keychain)
+    
+    /// Get value from Keychain
+    @objc public func secureGet(_ key: String) -> String? {
+        return KeychainManager.shared.get(forKey: key)
+    }
+    
+    /// Set value in Keychain
+    @objc public func secureSet(_ key: String, value: String) -> Bool {
+        return KeychainManager.shared.set(value, forKey: key)
+    }
+    
+    /// Delete value from Keychain
+    @objc public func secureDelete(_ key: String) -> Bool {
+        return KeychainManager.shared.delete(forKey: key)
+    }
+    
+    /// Check if key exists in Keychain
+    @objc public func secureExists(_ key: String) -> Bool {
+        return KeychainManager.shared.exists(forKey: key)
+    }
+    
+    // MARK: - File Operations
+    
+    /// Check if file exists
+    @objc public func fileExists(_ path: String) -> Bool {
+        return FileManager.default.fileExists(atPath: path)
+    }
+    
+    /// Read file contents
+    @objc public func fileRead(_ path: String) -> String? {
+        return try? String(contentsOfFile: path, encoding: .utf8)
+    }
+    
+    /// Write file contents
+    @objc public func fileWrite(_ path: String, data: String) -> Bool {
+        do {
+            try data.write(toFile: path, atomically: true, encoding: .utf8)
+            return true
+        } catch {
+            return false
+        }
+    }
+    
+    /// Delete file
+    @objc public func fileDelete(_ path: String) -> Bool {
+        do {
+            try FileManager.default.removeItem(atPath: path)
+            return true
+        } catch {
+            return false
+        }
+    }
+    
+    // MARK: - Device UUID
+    
+    /// Get persistent device UUID (from Keychain or generate new)
+    @objc public func getPersistentDeviceUUID() -> String {
+        // Try to get from Keychain first
+        if let existingUUID = KeychainManager.shared.retrieveDeviceUUID() {
+            return existingUUID
+        }
+        
+        // Try vendor ID
+        #if os(iOS) || os(tvOS)
+        if let vendorUUID = UIDevice.current.identifierForVendor?.uuidString {
+            _ = KeychainManager.shared.storeDeviceUUID(vendorUUID)
+            return vendorUUID
+        }
+        #endif
+        
+        // Generate new UUID
+        let newUUID = UUID().uuidString
+        _ = KeychainManager.shared.storeDeviceUUID(newUUID)
+        return newUUID
+    }
+}
+

package/ios/PlatformAdapterBridge.h

@@ -0,0 +1,152 @@
+/**
+ * PlatformAdapterBridge.h
+ *
+ * C interface for platform-specific operations (Keychain, File I/O).
+ * Called from C++ via extern "C" functions.
+ */
+
+#ifndef PlatformAdapterBridge_h
+#define PlatformAdapterBridge_h
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// ============================================================================
+// Secure Storage (Keychain)
+// ============================================================================
+
+/**
+ * Set a value in the Keychain
+ * @param key The key to store under
+ * @param value The value to store
+ * @return true if successful
+ */
+bool PlatformAdapter_secureSet(const char* key, const char* value);
+
+/**
+ * Get a value from the Keychain
+ * @param key The key to retrieve
+ * @param outValue Pointer to store the result (must be freed by caller with free())
+ * @return true if found
+ */
+bool PlatformAdapter_secureGet(const char* key, char** outValue);
+
+/**
+ * Delete a value from the Keychain
+ * @param key The key to delete
+ * @return true if successful
+ */
+bool PlatformAdapter_secureDelete(const char* key);
+
+/**
+ * Check if a key exists in the Keychain
+ * @param key The key to check
+ * @return true if exists
+ */
+bool PlatformAdapter_secureExists(const char* key);
+
+/**
+ * Get persistent device UUID (from Keychain or generate new)
+ * @param outValue Pointer to store the UUID (must be freed by caller with free())
+ * @return true if successful
+ */
+bool PlatformAdapter_getPersistentDeviceUUID(char** outValue);
+
+// ============================================================================
+// Device Info (Synchronous)
+// ============================================================================
+
+/**
+ * Get device model name (e.g., "iPhone 16 Pro Max")
+ * @param outValue Pointer to store the result (must be freed by caller)
+ * @return true if successful
+ */
+bool PlatformAdapter_getDeviceModel(char** outValue);
+
+/**
+ * Get OS version (e.g., "18.2")
+ * @param outValue Pointer to store the result (must be freed by caller)
+ * @return true if successful
+ */
+bool PlatformAdapter_getOSVersion(char** outValue);
+
+/**
+ * Get chip name (e.g., "A18 Pro")
+ * @param outValue Pointer to store the result (must be freed by caller)
+ * @return true if successful
+ */
+bool PlatformAdapter_getChipName(char** outValue);
+
+/**
+ * Get total memory in bytes
+ * @return Total memory in bytes
+ */
+uint64_t PlatformAdapter_getTotalMemory(void);
+
+/**
+ * Get available memory in bytes
+ * @return Available memory in bytes
+ */
+uint64_t PlatformAdapter_getAvailableMemory(void);
+
+/**
+ * Get CPU core count
+ * @return Number of CPU cores
+ */
+int PlatformAdapter_getCoreCount(void);
+
+/**
+ * Get architecture (e.g., "arm64")
+ * @param outValue Pointer to store the result (must be freed by caller)
+ * @return true if successful
+ */
+bool PlatformAdapter_getArchitecture(char** outValue);
+
+/**
+ * Get GPU family (e.g., "apple" for iOS, "mali", "adreno" for Android)
+ * @param outValue Pointer to store the result (must be freed by caller)
+ * @return true if successful
+ */
+bool PlatformAdapter_getGPUFamily(char** outValue);
+
+/**
+ * Check if device is a tablet
+ * Uses UIDevice.userInterfaceIdiom on iOS, Configuration on Android
+ * @return true if device is a tablet
+ */
+bool PlatformAdapter_isTablet(void);
+
+// ============================================================================
+// HTTP POST for Device Registration (Synchronous)
+// ============================================================================
+
+/**
+ * Synchronous HTTP POST for device registration
+ * Called from C++ device manager callbacks
+ *
+ * @param url Full URL to POST to
+ * @param jsonBody JSON body string
+ * @param supabaseKey Supabase API key (for dev mode, can be NULL)
+ * @param outStatusCode Pointer to store HTTP status code
+ * @param outResponseBody Pointer to store response body (must be freed by caller)
+ * @param outErrorMessage Pointer to store error message (must be freed by caller)
+ * @return true if request succeeded (2xx or 409)
+ */
+bool PlatformAdapter_httpPostSync(
+    const char* url,
+    const char* jsonBody,
+    const char* supabaseKey,
+    int* outStatusCode,
+    char** outResponseBody,
+    char** outErrorMessage
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PlatformAdapterBridge_h */
+