@runanywhere/core 0.16.0

package/cpp/bridges/InitBridge.hpp

@@ -0,0 +1,306 @@
+/**
+ * @file InitBridge.hpp
+ * @brief SDK initialization bridge for React Native
+ *
+ * Handles rac_init() and rac_shutdown() lifecycle management.
+ * Registers platform adapter with callbacks for file I/O, logging, secure storage.
+ *
+ * Matches Swift's CppBridge initialization pattern.
+ */
+
+#pragma once
+
+#include <string>
+#include <functional>
+#include <memory>
+#include <tuple>
+
+// RACommons headers
+#include "rac_core.h"
+#include "rac_types.h"
+#include "rac_platform_adapter.h"
+#include "rac_sdk_state.h"
+#include "rac_environment.h"
+#include "rac_model_paths.h"
+
+namespace runanywhere {
+namespace bridges {
+
+/**
+ * @brief Platform callbacks provided by React Native/JavaScript layer
+ *
+ * These callbacks are invoked by C++ when platform-specific operations are needed.
+ */
+struct PlatformCallbacks {
+    // File operations
+    std::function<bool(const std::string& path)> fileExists;
+    std::function<std::string(const std::string& path)> fileRead;
+    std::function<bool(const std::string& path, const std::string& data)> fileWrite;
+    std::function<bool(const std::string& path)> fileDelete;
+
+    // Secure storage (keychain/keystore)
+    std::function<std::string(const std::string& key)> secureGet;
+    std::function<bool(const std::string& key, const std::string& value)> secureSet;
+    std::function<bool(const std::string& key)> secureDelete;
+
+    // Logging
+    std::function<void(int level, const std::string& category, const std::string& message)> log;
+
+    // Clock
+    std::function<int64_t()> nowMs;
+};
+
+/**
+ * @brief SDK Environment enum matching Swift's SDKEnvironment
+ */
+enum class SDKEnvironment {
+    Development = 0,
+    Staging = 1,
+    Production = 2
+};
+
+/**
+ * @brief SDK initialization bridge singleton
+ *
+ * Manages the lifecycle of the runanywhere-commons SDK.
+ * Registers platform adapter and initializes state.
+ */
+class InitBridge {
+public:
+    static InitBridge& shared();
+
+    /**
+     * @brief Register platform callbacks
+     *
+     * Must be called BEFORE initialize() to set up platform operations.
+     *
+     * @param callbacks Platform-specific callbacks
+     */
+    void setPlatformCallbacks(const PlatformCallbacks& callbacks);
+
+    /**
+     * @brief Initialize the SDK
+     *
+     * 1. Registers platform adapter with RACommons
+     * 2. Configures logging for environment
+     * 3. Initializes SDK state
+     *
+     * @param environment SDK environment (development, staging, production)
+     * @param apiKey API key for authentication
+     * @param baseURL Base URL for API requests
+     * @param deviceId Persistent device identifier
+     * @return RAC_SUCCESS or error code
+     */
+    rac_result_t initialize(SDKEnvironment environment,
+                           const std::string& apiKey,
+                           const std::string& baseURL,
+                           const std::string& deviceId);
+
+    /**
+     * @brief Set base directory for model paths
+     *
+     * Must be called after initialize() and before using model path utilities.
+     * Mirrors Swift's CppBridge.ModelPaths.setBaseDirectory().
+     *
+     * @param documentsPath Path to Documents directory
+     * @return RAC_SUCCESS or error code
+     */
+    rac_result_t setBaseDirectory(const std::string& documentsPath);
+
+    /**
+     * @brief Shutdown the SDK
+     */
+    void shutdown();
+
+    /**
+     * @brief Check if SDK is initialized
+     */
+    bool isInitialized() const { return initialized_; }
+
+    /**
+     * @brief Get current environment
+     */
+    SDKEnvironment getEnvironment() const { return environment_; }
+
+    /**
+     * @brief Convert SDK environment to RAC environment
+     */
+    static rac_environment_t toRacEnvironment(SDKEnvironment env);
+
+    // =========================================================================
+    // Secure Storage Methods
+    // Matches Swift: KeychainManager
+    // =========================================================================
+
+    /**
+     * @brief Store a value in secure storage (Keychain/Keystore)
+     * @param key Storage key
+     * @param value Value to store
+     * @return true if successful
+     */
+    bool secureSet(const std::string& key, const std::string& value);
+
+    /**
+     * @brief Get a value from secure storage
+     * @param key Storage key
+     * @param outValue Output value (empty if not found)
+     * @return true if value found and retrieved
+     */
+    bool secureGet(const std::string& key, std::string& outValue);
+
+    /**
+     * @brief Delete a value from secure storage
+     * @param key Storage key
+     * @return true if deleted or didn't exist
+     */
+    bool secureDelete(const std::string& key);
+
+    /**
+     * @brief Check if a key exists in secure storage
+     * @param key Storage key
+     * @return true if key exists
+     */
+    bool secureExists(const std::string& key);
+
+    /**
+     * @brief Get or create persistent device UUID
+     *
+     * Strategy (matches Swift DeviceIdentity):
+     * 1. Try to load from secure storage (survives reinstalls)
+     * 2. If not found, generate new UUID and store
+     *
+     * @return Persistent device UUID
+     */
+    std::string getPersistentDeviceUUID();
+
+    // =========================================================================
+    // Device Info (Synchronous)
+    // For device registration callback which must be synchronous
+    // =========================================================================
+
+    /**
+     * @brief Get device model name (e.g., "iPhone 16 Pro Max")
+     */
+    std::string getDeviceModel();
+
+    /**
+     * @brief Get OS version (e.g., "18.2")
+     */
+    std::string getOSVersion();
+
+    /**
+     * @brief Get chip name (e.g., "A18 Pro")
+     */
+    std::string getChipName();
+
+    /**
+     * @brief Get total memory in bytes
+     */
+    uint64_t getTotalMemory();
+
+    /**
+     * @brief Get available memory in bytes
+     */
+    uint64_t getAvailableMemory();
+
+    /**
+     * @brief Get CPU core count
+     */
+    int getCoreCount();
+
+    /**
+     * @brief Get architecture (e.g., "arm64")
+     */
+    std::string getArchitecture();
+
+    /**
+     * @brief Get GPU family (e.g., "mali", "adreno")
+     */
+    std::string getGPUFamily();
+
+    /**
+     * @brief Check if device is a tablet
+     * Uses platform-specific detection (UIDevice on iOS, Configuration on Android)
+     * Matches Swift SDK: device.userInterfaceIdiom == .pad
+     */
+    bool isTablet();
+
+    // =========================================================================
+    // Configuration Getters (for HTTP requests in production mode)
+    // =========================================================================
+
+    /**
+     * @brief Get configured API key
+     */
+    std::string getApiKey() const { return apiKey_; }
+
+    /**
+     * @brief Get configured base URL
+     */
+    std::string getBaseURL() const { return baseURL_; }
+
+    /**
+     * @brief Set SDK version (passed from TypeScript layer)
+     * Must be called during initialization to ensure consistency
+     */
+    void setSdkVersion(const std::string& version) { sdkVersion_ = version; }
+
+    /**
+     * @brief Get SDK version
+     * Returns centralized version passed from TypeScript SDKConstants
+     */
+    std::string getSdkVersion() const { return sdkVersion_.empty() ? "0.2.0" : sdkVersion_; }
+
+    // Note: getEnvironment() already defined above in "SDK Environment" section
+
+    // =========================================================================
+    // HTTP Methods for Device Registration
+    // Matches Swift: CppBridge+Device.swift http_post callback
+    // =========================================================================
+
+    /**
+     * @brief Synchronous HTTP POST for device registration
+     *
+     * Uses native URLSession (iOS) or HttpURLConnection (Android).
+     * Required by C++ rac_device_manager which expects synchronous HTTP.
+     *
+     * @param url Full URL to POST to
+     * @param jsonBody JSON body string
+     * @param supabaseKey Supabase API key (for dev mode, empty for prod)
+     * @return tuple<success, statusCode, responseBody, errorMessage>
+     */
+    std::tuple<bool, int, std::string, std::string> httpPostSync(
+        const std::string& url,
+        const std::string& jsonBody,
+        const std::string& supabaseKey
+    );
+
+private:
+    InitBridge() = default;
+    ~InitBridge();
+
+    // Disable copy/move
+    InitBridge(const InitBridge&) = delete;
+    InitBridge& operator=(const InitBridge&) = delete;
+
+    void registerPlatformAdapter();
+
+    bool initialized_ = false;
+    bool adapterRegistered_ = false;
+    SDKEnvironment environment_ = SDKEnvironment::Development;
+
+    // Configuration stored at initialization
+    std::string apiKey_;
+    std::string baseURL_;
+    std::string deviceId_;
+    std::string sdkVersion_;  // SDK version from TypeScript SDKConstants
+
+    // Platform adapter - must persist for C++ to call
+    rac_platform_adapter_t adapter_{};
+
+    // Platform callbacks from JS layer
+    PlatformCallbacks callbacks_{};
+};
+
+} // namespace bridges
+} // namespace runanywhere

package/cpp/bridges/ModelRegistryBridge.cpp

@@ -0,0 +1,394 @@
+/**
+ * @file ModelRegistryBridge.cpp
+ * @brief C++ bridge for model registry operations.
+ *
+ * Mirrors Swift's CppBridge+ModelRegistry.swift pattern.
+ */
+
+#include "ModelRegistryBridge.hpp"
+#include "rac_core.h"  // For rac_get_model_registry()
+#include <cstring>
+
+// Platform-specific logging
+#if defined(ANDROID) || defined(__ANDROID__)
+#include <android/log.h>
+#define LOG_TAG "ModelRegistryBridge"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+#include <cstdio>
+#define LOGI(...) printf("[ModelRegistryBridge] "); printf(__VA_ARGS__); printf("\n")
+#define LOGD(...) printf("[ModelRegistryBridge DEBUG] "); printf(__VA_ARGS__); printf("\n")
+#define LOGE(...) printf("[ModelRegistryBridge ERROR] "); printf(__VA_ARGS__); printf("\n")
+#endif
+
+namespace runanywhere {
+namespace bridges {
+
+ModelRegistryBridge& ModelRegistryBridge::shared() {
+    static ModelRegistryBridge instance;
+    return instance;
+}
+
+ModelRegistryBridge::~ModelRegistryBridge() {
+    shutdown();
+}
+
+rac_result_t ModelRegistryBridge::initialize() {
+    if (handle_) {
+        LOGD("Model registry already initialized");
+        return RAC_SUCCESS;
+    }
+
+    // Use the GLOBAL model registry (same as Swift SDK)
+    // This ensures models registered by backends are visible to the SDK
+    handle_ = rac_get_model_registry();
+
+    if (handle_) {
+        LOGI("Using global C++ model registry");
+        return RAC_SUCCESS;
+    } else {
+        LOGE("Failed to get global model registry");
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+}
+
+void ModelRegistryBridge::shutdown() {
+    // NOTE: We're using the GLOBAL registry - DO NOT clear the handle
+    // The global registry persists for the lifetime of the app
+    // Just log that shutdown was called, but don't actually release the handle
+    LOGI("Model registry shutdown called (global registry handle retained)");
+    // DO NOT: handle_ = nullptr;
+}
+
+ModelInfo ModelRegistryBridge::fromRac(const rac_model_info_t& cModel) {
+    ModelInfo model;
+
+    model.id = cModel.id ? cModel.id : "";
+    model.name = cModel.name ? cModel.name : "";
+    model.description = cModel.description ? cModel.description : "";
+    model.category = cModel.category;
+    model.format = cModel.format;
+    model.framework = cModel.framework;
+    model.downloadUrl = cModel.download_url ? cModel.download_url : "";
+    model.localPath = cModel.local_path ? cModel.local_path : "";
+    model.downloadSize = cModel.download_size;
+    model.memoryRequired = cModel.memory_required;
+    model.contextLength = cModel.context_length;
+    model.supportsThinking = cModel.supports_thinking == RAC_TRUE;
+    model.source = cModel.source;
+
+    // Copy tags
+    if (cModel.tags && cModel.tag_count > 0) {
+        for (size_t i = 0; i < cModel.tag_count; i++) {
+            if (cModel.tags[i]) {
+                model.tags.push_back(cModel.tags[i]);
+            }
+        }
+    }
+
+    // Check if downloaded
+    model.isDownloaded = !model.localPath.empty() && model.localPath[0] != '\0';
+
+    return model;
+}
+
+void ModelRegistryBridge::toRac(const ModelInfo& model, rac_model_info_t& cModel) {
+    // Note: This allocates strings that must be freed
+    // For now we use static storage for simplicity
+    static std::string s_id, s_name, s_desc, s_url, s_path;
+    static std::vector<std::string> s_tags;
+    static std::vector<const char*> s_tagPtrs;
+
+    s_id = model.id;
+    s_name = model.name;
+    s_desc = model.description;
+    s_url = model.downloadUrl;
+    s_path = model.localPath;
+
+    memset(&cModel, 0, sizeof(cModel));
+
+    cModel.id = const_cast<char*>(s_id.c_str());
+    cModel.name = const_cast<char*>(s_name.c_str());
+    cModel.description = s_desc.empty() ? nullptr : const_cast<char*>(s_desc.c_str());
+    cModel.category = model.category;
+    cModel.format = model.format;
+    cModel.framework = model.framework;
+    cModel.download_url = s_url.empty() ? nullptr : const_cast<char*>(s_url.c_str());
+    cModel.local_path = s_path.empty() ? nullptr : const_cast<char*>(s_path.c_str());
+    cModel.download_size = model.downloadSize;
+    cModel.memory_required = model.memoryRequired;
+    cModel.context_length = model.contextLength;
+    cModel.supports_thinking = model.supportsThinking ? RAC_TRUE : RAC_FALSE;
+    cModel.source = model.source;
+
+    // Setup tags
+    s_tags = model.tags;
+    s_tagPtrs.clear();
+    for (const auto& tag : s_tags) {
+        s_tagPtrs.push_back(tag.c_str());
+    }
+    if (!s_tagPtrs.empty()) {
+        cModel.tags = const_cast<char**>(s_tagPtrs.data());
+        cModel.tag_count = s_tagPtrs.size();
+    }
+}
+
+rac_result_t ModelRegistryBridge::addModel(const ModelInfo& model) {
+    if (!handle_) {
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+
+    rac_model_info_t cModel;
+    toRac(model, cModel);
+
+    // Use rac_model_registry_save to add/update a model
+    rac_result_t result = rac_model_registry_save(handle_, &cModel);
+
+    if (result == RAC_SUCCESS) {
+        LOGI("Added model: %s", model.id.c_str());
+    } else {
+        LOGE("Failed to add model %s: %d", model.id.c_str(), result);
+    }
+
+    return result;
+}
+
+rac_result_t ModelRegistryBridge::removeModel(const std::string& modelId) {
+    if (!handle_) {
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+
+    rac_result_t result = rac_model_registry_remove(handle_, modelId.c_str());
+
+    if (result == RAC_SUCCESS) {
+        LOGI("Removed model: %s", modelId.c_str());
+    } else {
+        LOGE("Failed to remove model %s: %d", modelId.c_str(), result);
+    }
+
+    return result;
+}
+
+rac_result_t ModelRegistryBridge::updateModelPath(const std::string& modelId, const std::string& localPath) {
+    if (!handle_) {
+        return RAC_ERROR_NOT_INITIALIZED;
+    }
+
+    // Use rac_model_registry_update_download_status to update the model's local path
+    rac_result_t result = rac_model_registry_update_download_status(handle_, modelId.c_str(), localPath.c_str());
+
+    if (result == RAC_SUCCESS) {
+        LOGI("Updated model path: %s -> %s", modelId.c_str(), localPath.c_str());
+    } else {
+        LOGE("Failed to update model path %s: %d", modelId.c_str(), result);
+    }
+
+    return result;
+}
+
+std::optional<ModelInfo> ModelRegistryBridge::getModel(const std::string& modelId) {
+    if (!handle_) {
+        return std::nullopt;
+    }
+
+    rac_model_info_t* cModel = nullptr;
+    rac_result_t result = rac_model_registry_get(handle_, modelId.c_str(), &cModel);
+
+    if (result != RAC_SUCCESS || !cModel) {
+        return std::nullopt;
+    }
+
+    ModelInfo model = fromRac(*cModel);
+    rac_model_info_free(cModel);
+
+    return model;
+}
+
+std::vector<ModelInfo> ModelRegistryBridge::getAllModels() {
+    std::vector<ModelInfo> models;
+
+    if (!handle_) {
+        LOGE("getAllModels: Registry not initialized!");
+        return models;
+    }
+
+    rac_model_info_t** cModels = nullptr;
+    size_t count = 0;
+
+    LOGD("getAllModels: Calling rac_model_registry_get_all with handle=%p", handle_);
+
+    rac_result_t result = rac_model_registry_get_all(handle_, &cModels, &count);
+
+    LOGI("getAllModels: result=%d, count=%zu", result, count);
+
+    if (result != RAC_SUCCESS || !cModels) {
+        LOGE("getAllModels: Failed with result=%d, cModels=%p", result, (void*)cModels);
+        return models;
+    }
+
+    for (size_t i = 0; i < count; i++) {
+        if (cModels[i]) {
+            models.push_back(fromRac(*cModels[i]));
+            LOGD("getAllModels: Added model %s", cModels[i]->id);
+        }
+    }
+
+    rac_model_info_array_free(cModels, count);
+
+    LOGI("getAllModels: Returning %zu models", models.size());
+
+    return models;
+}
+
+std::vector<ModelInfo> ModelRegistryBridge::getModels(const ModelFilter& filter) {
+    std::vector<ModelInfo> models;
+
+    if (!handle_) {
+        return models;
+    }
+
+    // Get all models first
+    rac_model_info_t** cModels = nullptr;
+    size_t count = 0;
+
+    rac_result_t result = rac_model_registry_get_all(handle_, &cModels, &count);
+
+    if (result != RAC_SUCCESS || !cModels) {
+        return models;
+    }
+
+    // Setup filter
+    rac_model_filter_t cFilter = {};
+    cFilter.framework = filter.framework;
+    cFilter.format = filter.format;
+    cFilter.max_size = filter.maxSize;
+    cFilter.search_query = filter.searchQuery.empty() ? nullptr : filter.searchQuery.c_str();
+
+    // Apply filter using rac_model_matches_filter helper
+    for (size_t i = 0; i < count; i++) {
+        if (cModels[i]) {
+            if (rac_model_matches_filter(cModels[i], &cFilter) == RAC_TRUE) {
+                models.push_back(fromRac(*cModels[i]));
+            }
+        }
+    }
+
+    rac_model_info_array_free(cModels, count);
+
+    return models;
+}
+
+std::vector<ModelInfo> ModelRegistryBridge::getModelsByFramework(rac_inference_framework_t framework) {
+    ModelFilter filter;
+    filter.framework = framework;
+    return getModels(filter);
+}
+
+std::vector<ModelInfo> ModelRegistryBridge::getDownloadedModels() {
+    std::vector<ModelInfo> models;
+
+    if (!handle_) {
+        return models;
+    }
+
+    rac_model_info_t** cModels = nullptr;
+    size_t count = 0;
+
+    rac_result_t result = rac_model_registry_get_downloaded(handle_, &cModels, &count);
+
+    if (result != RAC_SUCCESS || !cModels) {
+        return models;
+    }
+
+    for (size_t i = 0; i < count; i++) {
+        if (cModels[i]) {
+            models.push_back(fromRac(*cModels[i]));
+        }
+    }
+
+    rac_model_info_array_free(cModels, count);
+
+    return models;
+}
+
+bool ModelRegistryBridge::modelExists(const std::string& modelId) {
+    if (!handle_) {
+        return false;
+    }
+
+    // Check existence by trying to get the model
+    rac_model_info_t* cModel = nullptr;
+    rac_result_t result = rac_model_registry_get(handle_, modelId.c_str(), &cModel);
+
+    if (result == RAC_SUCCESS && cModel) {
+        rac_model_info_free(cModel);
+        return true;
+    }
+
+    return false;
+}
+
+bool ModelRegistryBridge::isModelDownloaded(const std::string& modelId) {
+    if (!handle_) {
+        return false;
+    }
+
+    // Get the model and check its download status
+    rac_model_info_t* cModel = nullptr;
+    rac_result_t result = rac_model_registry_get(handle_, modelId.c_str(), &cModel);
+
+    if (result != RAC_SUCCESS || !cModel) {
+        return false;
+    }
+
+    rac_bool_t downloaded = rac_model_info_is_downloaded(cModel);
+    rac_model_info_free(cModel);
+
+    return downloaded == RAC_TRUE;
+}
+
+std::optional<std::string> ModelRegistryBridge::getModelPath(const std::string& modelId) {
+    if (!handle_) {
+        return std::nullopt;
+    }
+
+    // Get the model and extract its local_path
+    rac_model_info_t* cModel = nullptr;
+    rac_result_t result = rac_model_registry_get(handle_, modelId.c_str(), &cModel);
+
+    if (result != RAC_SUCCESS || !cModel) {
+        return std::nullopt;
+    }
+
+    std::string pathStr;
+    if (cModel->local_path && cModel->local_path[0] != '\0') {
+        pathStr = cModel->local_path;
+    }
+
+    rac_model_info_free(cModel);
+
+    return pathStr.empty() ? std::nullopt : std::make_optional(pathStr);
+}
+
+size_t ModelRegistryBridge::getModelCount() {
+    if (!handle_) {
+        return 0;
+    }
+
+    // Get count by getting all models
+    rac_model_info_t** cModels = nullptr;
+    size_t count = 0;
+
+    rac_result_t result = rac_model_registry_get_all(handle_, &cModels, &count);
+
+    if (result == RAC_SUCCESS && cModels) {
+        rac_model_info_array_free(cModels, count);
+    }
+
+    return count;
+}
+
+} // namespace bridges
+} // namespace runanywhere