cactus-react-native 0.2.11 → 1.0.1

package/android/build.gradle

@@ -1,60 +1,94 @@
 buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['Cactus_' + name]
+  }
+
   repositories {
     google()
     mavenCentral()
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["arm64-v8a"]
 }
 
 apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/cactus+autolinking.gradle'
 
-
-def appProject = rootProject.allprojects.find { it.plugins.hasPlugin('com.android.application') }
-
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Cactus_" + name]
-}
+apply plugin: "com.facebook.react"
 
 def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Cactus_" + name]).toInteger()
 }
 
-def reactNativeArchitectures() {
-  def value = project.getProperties().get("reactNativeArchitectures")
-  def archs = value ? value.split(",") : ["x86_64", "arm64-v8a"]
-  return archs.findAll { it != "armeabi-v7a" && it != "x86" } // Not building for 32-bit architectures
-}
-
 android {
-  ndkVersion getExtOrDefault("ndkVersion")
-  def ndkVersionMajor = ndkVersion.split("\\.")[0].toInteger()
-  if (ndkVersionMajor < 24) {
-    ndkVersion = project.properties["Cactus_ndkversion"]
-  }
+  namespace "com.margelo.nitro.cactus"
+
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
     minSdkVersion getExtOrIntegerDefault("minSdkVersion")
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+
     externalNativeBuild {
       cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
         abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
       }
     }
   }
-  
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -72,12 +106,10 @@ android {
 
   sourceSets {
     main {
-      if (isNewArchitectureEnabled()) {
-        java.srcDirs += ['src/newarch']
-      } else {
-        java.srcDirs += ['src/oldarch']
-      }
-      jniLibs.srcDirs = ['src/main/jniLibs']
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
     }
   }
 }
@@ -87,18 +119,10 @@ repositories {
   google()
 }
 
+def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-  // For < 0.71, this will be from the local maven repo
-  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
-  //noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"
-}
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "Cactus"
-    codegenJavaPackageName = "com.cactus"
-  }
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
 }

package/android/gradle.properties

@@ -1,5 +1,5 @@
-Cactus_kotlinVersion=1.7.0
-Cactus_minSdkVersion=23
-Cactus_targetSdkVersion=31
-Cactus_compileSdkVersion=31
-Cactus_ndkversion=25.1.8937393
+Cactus_kotlinVersion=2.0.21
+Cactus_minSdkVersion=24
+Cactus_targetSdkVersion=34
+Cactus_compileSdkVersion=35
+Cactus_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -1,4 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.cactus">
-
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "cactusOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::cactus::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/cactus/CactusPackage.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.cactus
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class CactusPackage : BaseReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("cactus")
+        }
+    }
+}

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusCrypto.kt

@@ -0,0 +1,38 @@
+package com.margelo.nitro.cactus
+
+import com.margelo.nitro.core.Promise
+import java.nio.ByteBuffer
+import java.security.MessageDigest
+import java.util.Locale
+import java.util.UUID
+
+class HybridCactusCrypto : HybridCactusCryptoSpec() {
+  override fun uuidv5(namespaceUuid: String, name: String): Promise<String> {
+    return Promise.async {
+      val nsUuid = try {
+        UUID.fromString(namespaceUuid)
+      } catch (e: IllegalArgumentException) {
+        throw IllegalArgumentException("Invalid namespace UUID")
+      }
+
+      val nsBytes = ByteBuffer.allocate(16).apply {
+        putLong(nsUuid.mostSignificantBits)
+        putLong(nsUuid.leastSignificantBits)
+      }.array()
+      val nameBytes = name.toByteArray(Charsets.UTF_8)
+
+      val sha1 = MessageDigest.getInstance("SHA-1")
+        .apply { update(nsBytes) }
+        .digest(nameBytes)
+      val uuidBytes = sha1.copyOfRange(0, 16)
+      uuidBytes[6] = (uuidBytes[6].toInt() and 0x0F or 0x50).toByte()
+      uuidBytes[8] = (uuidBytes[8].toInt() and 0x3F or 0x80).toByte()
+
+      val bb = ByteBuffer.wrap(uuidBytes)
+
+      val uuid = UUID(bb.long, bb.long)
+
+      uuid.toString().lowercase(Locale.ROOT)
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusDeviceInfo.kt

@@ -0,0 +1,24 @@
+package com.margelo.nitro.cactus
+
+import android.os.Build
+import android.provider.Settings
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+
+class HybridCactusDeviceInfo : HybridCactusDeviceInfoSpec() {
+  private val context = NitroModules.applicationContext ?: error("Android context not found")
+
+  override fun getAppIdentifier(): Promise<String?> {
+    return Promise.async { context.packageName }
+  }
+
+  override fun getDeviceInfo(): Promise<DeviceInfo> {
+    return Promise.async {
+      DeviceInfo(
+        brand = Build.MANUFACTURER, model = Build.MODEL, device_id = Settings.Secure.getString(
+          context.contentResolver, Settings.Secure.ANDROID_ID
+        ), os = "Android", os_version = Build.VERSION.RELEASE
+      )
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/cactus/HybridCactusFileSystem.kt

@@ -0,0 +1,227 @@
+package com.margelo.nitro.cactus
+
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.net.HttpURLConnection
+import java.net.URL
+import java.util.zip.ZipEntry
+import java.util.zip.ZipInputStream
+import kotlin.math.floor
+
+class HybridCactusFileSystem : HybridCactusFileSystemSpec() {
+  private val context = NitroModules.applicationContext ?: error("Android context not found")
+
+  override fun getCactusDirectory(): Promise<String> {
+    return Promise.async { cactusFile().absolutePath }
+  }
+
+  override fun fileExists(path: String): Promise<Boolean> {
+    return Promise.async {
+      val cactusDir = cactusFile()
+      val file = File(cactusDir, path)
+      file.exists()
+    }
+  }
+
+  override fun writeFile(path: String, content: String): Promise<Unit> {
+    return Promise.async {
+      val cactusDir = cactusFile()
+      val file = File(cactusDir, path)
+      file.parentFile?.mkdirs()
+      file.writeText(content)
+    }
+  }
+
+  override fun readFile(path: String): Promise<String> {
+    return Promise.async {
+      val cactusDir = cactusFile()
+      val file = File(cactusDir, path)
+
+      if (!file.exists()) {
+        throw Error("No such file: $path")
+      }
+
+      file.readText()
+    }
+  }
+
+  override fun deleteFile(path: String): Promise<Unit> {
+    return Promise.async {
+      val cactusDir = cactusFile()
+      val file = File(cactusDir, path)
+
+      if (!file.exists()) {
+        throw Error("No such file: $path")
+      }
+
+      file.deleteRecursively()
+    }
+  }
+
+  override fun modelExists(model: String): Promise<Boolean> {
+    return Promise.async { modelFile(model).exists() }
+  }
+
+  override fun getModelPath(model: String): Promise<String> {
+    return Promise.async { modelFile(model).absolutePath }
+  }
+
+  override fun downloadModel(
+    model: String, from: String, callback: ((progress: Double) -> Unit)?
+  ): Promise<Unit> {
+    return Promise.async {
+      val modelFile = modelFile(model)
+
+      if (modelFile.exists()) {
+        callback?.invoke(1.0)
+        return@async
+      }
+
+      val url = try {
+        URL(from)
+      } catch (_: Throwable) {
+        throw Error("Invalid URL")
+      }
+
+      val tmpZip = File.createTempFile("dl_", ".zip", context.cacheDir)
+      var connection: HttpURLConnection? = null
+
+      try {
+        connection = (url.openConnection() as HttpURLConnection).apply {
+          connectTimeout = 30_000
+          readTimeout = 5 * 60_000
+          instanceFollowRedirects = true
+        }
+        connection.connect()
+        val code = connection.responseCode
+
+        if (code !in 200..299) {
+          connection.disconnect()
+          throw Error("Download failed with HTTP status code: $code")
+        }
+
+        val contentLength = connection.getHeaderFieldLong("Content-Length", -1L)
+        var downloaded = 0L
+        var lastPct = -1.0
+
+        callback?.invoke(0.0)
+
+        connection.inputStream.use { input ->
+          BufferedInputStream(input).use { bis ->
+            FileOutputStream(tmpZip).use { fos ->
+              BufferedOutputStream(fos).use { bos ->
+                val buf = ByteArray(256 * 1024)
+
+                while (true) {
+                  val read = bis.read(buf)
+
+                  if (read == -1) {
+                    break
+                  }
+
+                  bos.write(buf, 0, read)
+                  downloaded += read
+
+                  if (contentLength > 0) {
+                    // cap at 0.99; 1.0 will be sent after unzip
+                    val pct = floor(
+                      (downloaded.toDouble() / contentLength.toDouble()).coerceIn(
+                        0.0, 1.0
+                      ) * 99
+                    ) / 100.0
+
+                    if (pct - lastPct >= 0.01) {
+                      callback?.invoke(pct)
+                      lastPct = pct
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        modelFile.mkdirs()
+        unzipItem(tmpZip, modelFile)
+
+        callback?.invoke(1.0)
+      } catch (t: Throwable) {
+        modelFile.deleteRecursively()
+        throw Error("Failed to download and unzip model: ${t.message}")
+      } finally {
+        tmpZip.delete()
+        connection?.disconnect()
+      }
+    }
+  }
+
+  private fun unzipItem(zipFile: File, outDir: File) {
+    val outRoot = outDir.canonicalFile
+    ZipInputStream(BufferedInputStream(FileInputStream(zipFile))).use { zis ->
+      var entry: ZipEntry? = zis.nextEntry
+      val buffer = ByteArray(256 * 1024)
+
+      while (entry != null) {
+        val outPath = File(outDir, entry.name)
+
+        // ZIP Slip protection
+        val canonical = outPath.canonicalFile
+        if (!canonical.path.startsWith(outRoot.path + File.separator)) {
+          throw SecurityException("Blocked zip entry outside target dir: ${entry.name}")
+        }
+
+        if (entry.isDirectory) {
+          canonical.mkdirs()
+        } else {
+          canonical.parentFile?.mkdirs()
+          FileOutputStream(canonical).use { fos ->
+            BufferedOutputStream(fos).use { bos ->
+              while (true) {
+                val read = zis.read(buffer)
+                if (read == -1) break
+                bos.write(buffer, 0, read)
+              }
+            }
+          }
+        }
+
+        zis.closeEntry()
+        entry = zis.nextEntry
+      }
+    }
+  }
+
+  override fun deleteModel(model: String): Promise<Unit> {
+    return Promise.async {
+      val modelFile = modelFile(model)
+
+      if (!modelFile.exists()) {
+        throw Error("No such model: $model")
+      }
+
+      modelFile.deleteRecursively()
+    }
+  }
+
+  private fun cactusFile(): File {
+    val documentsDir =
+      context.getExternalFilesDir(android.os.Environment.DIRECTORY_DOCUMENTS) ?: context.filesDir
+    val cactusDir = File(documentsDir, "cactus")
+
+    if (!cactusDir.exists()) {
+      cactusDir.mkdirs()
+    }
+
+    return cactusDir
+  }
+
+  private fun modelFile(model: String): File {
+    val cactusDir = cactusFile()
+    return File(cactusDir, "models/$model")
+  }
+}

package/cpp/HybridCactus.cpp

@@ -0,0 +1,123 @@
+#include "HybridCactus.hpp"
+
+namespace margelo::nitro::cactus
+{
+HybridCactus::HybridCactus() : HybridObject(TAG) {}
+
+std::shared_ptr<Promise<void>> HybridCactus::init(const std::string &modelPath, double contextSize) {
+  return Promise<void>::async([this, modelPath, contextSize]() -> void {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (this->_model) {
+      throw std::runtime_error("Cactus model is already initialized");
+    }
+
+    const cactus_model_t model = cactus_init(modelPath.c_str(), contextSize);
+
+    if (!model) {
+      throw std::runtime_error("Failed to initialize Cactus model");
+    }
+
+    this->_model = model;
+    this->_contextSize = contextSize;
+  });
+}
+
+std::shared_ptr<Promise<std::string>> HybridCactus::complete(const std::string &messagesJson, double responseBufferSize, const std::optional<std::string> &optionsJson, const std::optional<std::string> &toolsJson, const std::optional<std::function<void(const std::string & /* token */, double /* tokenId */)>> &callback) {
+  return Promise<std::string>::async([this, messagesJson, optionsJson, toolsJson, callback, responseBufferSize]() -> std::string {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_model) {
+      throw std::runtime_error("Cactus model is not initialized");
+    }
+
+    struct CallbackCtx {
+      const std::function<void(const std::string & /* token */, double /* tokenId */)> *callback;
+    } callbackCtx{ callback.has_value() ? &callback.value() : nullptr };
+
+    auto cactusTokenCallback = [](const char* token, uint32_t tokenId, void* userData) {
+      auto* callbackCtx = static_cast<CallbackCtx*>(userData);
+      if (!callbackCtx || !callbackCtx->callback || !(*callbackCtx->callback)) return;
+      (*callbackCtx->callback)(token, tokenId);
+    };
+
+    std::string responseBuffer;
+    responseBuffer.resize(responseBufferSize);
+
+    int result = cactus_complete(
+                    this->_model,
+                    messagesJson.c_str(),
+                    responseBuffer.data(),
+                    responseBufferSize,
+                    optionsJson ? optionsJson->c_str() : nullptr,
+                    toolsJson ? toolsJson->c_str() : nullptr,
+                    cactusTokenCallback,
+                    &callbackCtx
+                    );
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus completion failed");
+    }
+
+    // Remove null terminator
+    responseBuffer.resize(strlen(responseBuffer.c_str()));
+
+    return responseBuffer;
+  });
+}
+
+std::shared_ptr<Promise<std::vector<double>>> HybridCactus::embed(const std::string &text, double embeddingBufferSize) {
+  return Promise<std::vector<double>>::async([this, text, embeddingBufferSize]() -> std::vector<double> {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_model) {
+      throw std::runtime_error("Cactus model is not initialized");
+    }
+
+    std::vector<float> embeddingBuffer(embeddingBufferSize);
+    size_t embeddingDim;
+
+    int result = cactus_embed(this->_model, text.c_str(), embeddingBuffer.data(), embeddingBufferSize * sizeof(float), &embeddingDim);
+
+    if (result < 0) {
+      throw std::runtime_error("Cactus embedding failed");
+    }
+
+    embeddingBuffer.resize(embeddingDim);
+
+    return std::vector<double>(embeddingBuffer.begin(), embeddingBuffer.end());
+  });
+}
+
+std::shared_ptr<Promise<void>> HybridCactus::reset() {
+  return Promise<void>::async([this]() -> void {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_model) {
+      throw std::runtime_error("Cactus model is not initialized");
+    }
+
+    cactus_reset(this->_model);
+  });
+}
+
+std::shared_ptr<Promise<void>> HybridCactus::stop() {
+  return Promise<void>::async([this]() -> void {
+    cactus_stop(this->_model);
+  });
+}
+
+std::shared_ptr<Promise<void>> HybridCactus::destroy() {
+  return Promise<void>::async([this]() -> void {
+    std::lock_guard<std::mutex> lock(this->_modelMutex);
+
+    if (!this->_model) {
+      throw std::runtime_error("Cactus model is not initialized");
+    }
+
+    cactus_destroy(this->_model);
+    this->_model = nullptr;
+  });
+}
+
+} // namespace margelo::nitro::cactus

package/cpp/HybridCactus.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "HybridCactusSpec.hpp"
+
+#include "cactus_ffi.h"
+
+#include <mutex>
+
+namespace margelo::nitro::cactus
+{
+
+class HybridCactus : public HybridCactusSpec
+{
+public:
+  HybridCactus();
+  
+  std::shared_ptr<Promise<void>> init(const std::string &modelPath, double contextSize) override;
+  
+  std::shared_ptr<Promise<std::string>> complete(const std::string &messagesJson, double responseBufferSize, const std::optional<std::string> &optionsJson, const std::optional<std::string> &toolsJson, const std::optional<std::function<void(const std::string & /* token */, double /* tokenId */)>> &callback) override;
+  
+  std::shared_ptr<Promise<std::vector<double>>> embed(const std::string &text, double embeddingBufferSize) override;
+  
+  std::shared_ptr<Promise<void>> reset() override;
+  
+  std::shared_ptr<Promise<void>> stop() override;
+  
+  std::shared_ptr<Promise<void>> destroy() override;
+  
+private:
+  cactus_model_t _model = nullptr;
+  size_t _contextSize;
+
+  std::mutex _modelMutex;
+};
+
+} // namespace margelo::nitro::cactus