cactus-react-native 0.2.11 → 1.0.2

package/cpp/HybridCactusUtil.cpp

@@ -0,0 +1,47 @@
+#include "HybridCactusUtil.hpp"
+
+namespace margelo::nitro::cactus {
+
+HybridCactusUtil::HybridCactusUtil() : HybridObject(TAG) {}
+
+std::shared_ptr<Promise<std::string>>
+HybridCactusUtil::registerApp(const std::string &encryptedData) {
+  return Promise<std::string>::async([this, encryptedData]() -> std::string {
+    std::lock_guard<std::mutex> lock(this->_mutex);
+
+    const char *raw = register_app(encryptedData.c_str());
+
+    if (raw == nullptr) {
+      throw std::runtime_error("Failed to register app");
+    }
+
+    std::string registerAppStr(raw);
+    free_string(raw);
+
+    return registerAppStr;
+  });
+}
+
+std::shared_ptr<Promise<std::optional<std::string>>>
+HybridCactusUtil::getDeviceId() {
+  return Promise<std::optional<std::string>>::async(
+      [this]() -> std::optional<std::string> {
+        std::lock_guard<std::mutex> lock(this->_mutex);
+
+        const char *deviceId = get_device_id();
+        return deviceId ? std::optional<std::string>(deviceId) : std::nullopt;
+      });
+}
+
+std::shared_ptr<Promise<void>>
+HybridCactusUtil::setAndroidDataDirectory(const std::string &dataDir) {
+  return Promise<void>::async([this, dataDir]() -> void {
+    std::lock_guard<std::mutex> lock(this->_mutex);
+
+#ifdef __ANDROID__
+    set_android_data_directory(dataDir.c_str());
+#endif
+  });
+}
+
+} // namespace margelo::nitro::cactus

package/cpp/HybridCactusUtil.hpp

@@ -0,0 +1,26 @@
+#pragma once
+#include "HybridCactusUtilSpec.hpp"
+
+#include "cactus_util.h"
+
+#include <mutex>
+
+namespace margelo::nitro::cactus {
+
+class HybridCactusUtil : public HybridCactusUtilSpec {
+public:
+  HybridCactusUtil();
+
+  std::shared_ptr<Promise<std::string>>
+  registerApp(const std::string &encryptedData) override;
+
+  std::shared_ptr<Promise<std::optional<std::string>>> getDeviceId() override;
+
+  std::shared_ptr<Promise<void>>
+  setAndroidDataDirectory(const std::string &dataDir) override;
+
+private:
+  std::mutex _mutex;
+};
+
+} // namespace margelo::nitro::cactus

package/cpp/cactus_ffi.h

@@ -0,0 +1,55 @@
+#ifndef CACTUS_FFI_H
+#define CACTUS_FFI_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if __GNUC__ >= 4
+  #define CACTUS_FFI_EXPORT __attribute__ ((visibility ("default")))
+  #define CACTUS_FFI_LOCAL  __attribute__ ((visibility ("hidden")))
+#else
+  #define CACTUS_FFI_EXPORT
+  #define CACTUS_FFI_LOCAL
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* cactus_model_t;
+
+typedef void (*cactus_token_callback)(const char* token, uint32_t token_id, void* user_data);
+
+CACTUS_FFI_EXPORT cactus_model_t cactus_init(const char* model_path, size_t context_size, const char* corpus_dir);
+
+CACTUS_FFI_EXPORT int cactus_complete(
+    cactus_model_t model,
+    const char* messages_json,
+    char* response_buffer,
+    size_t buffer_size,
+    const char* options_json,
+    const char* tools_json,
+    cactus_token_callback callback,
+    void* user_data
+);
+
+
+CACTUS_FFI_EXPORT int cactus_embed(
+    cactus_model_t model,
+    const char* text,
+    float* embeddings_buffer,
+    size_t buffer_size,
+    size_t* embedding_dim
+);
+
+CACTUS_FFI_EXPORT void cactus_reset(cactus_model_t model);
+
+CACTUS_FFI_EXPORT void cactus_stop(cactus_model_t model);
+
+CACTUS_FFI_EXPORT void cactus_destroy(cactus_model_t model);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 

package/cpp/cactus_util.h

@@ -0,0 +1,25 @@
+#ifndef cactus_util_H
+#define cactus_util_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char* register_app(const char* encrypted_data);
+
+const char* get_device_id();
+
+// Helper function to free memory allocated by register_app
+void free_string(const char* str);
+
+#ifdef __ANDROID__
+// Function to set the Android app data directory
+// This should be called from Flutter/Java side before any other functions
+void set_android_data_directory(const char* data_dir);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/ios/HybridCactusCrypto.swift

@@ -0,0 +1,37 @@
+import CryptoKit
+import NitroModules
+
+class HybridCactusCrypto: HybridCactusCryptoSpec {
+  func uuidv5(namespaceUuid: String, name: String) throws -> Promise<String> {
+    return Promise.async {
+      guard let ns = UUID(uuidString: namespaceUuid) else {
+        throw RuntimeError.error(withMessage: "Invalid namespace UUID")
+      }
+
+      var nsBytes = ns.uuid
+      var data = withUnsafeBytes(of: &nsBytes) { Data($0) }
+      data.append(Data(name.utf8))
+
+      let digest = Insecure.SHA1.hash(data: data)
+      var bytes = Data(digest.prefix(16))
+      bytes.withUnsafeMutableBytes { raw in
+        let b = raw.bindMemory(to: UInt8.self)
+        b[6] = (b[6] & 0x0F) | 0x50
+        b[8] = (b[8] & 0x3F) | 0x80
+      }
+
+      let tuple = bytes.withUnsafeBytes { ptr -> uuid_t in
+        let b = ptr.bindMemory(to: UInt8.self)
+        return uuid_t(
+          b[0], b[1], b[2], b[3],
+          b[4], b[5], b[6], b[7],
+          b[8], b[9], b[10], b[11],
+          b[12], b[13], b[14], b[15])
+      }
+
+      let uuid = UUID(uuid: tuple)
+
+      return uuid.uuidString.lowercased()
+    }
+  }
+}

package/ios/HybridCactusDeviceInfo.swift

@@ -0,0 +1,32 @@
+import NitroModules
+import UIKit
+
+class HybridCactusDeviceInfo: HybridCactusDeviceInfoSpec {
+  func getAppIdentifier() throws -> Promise<String?> {
+    return Promise.async { Bundle.main.bundleIdentifier }
+  }
+
+  func getDeviceInfo() throws -> Promise<DeviceInfo> {
+    return Promise.async {
+      let device = await MainActor.run { UIDevice.current }
+      return await DeviceInfo(
+        brand: "Apple",
+        model: self.deviceModelIdentifier(),
+        device_id: device.identifierForVendor?.uuidString,
+        os: device.systemName,
+        os_version: device.systemVersion
+      )
+    }
+  }
+  
+  private func deviceModelIdentifier() -> String {
+    var systemInfo = utsname()
+    uname(&systemInfo)
+    let machineMirror = Mirror(reflecting: systemInfo.machine)
+    let identifier = machineMirror.children.reduce("") { identifier, element in
+      guard let value = element.value as? Int8, value != 0 else { return identifier }
+      return identifier + String(UnicodeScalar(UInt8(value)))
+    }
+    return identifier
+  }
+}

package/ios/HybridCactusFileSystem.swift

@@ -0,0 +1,234 @@
+import Foundation
+import NitroModules
+import ZIPFoundation
+
+class HybridCactusFileSystem: HybridCactusFileSystemSpec {
+  func getCactusDirectory() throws -> Promise<String> {
+    return Promise.async { try self.cactusURL().path }
+  }
+  
+  func fileExists(path: String) throws -> Promise<Bool> {
+    return Promise.async {
+      let cactusURL = try self.cactusURL()
+      let fileURL = cactusURL.appendingPathComponent(path)
+      return FileManager.default.fileExists(atPath: fileURL.path)
+    }
+  }
+  
+  func writeFile(path: String, content: String) throws -> Promise<Void> {
+    return Promise.async {
+      let cactusURL = try self.cactusURL()
+      let fileURL = cactusURL.appendingPathComponent(path)
+      let directoryURL = fileURL.deletingLastPathComponent()
+
+      if !FileManager.default.fileExists(atPath: directoryURL.path) {
+        try FileManager.default.createDirectory(at: directoryURL, withIntermediateDirectories: true)
+      }
+
+      try content.write(to: fileURL, atomically: true, encoding: .utf8)
+    }
+  }
+  
+  func readFile(path: String) throws -> Promise<String> {
+    return Promise.async {
+      let cactusURL = try self.cactusURL()
+      let fileURL = cactusURL.appendingPathComponent(path)
+
+      if !FileManager.default.fileExists(atPath: fileURL.path) {
+        throw RuntimeError.error(withMessage: "No such file: \(path)")
+      }
+
+      return try String(contentsOf: fileURL, encoding: .utf8)
+    }
+  }
+  
+  func deleteFile(path: String) throws -> Promise<Void> {
+    return Promise.async {
+      let cactusURL = try self.cactusURL()
+      let fileURL = cactusURL.appendingPathComponent(path)
+
+      if !FileManager.default.fileExists(atPath: fileURL.path) {
+        throw RuntimeError.error(withMessage: "No such file: \(path)")
+      }
+
+      try FileManager.default.removeItem(at: fileURL)
+    }
+  }
+  
+  func modelExists(model: String) throws -> Promise<Bool> {
+    return Promise.async {
+      let modelURL = try self.modelURL(model: model)
+      return FileManager.default.fileExists(atPath: modelURL.path)
+    }
+  }
+  
+  func getModelPath(model: String) throws -> Promise<String> {
+    return Promise.async { try self.modelURL(model: model).path }
+  }
+  
+  func downloadModel(model: String, from: String, callback: ((_ progress: Double) -> Void)?) throws
+  -> Promise<Void>
+  {
+    return Promise.async {
+      let modelURL = try self.modelURL(model: model)
+
+      if FileManager.default.fileExists(atPath: modelURL.path) {
+        DispatchQueue.main.async { callback?(1.0) }
+        return
+      }
+
+      guard let url = URL(string: from) else {
+        throw RuntimeError.error(withMessage: "Invalid URL")
+      }
+
+      var lastPct: Double = -1
+      let delegate = DownloadProgressDelegate { p in
+        DispatchQueue.main.async {
+          let pct = floor(min(max(0, p), 1) * 99) / 100
+          if pct - lastPct >= 0.01 {
+            callback?(pct)
+            lastPct = pct
+          }
+        }
+      }
+
+      let session = URLSession(configuration: .default, delegate: delegate, delegateQueue: nil)
+      let task = session.downloadTask(with: url)
+
+      callback?(0.0)
+
+      let (fileURL, response) = try await delegate.awaitCompletion(for: task)
+
+      guard let httpResponse = response as? HTTPURLResponse,
+            (200...299).contains(httpResponse.statusCode)
+      else {
+        let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+        throw RuntimeError.error(
+          withMessage: "Download failed with HTTP status code: \(statusCode)")
+      }
+
+      do {
+        try FileManager.default.createDirectory(at: modelURL, withIntermediateDirectories: true)
+        try FileManager.default.unzipItem(at: fileURL, to: modelURL)
+        try? FileManager.default.removeItem(at: fileURL)
+
+        DispatchQueue.main.async { callback?(1.0) }
+      } catch {
+        try? FileManager.default.removeItem(at: modelURL)
+        try? FileManager.default.removeItem(at: fileURL)
+
+        throw RuntimeError.error(withMessage: "Failed to download and unzip model: \(error)")
+      }
+    }
+  }
+  
+  func deleteModel(model: String) throws -> Promise<Void> {
+    return Promise.async {
+      let modelURL = try self.modelURL(model: model)
+
+      if !FileManager.default.fileExists(atPath: modelURL.path) {
+        throw RuntimeError.error(withMessage: "No such model: \(model)")
+      }
+
+      try FileManager.default.removeItem(at: modelURL)
+    }
+  }
+  
+  private func cactusURL() throws -> URL {
+    let documentsURL = try FileManager.default.url(
+      for: .documentDirectory,
+      in: .userDomainMask,
+      appropriateFor: nil,
+      create: false)
+    var cactusURL = documentsURL.appendingPathComponent("cactus", isDirectory: true)
+
+    if !FileManager.default.fileExists(atPath: cactusURL.path) {
+      try FileManager.default.createDirectory(at: cactusURL, withIntermediateDirectories: true)
+
+      // Exclude from iCloud backup
+      var resourceValues = URLResourceValues()
+      resourceValues.isExcludedFromBackup = true
+      try cactusURL.setResourceValues(resourceValues)
+    }
+
+    return cactusURL
+  }
+  
+  private func modelURL(model: String) throws -> URL {
+    let cactusURL = try self.cactusURL()
+    return cactusURL.appendingPathComponent("models/\(model)")
+  }
+}
+
+private class DownloadProgressDelegate: NSObject, URLSessionDownloadDelegate, URLSessionTaskDelegate
+{
+  private let progressHandler: (Double) -> Void
+  private var continuation: CheckedContinuation<(URL, URLResponse), Error>?
+  private var fileURL: URL?
+  private var response: URLResponse?
+  
+  init(progressHandler: @escaping (Double) -> Void) {
+    self.progressHandler = progressHandler
+  }
+  
+  func awaitCompletion(for task: URLSessionDownloadTask) async throws -> (URL, URLResponse) {
+    return try await withCheckedThrowingContinuation {
+      (cont: CheckedContinuation<(URL, URLResponse), Error>) in
+      self.continuation = cont
+      task.resume()
+    }
+  }
+  
+  func urlSession(
+    _ session: URLSession,
+    downloadTask: URLSessionDownloadTask,
+    didWriteData bytesWritten: Int64,
+    totalBytesWritten: Int64,
+    totalBytesExpectedToWrite: Int64
+  ) {
+    guard totalBytesExpectedToWrite > 0 else { return }
+    progressHandler(Double(totalBytesWritten) / Double(totalBytesExpectedToWrite))
+  }
+  
+  func urlSession(
+    _ session: URLSession,
+    downloadTask: URLSessionDownloadTask,
+    didFinishDownloadingTo location: URL
+  ) {
+    do {
+      let caches = try FileManager.default.url(
+        for: .cachesDirectory,
+        in: .userDomainMask,
+        appropriateFor: nil,
+        create: false
+      )
+
+      let destDir = caches.appendingPathComponent("cactus/models", isDirectory: true)
+      try FileManager.default.createDirectory(at: destDir, withIntermediateDirectories: true)
+
+      let dest = destDir.appendingPathComponent(UUID().uuidString).appendingPathExtension("zip")
+      try FileManager.default.moveItem(at: location, to: dest)
+
+      self.fileURL = dest
+    } catch {
+      self.fileURL = nil
+    }
+  }
+  
+  func urlSession(
+    _ session: URLSession,
+    task: URLSessionTask,
+    didCompleteWithError error: Error?
+  ) {
+    guard let cont = self.continuation else { return }
+    self.continuation = nil
+
+    if let error = error {
+      cont.resume(throwing: error)
+    } else if let url = self.fileURL, let resp = self.response ?? task.response {
+      cont.resume(returning: (url, resp))
+    } else {
+      cont.resume(throwing: URLError(.unknown))
+    }
+  }
+}

package/ios/cactus.xcframework/{info.plist → Info.plist}

@@ -18,57 +18,22 @@
 		</dict>
 		<dict>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>cactus.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
 			<key>SupportedPlatformVariant</key>
 			<string>simulator</string>
 		</dict>
-		<dict>
-			<key>LibraryIdentifier</key>
-			<string>tvos-arm64</string>
-			<key>LibraryPath</key>
-			<string>cactus.framework</string>
-			<key>SupportedArchitectures</key>
-			<array>
-				<string>arm64</string>
-			</array>
-			<key>SupportedPlatform</key>
-			<string>tvos</string>
-		</dict>
-		<dict>
-			<key>LibraryIdentifier</key>
-			<string>tvos-arm64_x86_64-simulator</string>
-			<key>LibraryPath</key>
-			<string>cactus.framework</string>
-			<key>SupportedArchitectures</key>
-			<array>
-				<string>arm64</string>
-				<string>x86_64</string>
-			</array>
-			<key>SupportedPlatform</key>
-			<string>tvos</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
-		</dict>
-
 	</array>
 	<key>CFBundlePackageType</key>
 	<string>XFWK</string>
 	<key>XCFrameworkFormatVersion</key>
 	<string>1.0</string>
-	<key>CFBundleVersion</key>
-	<string>1.0.0</string>
-	<key>CFBundleShortVersionString</key>
-	<string>1.0.0</string>
-	<key>CFBundleIdentifier</key>
-	<string>com.cactus</string>
 </dict>
-</plist>
+</plist>