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

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

@@ -0,0 +1,270 @@
+import Foundation
+import JavaScriptCore
+
+/// Implements the `fs_*` host functions from `BRIDGE_CONTRACT.md`.
+///
+/// All sync calls return `null` / `false` on failure and stash the error
+/// string in a thread-local field readable via `fs_last_error()`.
+public final class FSBridge {
+    private weak var context: JSContext?
+    private var lastError: String?
+
+    public init() {}
+
+    public func install(into ctx: JSContext) {
+        self.context = ctx
+        let fm = FileManager.default
+
+        ctx.installBridgeFunction(name: "fs_read_text") { args in
+            self.clearError()
+            guard let path = args.first?.toString() else {
+                self.setError("fs_read_text: missing path")
+                return NSNull()
+            }
+            do {
+                let s = try String(contentsOfFile: path, encoding: .utf8)
+                return s
+            } catch {
+                self.setError("fs_read_text: \(error.localizedDescription)")
+                return NSNull()
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_read_bytes") { args in
+            self.clearError()
+            guard let path = args.first?.toString() else {
+                self.setError("fs_read_bytes: missing path")
+                return NSNull()
+            }
+            do {
+                let data = try Data(contentsOf: URL(fileURLWithPath: path))
+                return ctx.newUint8Array(data)
+            } catch {
+                self.setError("fs_read_bytes: \(error.localizedDescription)")
+                return NSNull()
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_write_text") { args in
+            self.clearError()
+            guard args.count >= 2,
+                  let path = args[0].toString(),
+                  let data = args[1].toString() else {
+                self.setError("fs_write_text: missing args")
+                return false
+            }
+            do {
+                try data.write(toFile: path, atomically: true, encoding: .utf8)
+                return true
+            } catch {
+                self.setError("fs_write_text: \(error.localizedDescription)")
+                return false
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_write_bytes") { args in
+            self.clearError()
+            guard args.count >= 2,
+                  let path = args[0].toString(),
+                  let bytes = args[1].toData() else {
+                self.setError("fs_write_bytes: missing args")
+                return false
+            }
+            do {
+                try bytes.write(to: URL(fileURLWithPath: path), options: .atomic)
+                return true
+            } catch {
+                self.setError("fs_write_bytes: \(error.localizedDescription)")
+                return false
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_append_text") { args in
+            self.clearError()
+            guard args.count >= 2,
+                  let path = args[0].toString(),
+                  let data = args[1].toString() else {
+                self.setError("fs_append_text: missing args")
+                return false
+            }
+            return self.appendText(path: path, text: data)
+        }
+
+        ctx.installBridgeFunction(name: "fs_exists") { args in
+            self.clearError()
+            guard let path = args.first?.toString() else { return false }
+            return fm.fileExists(atPath: path)
+        }
+
+        ctx.installBridgeFunction(name: "fs_mkdir") { args in
+            self.clearError()
+            guard args.count >= 2,
+                  let path = args[0].toString() else {
+                self.setError("fs_mkdir: missing args")
+                return false
+            }
+            let recursive = args[1].toBool()
+            do {
+                try fm.createDirectory(
+                    atPath: path,
+                    withIntermediateDirectories: recursive,
+                    attributes: nil
+                )
+                return true
+            } catch {
+                self.setError("fs_mkdir: \(error.localizedDescription)")
+                return false
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_readdir") { args in
+            self.clearError()
+            guard let path = args.first?.toString() else {
+                self.setError("fs_readdir: missing path")
+                return NSNull()
+            }
+            do {
+                let entries = try fm.contentsOfDirectory(atPath: path)
+                return entries
+            } catch {
+                self.setError("fs_readdir: \(error.localizedDescription)")
+                return NSNull()
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_stat") { args in
+            self.clearError()
+            guard let path = args.first?.toString() else {
+                self.setError("fs_stat: missing path")
+                return NSNull()
+            }
+            do {
+                let attrs = try fm.attributesOfItem(atPath: path)
+                let size = (attrs[.size] as? NSNumber)?.intValue ?? 0
+                let mtimeDate = attrs[.modificationDate] as? Date
+                let mtimeMs = (mtimeDate?.timeIntervalSince1970 ?? 0) * 1000.0
+                let type = attrs[.type] as? FileAttributeType
+                let isDir = (type == .typeDirectory)
+                let isFile = (type == .typeRegular)
+                return [
+                    "size": size,
+                    "mtime_ms": mtimeMs,
+                    "is_directory": isDir,
+                    "is_file": isFile,
+                ] as [String: Any]
+            } catch {
+                self.setError("fs_stat: \(error.localizedDescription)")
+                return NSNull()
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_remove") { args in
+            self.clearError()
+            guard let path = args.first?.toString() else {
+                self.setError("fs_remove: missing path")
+                return false
+            }
+            // `recursive` is an opt-in flag in the contract. FileManager
+            // removeItem already recurses for directories, but if the caller
+            // explicitly passes `false` for a directory we refuse so the
+            // semantics match POSIX rm-vs-rm-rf.
+            let recursive: Bool = args.count >= 2 ? args[1].toBool() : true
+            var isDir: ObjCBool = false
+            let exists = fm.fileExists(atPath: path, isDirectory: &isDir)
+            if !exists {
+                return true
+            }
+            if isDir.boolValue && !recursive {
+                self.setError("fs_remove: path is a directory and recursive=false")
+                return false
+            }
+            do {
+                try fm.removeItem(atPath: path)
+                return true
+            } catch {
+                self.setError("fs_remove: \(error.localizedDescription)")
+                return false
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_rename") { args in
+            self.clearError()
+            guard args.count >= 2,
+                  let from = args[0].toString(),
+                  let to = args[1].toString() else {
+                self.setError("fs_rename: missing args")
+                return false
+            }
+            do {
+                try fm.moveItem(atPath: from, toPath: to)
+                return true
+            } catch {
+                self.setError("fs_rename: \(error.localizedDescription)")
+                return false
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_copy") { args in
+            self.clearError()
+            guard args.count >= 2,
+                  let from = args[0].toString(),
+                  let to = args[1].toString() else {
+                self.setError("fs_copy: missing args")
+                return false
+            }
+            do {
+                if fm.fileExists(atPath: to) {
+                    try fm.removeItem(atPath: to)
+                }
+                try fm.copyItem(atPath: from, toPath: to)
+                return true
+            } catch {
+                self.setError("fs_copy: \(error.localizedDescription)")
+                return false
+            }
+        }
+
+        ctx.installBridgeFunction(name: "fs_last_error") { _ in
+            return self.lastError ?? NSNull()
+        }
+    }
+
+    // MARK: - Internals
+
+    private func setError(_ message: String) {
+        self.lastError = message
+    }
+
+    private func clearError() {
+        self.lastError = nil
+    }
+
+    /// Appends UTF-8 text to a file, creating it if missing. Returns false
+    /// on failure and stashes a message in `lastError`.
+    private func appendText(path: String, text: String) -> Bool {
+        let fm = FileManager.default
+        if !fm.fileExists(atPath: path) {
+            do {
+                try text.write(toFile: path, atomically: true, encoding: .utf8)
+                return true
+            } catch {
+                setError("fs_append_text: \(error.localizedDescription)")
+                return false
+            }
+        }
+        guard let handle = FileHandle(forWritingAtPath: path),
+              let bytes = text.data(using: .utf8) else {
+            setError("fs_append_text: could not open file for writing")
+            return false
+        }
+        defer { try? handle.close() }
+        do {
+            try handle.seekToEnd()
+            try handle.write(contentsOf: bytes)
+            return true
+        } catch {
+            setError("fs_append_text: \(error.localizedDescription)")
+            return false
+        }
+    }
+}

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

@@ -0,0 +1,153 @@
+import Foundation
+import JavaScriptCore
+
+/// Implements `http_fetch` from `BRIDGE_CONTRACT.md`.
+///
+/// Returns a JS Promise via the constructor pattern: the bridge captures the
+/// resolve callback as a `ManagedCallback`, runs the URLSession request off
+/// the JSContext queue, then re-enters the JSContext queue to fulfill the
+/// promise.
+public final class HTTPBridge {
+    private weak var context: JSContext?
+    private let urlSession: URLSession
+
+    public init(session: URLSession = .shared) {
+        self.urlSession = session
+    }
+
+    public func install(into ctx: JSContext) {
+        self.context = ctx
+
+        ctx.installBridgeFunction(name: "http_fetch") { args in
+            guard let ctx = self.context else { return NSNull() }
+            guard let opts = args.first, opts.isObject else {
+                return Self.rejectedPromise(in: ctx, error: "http_fetch: missing options")
+            }
+
+            let url = opts.objectForKeyedSubscript("url")?.toString() ?? ""
+            let method = (opts.objectForKeyedSubscript("method")?.toString() ?? "GET").uppercased()
+            let headers = opts.objectForKeyedSubscript("headers")?.toStringMap() ?? [:]
+            let bodyValue = opts.objectForKeyedSubscript("body")
+            let body: Data? = (bodyValue?.isNullish == false) ? bodyValue?.toData() : nil
+            let timeoutMs = opts.objectForKeyedSubscript("timeout_ms")?.toNumber()?.doubleValue
+
+            guard let target = URL(string: url) else {
+                return Self.rejectedPromise(in: ctx, error: "http_fetch: invalid url")
+            }
+            guard target.scheme == "http" || target.scheme == "https" else {
+                return Self.rejectedPromise(in: ctx, error: "http_fetch: unsupported URL scheme")
+            }
+            if Self.isLocalOrPrivateNetwork(target) {
+                return Self.rejectedPromise(in: ctx, error: "http_fetch: loopback/private URLs must use path-only http_request IPC")
+            }
+
+            var request = URLRequest(url: target)
+            request.httpMethod = method
+            for (k, v) in headers {
+                request.setValue(v, forHTTPHeaderField: k)
+            }
+            if let body = body, method != "GET", method != "HEAD" {
+                request.httpBody = body
+            }
+            if let ms = timeoutMs, ms > 0 {
+                request.timeoutInterval = ms / 1000.0
+            }
+
+            return self.runFetch(ctx: ctx, request: request)
+        }
+    }
+
+    // MARK: - Internals
+
+    private func runFetch(ctx: JSContext, request: URLRequest) -> Any? {
+        // Build the promise factory once.
+        let promiseScript = """
+        (function(){
+          let resolveFn;
+          const p = new Promise(function(res){ resolveFn = res; });
+          p.__eliza_resolve = resolveFn;
+          return p;
+        })
+        """
+        guard let promise = ctx.evaluateScript(promiseScript)?.call(withArguments: []) else {
+            return Self.rejectedPromise(in: ctx, error: "http_fetch: failed to construct promise")
+        }
+        let resolveValue = promise.forProperty("__eliza_resolve")
+        let managedResolve = resolveValue.flatMap { ManagedCallback(value: $0) }
+
+        let task = urlSession.dataTask(with: request) { data, response, error in
+            let result = Self.buildResultDict(data: data, response: response, error: error, ctx: ctx)
+            // Hop back onto the JS queue.
+            RuntimeQueue.dispatchOnJS {
+                guard let resolve = managedResolve else { return }
+                resolve.callSync(args: [result])
+            }
+        }
+        task.resume()
+
+        return promise
+    }
+
+    private static func isLocalOrPrivateNetwork(_ url: URL) -> Bool {
+        guard let host = url.host?.lowercased() else { return false }
+        return host == "localhost" ||
+            host == "127.0.0.1" ||
+            host == "0.0.0.0" ||
+            host == "::1" ||
+            host.hasPrefix("127.") ||
+            host.hasPrefix("10.") ||
+            host.hasPrefix("192.168.") ||
+            host.range(of: #"^172\.(1[6-9]|2[0-9]|3[0-1])\."#, options: .regularExpression) != nil ||
+            host.range(of: #"^100\.(6[4-9]|[7-9][0-9]|1[0-1][0-9]|12[0-7])\."#, options: .regularExpression) != nil ||
+            host.hasPrefix("169.254.") ||
+            (host.contains(":") &&
+                (host.hasPrefix("fe80:") ||
+                    host.hasPrefix("fc") ||
+                    host.hasPrefix("fd"))) ||
+            host == "local" ||
+            host == "internal" ||
+            host == "lan" ||
+            host == "ts.net" ||
+            host.hasSuffix(".local") ||
+            host.hasSuffix(".internal") ||
+            host.hasSuffix(".lan") ||
+            host.hasSuffix(".ts.net")
+    }
+
+    private static func buildResultDict(data: Data?, response: URLResponse?, error: Error?, ctx: JSContext) -> [String: Any] {
+        if let error = error {
+            return [
+                "status": 0,
+                "headers": [:] as [String: String],
+                "body": ctx.newUint8Array(Data()),
+                "error": error.localizedDescription,
+            ]
+        }
+        guard let http = response as? HTTPURLResponse else {
+            return [
+                "status": 0,
+                "headers": [:] as [String: String],
+                "body": ctx.newUint8Array(Data()),
+                "error": "Non-HTTP response",
+            ]
+        }
+        var headerDict: [String: String] = [:]
+        for (k, v) in http.allHeaderFields {
+            guard let key = k as? String else { continue }
+            headerDict[key.lowercased()] = String(describing: v)
+        }
+        let payload = data ?? Data()
+        return [
+            "status": http.statusCode,
+            "headers": headerDict,
+            "body": ctx.newUint8Array(payload),
+        ]
+    }
+
+    private static func rejectedPromise(in ctx: JSContext, error: String) -> Any? {
+        // Promise.resolve({ error }) per contract — async errors are returned,
+        // not thrown.
+        let script = "(function(msg){return Promise.resolve({status:0,headers:{},body:new Uint8Array(),error:msg});})"
+        return ctx.evaluateScript(script)?.call(withArguments: [error])
+    }
+}

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

@@ -0,0 +1,32 @@
+import Foundation
+import JavaScriptCore
+
+/// Compatibility registration for the old `http_serve_*` bridge surface.
+///
+/// iOS local mode must route foreground and backend calls through Capacitor /
+/// engine IPC (`ElizaBunRuntime.call("http_request", ...)`) instead of opening
+/// a localhost listener inside the app. Keeping these symbols registered gives
+/// older JSContext bundles a deterministic error without ever binding a port.
+public final class HTTPServerBridge {
+    public init() {}
+
+    public func install(into ctx: JSContext) {
+        ctx.installBridgeFunction(name: "http_serve_start") { _ in
+            [
+                "ok": false,
+                "port": 0,
+                "error": "http_serve_start is disabled on iOS; use ElizaBunRuntime.call(http_request) IPC",
+            ]
+        }
+
+        ctx.installBridgeFunction(name: "http_serve_register_handler") { _ in
+            NSNull()
+        }
+
+        ctx.installBridgeFunction(name: "http_serve_stop") { _ in
+            NSNull()
+        }
+    }
+
+    public func shutdown() {}
+}

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

@@ -0,0 +1,233 @@
+import Foundation
+import JavaScriptCore
+
+#if canImport(LlamaCppCapacitor)
+import LlamaCppCapacitor
+#endif
+
+/// Implements `llama_*` from `BRIDGE_CONTRACT.md`.
+///
+/// `LlamaBridgeImpl` is JSContext-agnostic by design: this file owns JSValue
+/// parsing, promise wiring, and ManagedCallback streaming; the impl owns the
+/// llama.cpp C API calls. Bridge failures resolve as `{ error }` values
+/// because the JS polyfill layer treats bridge results as native response
+/// payloads rather than exception channels.
+public final class LlamaBridge {
+    private weak var context: JSContext?
+    private var nextContextId: Int = 1
+    private var contexts: [Int: LlamaContextState] = [:]
+    private var streamCallbacks: [String: ManagedCallback] = [:]
+    private let inferenceQueue = DispatchQueue(label: "ai.eliza.bun.runtime.llama", qos: .userInitiated)
+
+    public init() {}
+
+    public func install(into ctx: JSContext) {
+        self.context = ctx
+
+        ctx.installBridgeFunction(name: "llama_load_model") { args in
+            guard let ctx = self.context else { return NSNull() }
+            return self.loadModel(args: args, ctx: ctx)
+        }
+
+        ctx.installBridgeFunction(name: "llama_generate") { args in
+            guard let ctx = self.context else { return NSNull() }
+            return self.generate(args: args, ctx: ctx)
+        }
+
+        ctx.installBridgeFunction(name: "llama_register_stream_callback") { args in
+            guard args.count >= 2,
+                  let token = args[0].toString() else { return NSNull() }
+            let handlerValue = args[1]
+            if let mc = ManagedCallback(value: handlerValue) {
+                self.streamCallbacks[token] = mc
+            }
+            return NSNull()
+        }
+
+        ctx.installBridgeFunction(name: "llama_cancel") { args in
+            guard let id = args.first?.toNumber()?.intValue else { return NSNull() }
+            if var state = self.contexts[id] {
+                state.cancelled = true
+                self.contexts[id] = state
+            }
+            LlamaBridgeImpl.shared.cancel(contextId: Int64(id))
+            return NSNull()
+        }
+
+        ctx.installBridgeFunction(name: "llama_free") { args in
+            guard let id = args.first?.toNumber()?.intValue else { return NSNull() }
+            self.contexts.removeValue(forKey: id)
+            LlamaBridgeImpl.shared.free(contextId: Int64(id))
+            return NSNull()
+        }
+
+        ctx.installBridgeFunction(name: "llama_hardware_info") { _ in
+            return self.hardwareInfo()
+        }
+    }
+
+    // MARK: - Context state
+
+    private struct LlamaContextState {
+        let id: Int
+        let modelPath: String
+        var contextSize: Int
+        var useGpu: Bool
+        var threads: Int
+        var cancelled: Bool
+    }
+
+    // MARK: - Implementations
+
+    private func loadModel(args: [JSValue], ctx: JSContext) -> Any? {
+        guard let opts = args.first, opts.isObject else {
+            return Self.rejectedAsync(in: ctx, error: "llama_load_model: missing options")
+        }
+        let path = opts.objectForKeyedSubscript("path")?.toString() ?? ""
+        if path.isEmpty {
+            return Self.rejectedAsync(in: ctx, error: "llama_load_model: missing path")
+        }
+        let contextSize = opts.objectForKeyedSubscript("context_size")?.toNumber()?.intValue ?? 4096
+        let useGpu = opts.objectForKeyedSubscript("use_gpu")?.toBool() ?? true
+        let threads = opts.objectForKeyedSubscript("threads")?.toNumber()?.intValue
+            ?? min(4, ProcessInfo.processInfo.activeProcessorCount)
+
+        // Build the promise + resolver pair on the JS side.
+        let (promise, resolver) = Self.makeAsyncPromise(in: ctx)
+        let managedResolve = resolver.flatMap { ManagedCallback(value: $0) }
+
+        inferenceQueue.async { [weak self] in
+            guard let self = self else { return }
+
+            if !FileManager.default.fileExists(atPath: path) {
+                RuntimeQueue.dispatchOnJS {
+                    managedResolve?.callSync(args: [["error": "model file not found: \(path)"]])
+                }
+                return
+            }
+
+            let result = LlamaBridgeImpl.shared.loadModel(
+                path: path,
+                contextSize: UInt32(max(1, contextSize)),
+                useGPU: useGpu,
+                threads: Int32(max(1, threads))
+            )
+            if let error = result.error {
+                RuntimeQueue.dispatchOnJS {
+                    managedResolve?.callSync(args: [["error": error]])
+                }
+                return
+            }
+            guard let contextId = result.contextId else {
+                RuntimeQueue.dispatchOnJS {
+                    managedResolve?.callSync(args: [["error": "llama_load_model: backend returned no context_id"]])
+                }
+                return
+            }
+
+            let id = Int(contextId)
+            self.nextContextId = max(self.nextContextId, id + 1)
+            self.contexts[id] = LlamaContextState(
+                id: id,
+                modelPath: path,
+                contextSize: contextSize,
+                useGpu: useGpu,
+                threads: threads,
+                cancelled: false
+            )
+
+            RuntimeQueue.dispatchOnJS {
+                managedResolve?.callSync(args: [["context_id": id]])
+            }
+        }
+
+        return promise
+    }
+
+    private func generate(args: [JSValue], ctx: JSContext) -> Any? {
+        guard let opts = args.first, opts.isObject else {
+            return Self.rejectedAsync(in: ctx, error: "llama_generate: missing options")
+        }
+        let contextId = opts.objectForKeyedSubscript("context_id")?.toNumber()?.intValue ?? -1
+        let prompt = opts.objectForKeyedSubscript("prompt")?.toString() ?? ""
+        let maxTokens = opts.objectForKeyedSubscript("max_tokens")?.toNumber()?.intValue ?? 256
+        let temperature = opts.objectForKeyedSubscript("temperature")?.toNumber()?.doubleValue ?? 0.7
+        let topP = opts.objectForKeyedSubscript("top_p")?.toNumber()?.doubleValue ?? 0.95
+        let stop = opts.objectForKeyedSubscript("stop")?.toStringArray() ?? []
+        let streamToken = opts.objectForKeyedSubscript("stream_callback_token")?.toString()
+
+        guard let state = contexts[contextId] else {
+            return Self.rejectedAsync(in: ctx, error: "llama_generate: unknown context_id \(contextId)")
+        }
+
+        let (promise, resolver) = Self.makeAsyncPromise(in: ctx)
+        let managedResolve = resolver.flatMap { ManagedCallback(value: $0) }
+        let streamCallback = streamToken.flatMap { self.streamCallbacks[$0] }
+
+        let queue = LlamaBridgeImpl.shared.workQueue(for: Int64(contextId)) ?? inferenceQueue
+        queue.async {
+            let started = Date()
+            let result = LlamaBridgeImpl.shared.generate(
+                contextId: Int64(state.id),
+                prompt: prompt,
+                maxTokens: Int32(max(1, maxTokens)),
+                temperature: Float(temperature),
+                topP: Float(topP),
+                stopSequences: stop,
+                onToken: { token, isLast in
+                    guard let cb = streamCallback else { return }
+                    RuntimeQueue.dispatchOnJS {
+                        cb.callSync(args: [token, isLast])
+                    }
+                }
+            )
+
+            let durationMs = Int(Date().timeIntervalSince(started) * 1000)
+            let promptTokens = max(1, result.promptTokens)
+            let outputTokens = max(1, result.outputTokens)
+
+            RuntimeQueue.dispatchOnJS {
+                if let error = result.error {
+                    managedResolve?.callSync(args: [["error": error]])
+                    return
+                }
+                managedResolve?.callSync(args: [[
+                    "text": result.text,
+                    "prompt_tokens": promptTokens,
+                    "output_tokens": outputTokens,
+                    "duration_ms": Int(result.durationMs > 0 ? result.durationMs : Double(durationMs)),
+                ]])
+            }
+        }
+
+        return promise
+    }
+
+    private func hardwareInfo() -> [String: Any] {
+        return LlamaBridgeImpl.shared.hardwareInfo().asDict()
+    }
+
+    // MARK: - Promise builders
+
+    /// Returns `(promise, resolver)`. The resolver is a JS function value.
+    static func makeAsyncPromise(in ctx: JSContext) -> (Any, JSValue?) {
+        let script = """
+        (function(){
+          let resolveFn;
+          const p = new Promise(function(res){ resolveFn = res; });
+          p.__eliza_resolve = resolveFn;
+          return p;
+        })
+        """
+        guard let promise = ctx.evaluateScript(script)?.call(withArguments: []) else {
+            return (NSNull(), nil)
+        }
+        let resolver = promise.forProperty("__eliza_resolve")
+        return (promise, resolver)
+    }
+
+    static func rejectedAsync(in ctx: JSContext, error: String) -> Any? {
+        let script = "(function(msg){return Promise.resolve({error:msg});})"
+        return ctx.evaluateScript(script)?.call(withArguments: [error])
+    }
+}