@elizaos/capacitor-bun-runtime 2.0.3-beta.2

package/ios/Sources/ElizaBunRuntimePlugin/JSContextHelpers.swift

@@ -0,0 +1,226 @@
+import Foundation
+import JavaScriptCore
+
+// MARK: - JSContext queue affinity
+
+/// Thread/queue-affinity helpers for the JSContext-bound dispatch queue.
+///
+/// JSContext is single-threaded. The runtime owns a serial DispatchQueue
+/// (`ai.eliza.bun.runtime`). All host-function bodies execute on that queue.
+/// I/O bridges (HTTP fetch, llama generation) dispatch off the runtime queue
+/// to do work, then post results back via a wrapper that re-enters the
+/// JSContext queue.
+public enum RuntimeQueue {
+    public static let label = "ai.eliza.bun.runtime"
+
+    /// Returns the JS thread's dispatch queue. Created lazily by the runtime
+    /// at startup and stored here for the bridge modules to use.
+    public static var current: DispatchQueue?
+
+    /// Dispatches a block onto the JSContext queue. If the queue is not yet
+    /// set up (e.g. early-bridge construction during install), runs inline.
+    public static func dispatchOnJS(_ block: @escaping () -> Void) {
+        if let q = current {
+            q.async(execute: block)
+        } else {
+            block()
+        }
+    }
+}
+
+// MARK: - JSValue conveniences
+
+public extension JSValue {
+    /// Returns `true` when the value is `null` or `undefined`.
+    var isNullish: Bool {
+        return isNull || isUndefined
+    }
+
+    /// Bridges a `JSValue` Uint8Array (or ArrayBuffer) to a Swift `Data` blob.
+    /// Returns `nil` if the value isn't a TypedArray / ArrayBuffer-backed view.
+    func toData() -> Data? {
+        guard let ctx = context else { return nil }
+
+        // Common path: JSC exposes typed-array length via .length and per-element
+        // access via subscript. That's slow for large blobs. Faster: call back
+        // into JS to expose a byteLength + slice() to a Uint8Array, then walk
+        // the byte values. We keep it portable across JSC builds without
+        // relying on `JSObjectGetTypedArrayBytesPtr` which is gated by
+        // availability flags.
+
+        let lenValue = forProperty("length")
+        guard let lenValue = lenValue, lenValue.isNumber else {
+            return nil
+        }
+        let count = Int(lenValue.toInt32())
+        if count == 0 { return Data() }
+
+        let global = ctx.globalObject
+        let helper = global?.forProperty("__eliza_uint8_to_array")
+        if helper == nil || helper?.isUndefined == true {
+            let install = "globalThis.__eliza_uint8_to_array = function(u){const o=new Array(u.length); for (let i=0;i<u.length;i++){o[i]=u[i]|0;} return o;};"
+            ctx.evaluateScript(install)
+        }
+
+        guard let arrayValue = ctx.evaluateScript("globalThis.__eliza_uint8_to_array")?
+            .call(withArguments: [self]),
+              let nsArray = arrayValue.toArray() else {
+            return nil
+        }
+        var out = Data(count: nsArray.count)
+        out.withUnsafeMutableBytes { (raw: UnsafeMutableRawBufferPointer) in
+            guard let base = raw.baseAddress else { return }
+            for (i, entry) in nsArray.enumerated() {
+                let n = (entry as? NSNumber)?.uint8Value ?? 0
+                base.storeBytes(of: n, toByteOffset: i, as: UInt8.self)
+            }
+        }
+        return out
+    }
+
+    /// Returns a string array from a JS array of strings. Returns nil if not
+    /// an array.
+    func toStringArray() -> [String]? {
+        guard isArray else { return nil }
+        guard let arr = toArray() else { return nil }
+        var out: [String] = []
+        out.reserveCapacity(arr.count)
+        for item in arr {
+            if let s = item as? String {
+                out.append(s)
+            } else if let n = item as? NSNumber {
+                out.append(n.stringValue)
+            } else {
+                out.append(String(describing: item))
+            }
+        }
+        return out
+    }
+
+    /// Returns a [String: String] map from a JS object whose values are strings.
+    func toStringMap() -> [String: String] {
+        var out: [String: String] = [:]
+        guard let obj = toObject() as? [String: Any] else { return out }
+        for (k, v) in obj {
+            if let s = v as? String {
+                out[k] = s
+            } else if let n = v as? NSNumber {
+                out[k] = n.stringValue
+            } else {
+                out[k] = String(describing: v)
+            }
+        }
+        return out
+    }
+}
+
+public extension JSContext {
+    /// Returns a fresh Uint8Array JSValue for the given Swift `Data`.
+    func newUint8Array(_ data: Data) -> JSValue {
+        // Constructing a Uint8Array directly from raw bytes through the public
+        // JSC API requires either JSObjectMakeTypedArrayWithBytesNoCopy or
+        // round-tripping through JS. We avoid the C API for portability.
+        // Strategy: stash bytes in a JS Array of numbers, then convert via
+        // Uint8Array.from().
+        let helper = """
+        (function(arr){return Uint8Array.from(arr);})
+        """
+        let factory = evaluateScript(helper)
+        var ints: [Int] = []
+        ints.reserveCapacity(data.count)
+        data.withUnsafeBytes { (raw: UnsafeRawBufferPointer) in
+            guard let base = raw.baseAddress else { return }
+            for i in 0..<data.count {
+                let b = base.load(fromByteOffset: i, as: UInt8.self)
+                ints.append(Int(b))
+            }
+        }
+        let result = factory?.call(withArguments: [ints])
+        return result ?? JSValue(undefinedIn: self)
+    }
+
+    /// Installs a host function on `globalThis.__ELIZA_BRIDGE__[name]`.
+    /// `body` runs on the JSContext queue (the caller's thread).
+    func installBridgeFunction(name: String, _ body: @escaping ([JSValue]) -> Any?) {
+        let block: @convention(block) () -> Any? = {
+            let args = JSContext.currentArguments() as? [JSValue] ?? []
+            return body(args)
+        }
+        let global = globalObject!
+        var bridge = global.forProperty("__ELIZA_BRIDGE__")
+        if bridge == nil || bridge?.isUndefined == true || bridge?.isNull == true {
+            evaluateScript("globalThis.__ELIZA_BRIDGE__ = {};")
+            bridge = global.forProperty("__ELIZA_BRIDGE__")
+        }
+        bridge?.setObject(unsafeBitCast(block, to: AnyObject.self), forKeyedSubscript: name as NSString)
+    }
+}
+
+// MARK: - Exception bridging
+
+public struct JSRuntimeError: Error, CustomStringConvertible {
+    public let message: String
+    public let stack: String?
+
+    public init(message: String, stack: String? = nil) {
+        self.message = message
+        self.stack = stack
+    }
+
+    public var description: String {
+        if let s = stack, !s.isEmpty {
+            return "\(message)\n\(s)"
+        }
+        return message
+    }
+}
+
+public extension JSContext {
+    /// Reads and clears the pending exception on the context. Returns a
+    /// Swift error if one was present.
+    func takeException() -> JSRuntimeError? {
+        guard let exc = self.exception else { return nil }
+        defer { self.exception = nil }
+        let message = exc.toString() ?? "Unknown JS error"
+        let stack = exc.objectForKeyedSubscript("stack")?.toString()
+        return JSRuntimeError(message: message, stack: stack)
+    }
+}
+
+// MARK: - JSManagedValue wrapper
+
+/// Holds a JS callback function safely across Swift queue hops. JSManagedValue
+/// is required because raw JSValue retention can deadlock the GC.
+public final class ManagedCallback {
+    public let managed: JSManagedValue
+    public weak var context: JSContext?
+
+    public init?(value: JSValue) {
+        guard value.isObject else { return nil }
+        self.context = value.context
+        self.managed = JSManagedValue(value: value)
+        // Hand the managed value to the VM so it survives GC sweeps.
+        value.context?.virtualMachine.addManagedReference(self.managed, withOwner: self)
+    }
+
+    deinit {
+        context?.virtualMachine.removeManagedReference(managed, withOwner: self)
+    }
+
+    /// Invokes the callback on the JSContext queue.
+    public func call(args: [Any] = []) {
+        RuntimeQueue.dispatchOnJS { [weak self] in
+            guard let self = self else { return }
+            guard let value = self.managed.value else { return }
+            _ = value.call(withArguments: args)
+        }
+    }
+
+    /// Synchronous-on-queue call, intended for use when already on the
+    /// JSContext queue. Returns the call's JSValue result.
+    @discardableResult
+    public func callSync(args: [Any] = []) -> JSValue? {
+        guard let value = managed.value else { return nil }
+        return value.call(withArguments: args)
+    }
+}

package/ios/Sources/ElizaBunRuntimePlugin/SandboxPaths.swift

@@ -0,0 +1,46 @@
+import Foundation
+
+/// Resolved sandbox directories handed to bridge modules at install time.
+/// Each path is absolute and stable for the lifetime of the process.
+public struct SandboxPaths {
+    public let appSupport: URL
+    public let documents: URL
+    public let caches: URL
+    public let tmp: URL
+    public let bundle: URL
+
+    public init(appBundle: Bundle = .main, brand: String = "Eliza") {
+        let fm = FileManager.default
+        let supportRoot = (try? fm.url(
+            for: .applicationSupportDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )) ?? URL(fileURLWithPath: NSHomeDirectory()).appendingPathComponent("Library/Application Support")
+
+        let appSupportURL = supportRoot.appendingPathComponent(brand, isDirectory: true)
+        if !fm.fileExists(atPath: appSupportURL.path) {
+            try? fm.createDirectory(at: appSupportURL, withIntermediateDirectories: true)
+        }
+        self.appSupport = appSupportURL
+
+        let docs = (try? fm.url(
+            for: .documentDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )) ?? URL(fileURLWithPath: NSHomeDirectory()).appendingPathComponent("Documents")
+        self.documents = docs
+
+        let caches = (try? fm.url(
+            for: .cachesDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )) ?? URL(fileURLWithPath: NSHomeDirectory()).appendingPathComponent("Library/Caches")
+        self.caches = caches
+
+        self.tmp = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+        self.bundle = appBundle.bundleURL
+    }
+}

package/ios/Sources/ElizaBunRuntimePlugin/bridge/CryptoBridge.swift

@@ -0,0 +1,238 @@
+import Foundation
+import JavaScriptCore
+import CryptoKit
+import CommonCrypto
+
+/// Implements the `crypto_*` host functions from `BRIDGE_CONTRACT.md`.
+///
+/// SHA/HMAC/AES-GCM go through CryptoKit. PBKDF2 falls through to
+/// CommonCrypto's `CCKeyDerivationPBKDF` because CryptoKit doesn't expose
+/// PBKDF2 directly.
+public final class CryptoBridge {
+    public init() {}
+
+    public func install(into ctx: JSContext) {
+        ctx.installBridgeFunction(name: "crypto_random_bytes") { args in
+            guard let len = args.first?.toNumber()?.intValue, len > 0 else {
+                return ctx.newUint8Array(Data())
+            }
+            var bytes = [UInt8](repeating: 0, count: len)
+            let status = SecRandomCopyBytes(kSecRandomDefault, len, &bytes)
+            if status != errSecSuccess {
+                // Fall back to arc4random which can't fail.
+                for i in 0..<len { bytes[i] = UInt8.random(in: 0...255) }
+            }
+            return ctx.newUint8Array(Data(bytes))
+        }
+
+        ctx.installBridgeFunction(name: "crypto_random_uuid") { _ in
+            return UUID().uuidString.lowercased()
+        }
+
+        ctx.installBridgeFunction(name: "crypto_hash") { args in
+            guard args.count >= 2,
+                  let algo = args[0].toString(),
+                  let data = args[1].toData() else {
+                return NSNull()
+            }
+            let out = Self.hash(algo: algo, data: data)
+            guard let out = out else { return NSNull() }
+            return ctx.newUint8Array(out)
+        }
+
+        ctx.installBridgeFunction(name: "crypto_hmac") { args in
+            guard args.count >= 3,
+                  let algo = args[0].toString(),
+                  let key = args[1].toData(),
+                  let data = args[2].toData() else {
+                return NSNull()
+            }
+            let out = Self.hmac(algo: algo, key: key, data: data)
+            guard let out = out else { return NSNull() }
+            return ctx.newUint8Array(out)
+        }
+
+        ctx.installBridgeFunction(name: "crypto_pbkdf2") { args in
+            guard args.count >= 5,
+                  let password = args[0].toData(),
+                  let salt = args[1].toData(),
+                  let iter = args[2].toNumber()?.uint32Value,
+                  let keyLen = args[3].toNumber()?.intValue,
+                  let digest = args[4].toString() else {
+                return NSNull()
+            }
+            let out = Self.pbkdf2(
+                password: password,
+                salt: salt,
+                iterations: iter,
+                keyLength: keyLen,
+                digest: digest
+            )
+            guard let out = out else { return NSNull() }
+            return ctx.newUint8Array(out)
+        }
+
+        ctx.installBridgeFunction(name: "crypto_aes_gcm_encrypt") { args in
+            guard args.count >= 3,
+                  let key = args[0].toData(),
+                  let nonce = args[1].toData(),
+                  let plaintext = args[2].toData() else {
+                return NSNull()
+            }
+            let aad: Data? = args.count >= 4 ? args[3].toData() : nil
+            guard let sealed = Self.aesGcmEncrypt(key: key, nonce: nonce, plaintext: plaintext, aad: aad) else {
+                return NSNull()
+            }
+            return [
+                "ciphertext": ctx.newUint8Array(sealed.ciphertext),
+                "tag": ctx.newUint8Array(sealed.tag),
+            ] as [String: Any]
+        }
+
+        ctx.installBridgeFunction(name: "crypto_aes_gcm_decrypt") { args in
+            guard args.count >= 4,
+                  let key = args[0].toData(),
+                  let nonce = args[1].toData(),
+                  let ciphertext = args[2].toData(),
+                  let tag = args[3].toData() else {
+                return NSNull()
+            }
+            let aad: Data? = args.count >= 5 ? args[4].toData() : nil
+            guard let plain = Self.aesGcmDecrypt(key: key, nonce: nonce, ciphertext: ciphertext, tag: tag, aad: aad) else {
+                return NSNull()
+            }
+            return ctx.newUint8Array(plain)
+        }
+    }
+
+    // MARK: - Hashes
+
+    static func hash(algo: String, data: Data) -> Data? {
+        switch algo.lowercased() {
+        case "sha256":
+            return Data(SHA256.hash(data: data))
+        case "sha512":
+            return Data(SHA512.hash(data: data))
+        case "sha1":
+            return Data(Insecure.SHA1.hash(data: data))
+        case "md5":
+            return Data(Insecure.MD5.hash(data: data))
+        default:
+            return nil
+        }
+    }
+
+    static func hmac(algo: String, key: Data, data: Data) -> Data? {
+        let symmetricKey = SymmetricKey(data: key)
+        switch algo.lowercased() {
+        case "sha256":
+            let mac = HMAC<SHA256>.authenticationCode(for: data, using: symmetricKey)
+            return Data(mac)
+        case "sha512":
+            let mac = HMAC<SHA512>.authenticationCode(for: data, using: symmetricKey)
+            return Data(mac)
+        case "sha1":
+            let mac = HMAC<Insecure.SHA1>.authenticationCode(for: data, using: symmetricKey)
+            return Data(mac)
+        default:
+            return nil
+        }
+    }
+
+    static func pbkdf2(
+        password: Data,
+        salt: Data,
+        iterations: UInt32,
+        keyLength: Int,
+        digest: String
+    ) -> Data? {
+        let prf: CCPseudoRandomAlgorithm
+        switch digest.lowercased() {
+        case "sha256": prf = CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256)
+        case "sha512": prf = CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA512)
+        case "sha1":   prf = CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA1)
+        default: return nil
+        }
+
+        var derived = Data(count: keyLength)
+        let status = derived.withUnsafeMutableBytes { (derivedRaw: UnsafeMutableRawBufferPointer) -> Int32 in
+            guard let derivedBase = derivedRaw.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                return Int32(kCCParamError)
+            }
+            return password.withUnsafeBytes { (pwRaw: UnsafeRawBufferPointer) -> Int32 in
+                guard let pwBase = pwRaw.baseAddress?.assumingMemoryBound(to: Int8.self) else {
+                    return Int32(kCCParamError)
+                }
+                return salt.withUnsafeBytes { (saltRaw: UnsafeRawBufferPointer) -> Int32 in
+                    guard let saltBase = saltRaw.baseAddress?.assumingMemoryBound(to: UInt8.self) else {
+                        return Int32(kCCParamError)
+                    }
+                    return CCKeyDerivationPBKDF(
+                        CCPBKDFAlgorithm(kCCPBKDF2),
+                        pwBase, password.count,
+                        saltBase, salt.count,
+                        prf,
+                        iterations,
+                        derivedBase, keyLength
+                    )
+                }
+            }
+        }
+        if status != 0 { return nil }
+        return derived
+    }
+
+    // MARK: - AES-GCM
+
+    struct SealedBlob {
+        let ciphertext: Data
+        let tag: Data
+    }
+
+    static func aesGcmEncrypt(key: Data, nonce: Data, plaintext: Data, aad: Data?) -> SealedBlob? {
+        guard key.count == 16 || key.count == 32 else { return nil }
+        guard nonce.count == 12 else { return nil }
+        let symmetric = SymmetricKey(data: key)
+        guard let aesNonce = try? AES.GCM.Nonce(data: nonce) else { return nil }
+        do {
+            let sealed: AES.GCM.SealedBox
+            if let aad = aad {
+                sealed = try AES.GCM.seal(plaintext, using: symmetric, nonce: aesNonce, authenticating: aad)
+            } else {
+                sealed = try AES.GCM.seal(plaintext, using: symmetric, nonce: aesNonce)
+            }
+            return SealedBlob(ciphertext: sealed.ciphertext, tag: sealed.tag)
+        } catch {
+            return nil
+        }
+    }
+
+    static func aesGcmDecrypt(key: Data, nonce: Data, ciphertext: Data, tag: Data, aad: Data?) -> Data? {
+        guard key.count == 16 || key.count == 32 else { return nil }
+        guard nonce.count == 12 else { return nil }
+        let symmetric = SymmetricKey(data: key)
+        guard let aesNonce = try? AES.GCM.Nonce(data: nonce),
+              let sealed = try? AES.GCM.SealedBox(nonce: aesNonce, ciphertext: ciphertext, tag: tag) else {
+            return nil
+        }
+        do {
+            if let aad = aad {
+                return try AES.GCM.open(sealed, using: symmetric, authenticating: aad)
+            } else {
+                return try AES.GCM.open(sealed, using: symmetric)
+            }
+        } catch {
+            return nil
+        }
+    }
+}
+
+// MARK: - JSValue numeric helpers used by the bridge
+
+extension JSValue {
+    /// Returns a Swift NSNumber for numeric JSValues. Nil for non-numbers.
+    func toNumber() -> NSNumber? {
+        guard isNumber else { return nil }
+        return NSNumber(value: toDouble())
+    }
+}

package/ios/Sources/ElizaBunRuntimePlugin/bridge/ElizaSqliteVecBridge.m

@@ -0,0 +1,28 @@
+#import <sqlite3.h>
+#import <stddef.h>
+
+__attribute__((weak)) int sqlite3_vec_init(sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi) {
+  (void)db;
+  (void)pzErrMsg;
+  (void)pApi;
+  return SQLITE_MISUSE;
+}
+
+__attribute__((weak)) const char *sqlite3_vec_version(void) {
+  return NULL;
+}
+
+int eliza_sqlite_vec_is_available(void) {
+  return sqlite3_vec_version() != NULL ? 1 : 0;
+}
+
+const char *eliza_sqlite_vec_version(void) {
+  return sqlite3_vec_version();
+}
+
+int eliza_sqlite_vec_register(sqlite3 *db, char **pzErrMsg) {
+  if (eliza_sqlite_vec_is_available() != 1) {
+    return SQLITE_MISUSE;
+  }
+  return sqlite3_vec_init(db, pzErrMsg, NULL);
+}