akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/native/ios/Sources/AkanNativeUpdates.swift

@@ -0,0 +1,270 @@
+// Web bundle updates (UP-2): which bundle the shell serves, and the trial / confirm / rollback
+// state. @akanjs/native/plugins/updates downloads and verifies bundles and calls stage/apply/confirm; the
+// shell picks the bundle at launch (`launch`) and rolls back a trial that never confirms.
+//
+// Layout: Library/Application Support/akan-native-updates/{state.json, bundles/<bundle>/{…, manifest.json,
+// manifest.json.sig}} (the filesystem plugin's `data` is Application Support/files). A bundle is
+// served only while its signed manifest still verifies and its files are all there with their
+// sizes (checked at every launch).
+// state.json: { current?, pending?, trial?, failed: [bundle], rolledBack? } with entries
+// { bundle, sequence, nativeApi, attempts? }.
+// - A downloaded bundle is `pending`. At the next launch (or apply()) it becomes `trial` with one
+//   attempt. notifyReady() makes the trial `current`. A trial that is launched again without
+//   having confirmed (it crashed or hung) is marked failed and the previous bundle serves.
+// - Anything built for another native API (UP-3) or older than the binary's own bundle
+//   (embeddedSequence in updates.json) is dropped: Capacitor's "new binary resets the live
+//   update" rule (CAPBridgeViewController.swift:18-29, 327-339), keyed on the fingerprint.
+// - Nothing is deleted before the new bundle confirmed (Electrobun removes .previous as soon as
+//   the new app launched, electrobun/package/src/extractor/main.zig:7811-7818).
+
+// Compiled only when the app has updates (a config or the plugin): akan-native passes -D AKAN_NATIVE_UPDATES
+// (architecture review stage 6, optional features are compiled only when used).
+#if AKAN_NATIVE_UPDATES
+import CryptoKit
+import Foundation
+
+struct AkanNativeUpdateEntry: Equatable, Sendable {
+    var bundle: String
+    var sequence: Double
+    var nativeApi: String
+    var attempts: Int = 0
+
+    init(bundle: String, sequence: Double, nativeApi: String, attempts: Int = 0) {
+        self.bundle = bundle
+        self.sequence = sequence
+        self.nativeApi = nativeApi
+        self.attempts = attempts
+    }
+
+    init?(_ json: Any?) {
+        guard let o = json as? [String: Any], let bundle = o["bundle"] as? String, AkanNativeUpdates.isBundleId(bundle),
+              let sequence = (o["sequence"] as? NSNumber)?.doubleValue, let nativeApi = o["nativeApi"] as? String else { return nil }
+        self.init(bundle: bundle, sequence: sequence, nativeApi: nativeApi, attempts: (o["attempts"] as? NSNumber)?.intValue ?? 0)
+    }
+
+    var json: [String: Any] { ["bundle": bundle, "sequence": sequence, "nativeApi": nativeApi, "attempts": attempts] }
+}
+
+struct AkanNativeUpdateState: Sendable {
+    var current: AkanNativeUpdateEntry?
+    var pending: AkanNativeUpdateEntry?
+    var trial: AkanNativeUpdateEntry?
+    var failed: [String] = []
+    var rolledBack: String?
+
+    init() {}
+
+    init(_ o: [String: Any]) {
+        current = AkanNativeUpdateEntry(o["current"])
+        pending = AkanNativeUpdateEntry(o["pending"])
+        trial = AkanNativeUpdateEntry(o["trial"])
+        failed = (o["failed"] as? [String] ?? []).filter(AkanNativeUpdates.isBundleId)
+        rolledBack = o["rolledBack"] as? String
+    }
+
+    var json: [String: Any] {
+        var o: [String: Any] = ["failed": Array(failed.suffix(20))]
+        if let current { o["current"] = current.json }
+        if let pending { o["pending"] = pending.json }
+        if let trial { o["trial"] = trial.json }
+        if let rolledBack { o["rolledBack"] = rolledBack }
+        return o
+    }
+}
+
+/// updates.json from the build (akan-native.config.ts `updates`), nil when the app has no updates.
+struct AkanNativeUpdateConfig: Sendable {
+    let app: String
+    let platform: String
+    let nativeApi: String
+    let embeddedSequence: Double
+    let url: String
+    let publicKey: Data
+    let channel: String
+    let readyTimeout: TimeInterval
+    let dev: Bool
+
+    static func load() -> AkanNativeUpdateConfig? {
+        let o = AkanNativeResources.json("updates.json")
+        guard let app = o["app"] as? String, let url = o["url"] as? String, let key = (o["publicKey"] as? String).flatMap({ Data(base64Encoded: $0) }), key.count == 32,
+              let nativeApi = o["nativeApi"] as? String else { return nil }
+        return AkanNativeUpdateConfig(
+            app: app,
+            platform: o["platform"] as? String ?? "ios",
+            nativeApi: nativeApi,
+            embeddedSequence: (o["embeddedSequence"] as? NSNumber)?.doubleValue ?? 0,
+            url: url,
+            publicKey: key,
+            channel: o["channel"] as? String ?? "production",
+            readyTimeout: ((o["readyTimeout"] as? NSNumber)?.doubleValue ?? 10_000) / 1000,
+            dev: o["dev"] as? Bool ?? false
+        )
+    }
+}
+
+@MainActor
+enum AkanNativeUpdates {
+    static let config = AkanNativeUpdateConfig.load()
+    /// The bundle served in this session (nil: the one inside the app).
+    private(set) static var active: AkanNativeUpdateEntry?
+    /// The served bundle has not confirmed yet (notifyReady), so the ready timer runs.
+    private(set) static var onTrial = false
+
+    nonisolated static func isBundleId(_ s: String) -> Bool { AkanNativeKernel.isBundleId(s) }
+
+    nonisolated static var directory: URL {
+        let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        return base.appendingPathComponent("akan-native-updates", isDirectory: true)
+    }
+
+    nonisolated static func bundleDirectory(_ bundle: String) -> URL {
+        directory.appendingPathComponent("bundles", isDirectory: true).appendingPathComponent(bundle, isDirectory: true)
+    }
+
+    static func readState() -> AkanNativeUpdateState {
+        guard let data = try? Data(contentsOf: directory.appendingPathComponent("state.json")),
+              let o = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return AkanNativeUpdateState() }
+        return AkanNativeUpdateState(o)
+    }
+
+    /// Atomic replace (write + rename), so a crash never leaves half a state file. false: not
+    /// written (a full disk): a trial that is not on record must not run, since nothing would roll
+    /// it back.
+    @discardableResult
+    static func writeState(_ state: AkanNativeUpdateState) -> Bool {
+        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        var url = directory
+        var values = URLResourceValues()
+        values.isExcludedFromBackup = true // downloadable again; not the user's data
+        try? url.setResourceValues(values)
+        guard let data = try? JSONSerialization.data(withJSONObject: state.json, options: [.sortedKeys]) else { return false }
+        do {
+            try data.write(to: directory.appendingPathComponent("state.json"), options: .atomic)
+            return true
+        } catch {
+            NSLog("[akan-native] updates: cannot write state.json: %@", error.localizedDescription)
+            return false
+        }
+    }
+
+    /// Whether a bundle may run in this binary.
+    static func usable(_ entry: AkanNativeUpdateEntry?, _ config: AkanNativeUpdateConfig) -> Bool {
+        guard let entry else { return false }
+        return entry.nativeApi == config.nativeApi && entry.sequence > config.embeddedSequence
+            && FileManager.default.fileExists(atPath: bundleDirectory(entry.bundle).appendingPathComponent("index.html").path)
+            && verified(entry, config)
+    }
+
+    /// The bundle's signed manifest (kept next to it by the plugin) verifies, describes this entry,
+    /// and every file it lists is there with its size. The hashes were checked at the download.
+    private static func verified(_ entry: AkanNativeUpdateEntry, _ config: AkanNativeUpdateConfig) -> Bool {
+        let dir = bundleDirectory(entry.bundle)
+        guard let manifest = try? Data(contentsOf: dir.appendingPathComponent("manifest.json")),
+              let sigText = try? String(contentsOf: dir.appendingPathComponent("manifest.json.sig"), encoding: .utf8),
+              let signature = Data(base64Encoded: sigText.trimmingCharacters(in: .whitespacesAndNewlines)),
+              let key = try? Curve25519.Signing.PublicKey(rawRepresentation: config.publicKey),
+              key.isValidSignature(signature, for: manifest),
+              let o = try? JSONSerialization.jsonObject(with: manifest) as? [String: Any],
+              o["bundle"] as? String == entry.bundle, (o["sequence"] as? NSNumber)?.doubleValue == entry.sequence,
+              o["nativeApi"] as? String == entry.nativeApi, o["app"] as? String == config.app, o["platform"] as? String == config.platform,
+              let files = o["files"] as? [[String: Any]] else { return false }
+        return files.allSatisfy { f in
+            guard let path = f["path"] as? String, let size = (f["size"] as? NSNumber)?.intValue,
+                  let attributes = try? FileManager.default.attributesOfItem(atPath: dir.appendingPathComponent(path).path) else { return false }
+            return attributes[.type] as? FileAttributeType == .typeRegular && (attributes[.size] as? NSNumber)?.intValue == size
+        }
+    }
+
+    /// Picks the bundle for this launch (called once, before the web view loads) and returns its
+    /// folder, or nil for the bundle inside the app.
+    static func launch() -> URL? {
+        guard let config else { return nil }
+        var state = readState()
+        if !usable(state.current, config) { state.current = nil }
+        if !usable(state.pending, config) { state.pending = nil }
+        if !usable(state.trial, config) { state.trial = nil }
+        if let trial = state.trial {
+            // Launched again without notifyReady(): the trial crashed or hung.
+            state.failed.append(trial.bundle)
+            state.rolledBack = trial.bundle
+            state.trial = nil
+            NSLog("[akan-native] updates: bundle %@ did not confirm; rolled back", trial.bundle)
+        }
+        if var pending = state.pending, !state.failed.contains(pending.bundle) {
+            pending.attempts = 1
+            state.trial = pending
+            state.pending = nil
+        }
+        if !writeState(state), state.trial != nil {
+            state.trial = nil // not on record: the pending bundle waits for a launch that can record it
+        }
+        active = state.trial ?? state.current
+        onTrial = state.trial != nil
+        return active.map { bundleDirectory($0.bundle) }
+    }
+
+    /// A verified download (plugin): runs at the next launch, or right away through apply().
+    static func stage(_ entry: AkanNativeUpdateEntry) {
+        var state = readState()
+        state.pending = entry
+        state.failed.removeAll { $0 == entry.bundle }
+        writeState(state)
+    }
+
+    /// apply(): makes the pending bundle the trial now; returns its folder for the reload.
+    static func applyPending() -> URL? {
+        guard let config else { return nil }
+        var state = readState()
+        guard var pending = state.pending, usable(pending, config) else { return nil }
+        pending.attempts = 1
+        state.trial = pending
+        state.pending = nil
+        guard writeState(state) else { return nil }
+        active = pending
+        onTrial = true
+        return bundleDirectory(pending.bundle)
+    }
+
+    /// notifyReady(): the served trial becomes current; bundles nothing refers to are removed.
+    static func confirm() {
+        guard onTrial, let trial = active else { return }
+        var state = readState()
+        guard state.trial?.bundle == trial.bundle else { return }
+        state.current = AkanNativeUpdateEntry(bundle: trial.bundle, sequence: trial.sequence, nativeApi: trial.nativeApi)
+        state.trial = nil
+        state.rolledBack = nil
+        writeState(state)
+        onTrial = false
+        prune(keep: [state.current?.bundle, state.pending?.bundle].compactMap { $0 })
+    }
+
+    /// The trial did not confirm in time: back to the previous bundle. Returns its folder (nil: the app's own).
+    static func rollback() -> URL? {
+        guard onTrial, let trial = active else { return active.map { bundleDirectory($0.bundle) } }
+        var state = readState()
+        state.trial = nil
+        state.failed.append(trial.bundle)
+        state.rolledBack = trial.bundle
+        writeState(state)
+        onTrial = false
+        active = config.flatMap { usable(state.current, $0) ? state.current : nil }
+        NSLog("[akan-native] updates: bundle %@ did not call notifyReady() in time; rolled back", trial.bundle)
+        return active.map { bundleDirectory($0.bundle) }
+    }
+
+    /// reset(): the app's own bundle from the next launch on.
+    static func reset() {
+        writeState(AkanNativeUpdateState())
+        prune(keep: active.map { [$0.bundle] } ?? [])
+    }
+
+    /// A download in progress (bundles/<bundle>.partial) is the plugin's, which removes it.
+    private static func prune(keep: [String]) {
+        let folder = directory.appendingPathComponent("bundles", isDirectory: true)
+        guard let names = try? FileManager.default.contentsOfDirectory(atPath: folder.path) else { return }
+        for name in names where !keep.contains(name) && name != active?.bundle && !name.hasSuffix(".partial") {
+            try? FileManager.default.removeItem(at: folder.appendingPathComponent(name))
+        }
+    }
+}
+#endif

package/vendor/@akanjs/native/native/ios/Sources/AkanNativeVectors.swift

@@ -0,0 +1,155 @@
+// Runs the shared vectors (packages/core/vectors) against this host's kernel (AkanNativeKernel,
+// AkanNativeGlob): on the Mac through scripts/native-vectors.ts, on the device through the dev-only
+// $host.vectors of the self-test. AkanNativeVectorData is generated per build, empty in release builds.
+
+// Dev builds only (-D AKAN_NATIVE_DEV): the self-test's $host.vectors and scripts/native-vectors.ts.
+#if AKAN_NATIVE_DEV
+import CryptoKit
+import Foundation
+
+enum AkanNativeVectors {
+    /// How many cases passed, and a line for each that did not.
+    static func run() -> (passed: Int, failures: [String]) {
+        var passed = 0
+        var failures: [String] = []
+        var ran: [String: Int] = [:]
+        var current = ""
+        func check(_ ok: Bool, _ what: @autoclosure () -> String) {
+            ran[current, default: 0] += 1
+            if ok { passed += 1 } else { failures.append(what()) }
+        }
+        func load(_ name: String) -> [String: Any] {
+            current = name
+            guard let text = AkanNativeVectorData.files[name], let o = try? JSONSerialization.jsonObject(with: Data(text.utf8)) as? [String: Any] else { return [:] }
+            return o
+        }
+        func rows(_ o: [String: Any], _ key: String) -> [[Any]] { o[key] as? [[Any]] ?? [] }
+        func str(_ v: Any) -> String? { v as? String }
+
+        let scope = load("scope")
+        for c in rows(scope, "glob") {
+            let mode = c[2] as? String
+            check(AkanNativeGlob.match(c[0] as! String, c[1] as! String, path: mode != "plain", deny: mode == "path-deny") == c[3] as? Bool, "glob \(c)")
+        }
+        for c in rows(scope, "permits") {
+            let s = c[0] as! [String: Any]
+            let entries = { (v: Any?) in (v as? [[String: String]]) }
+            let scope = AkanNativeScope(allow: entries(s["allow"]), deny: entries(s["deny"]) ?? [])
+            let ok = scope.permits(c[1] as! [String: String], pathFields: Set(c[2] as! [String]), urlFields: Set(c[3] as! [String]), fold: c[4] as! Bool)
+            check(ok == c[5] as? Bool, "permits \(c)")
+        }
+        for c in rows(scope, "url") {
+            check(AkanNativeGlob.url(c[0] as! String, c[1] as! String, deny: c[2] as? String == "deny") == c[3] as? Bool, "url \(c)")
+        }
+
+        let routes = load("routes")
+        let files = Set(routes["files"] as? [String] ?? [])
+        for c in rows(routes, "cases") {
+            let all = c[1] as? String == "all"
+            let got: (String, String?) = switch AkanNativeKernel.route(c[0] as! String, exists: { all || files.contains($0) }) {
+            case .initScript: ("init", nil)
+            case .ipc: ("ipc", nil)
+            case .hello: ("hello", nil)
+            case .file(let id): ("file", id)
+            case .asset(let path): ("asset", path)
+            case .notFound: ("not-found", nil)
+            }
+            check(got.0 == c[2] as? String && got.1 == str(c[3]), "route \(c): \(got)")
+        }
+        for c in rows(routes, "hostPaths") {
+            check(AkanNativeKernel.isHostPath(c[0] as! String) == c[1] as? Bool, "host path \(c)")
+        }
+
+        for c in rows(load("ranges"), "cases") {
+            let expected = (c[2] as? [NSNumber] ?? []).map(\.int64Value)
+            let got: [Int64] = switch AkanNativeKernel.parseRange(str(c[0]), size: (c[1] as! NSNumber).int64Value) {
+            case .whole: [200]
+            case .part(let a, let b): [206, a, b]
+            case .unsatisfiable: [416]
+            }
+            check(got == expected, "range \(c): \(got)")
+        }
+
+        let ids = load("ids")
+        let specs = ["fileRef": AkanNativeContract.idFileRef, "bundle": AkanNativeContract.idBundle, "document": AkanNativeContract.idDocument, "name": AkanNativeContract.idName]
+        for c in rows(ids, "cases") {
+            check(AkanNativeKernel.idValid(specs[c[0] as! String]!, c[1] as! String) == c[2] as? Bool, "id \(c)")
+        }
+        for c in rows(ids["mime"] as? [String: Any] ?? [:], "cases") {
+            let path = c[0] as! String
+            check(AkanNativeKernel.assetMime(path) == c[1] as? String && AkanNativeKernel.fileMime(path) == c[2] as? String, "mime \(c): \(AkanNativeKernel.assetMime(path))")
+        }
+
+        let bridge = load("bridge")
+        for c in rows(bridge, "requests") {
+            let request: Any? = c[0] is NSNull ? nil : c[0]
+            let got = AkanNativeKernel.validateRequest(request)
+            check(got == str(c[1]), "request \(c): \(got ?? "nil")")
+        }
+        for c in rows(bridge, "declarations") {
+            let decl: Any? = c[0] is NSNull ? nil : c[0]
+            check(AkanNativeKernel.declares(decl, method: c[1] as! String, event: str(c[2])) == c[3] as? Bool, "declaration \(c)")
+        }
+        for c in rows(bridge, "documents") {
+            let got = AkanNativeKernel.admitDocument(current: str(c[0]), ended: c[1] as? [String] ?? [], requested: str(c[2]))
+            check(got.rawValue == c[3] as? String, "document \(c): \(got.rawValue)")
+        }
+
+        for (i, item) in ((load("acl")["cases"] as? [[String: Any]]) ?? []).enumerated() {
+            let (acl, problem) = AkanNativeAcl.from(item)
+            check((problem != nil) == item["problem"] as? Bool, "acl case \(i): problem \(problem ?? "none")")
+            for c in (item["checks"] as? [[Any]] ?? []) {
+                let (allowed, scope) = acl?.check(plugin: c[0] as! String, item: c[1] as! String, window: (c[2] as! NSNumber).intValue) ?? (true, nil)
+                let expected = c[4] as? [String: Any]
+                let scopeOk = scope == nil ? expected == nil
+                    : (expected?["allow"] is NSNull ? scope!.allow == nil : (scope!.allow.map { $0 as NSArray } == expected?["allow"] as? NSArray))
+                        && (scope!.deny as NSArray) == (expected?["deny"] as? NSArray)
+                check(allowed == c[3] as? Bool && scopeOk, "acl case \(i) \(c): \(allowed) \(String(describing: scope?.allow)) \(String(describing: scope?.deny))")
+            }
+        }
+
+        let navigation = load("navigation")
+        for c in rows(navigation, "cases") {
+            let got = AkanNativeKernel.decideNavigation(c[0] as! String, topLevel: c[1] as! Bool, origin: "app://localhost", extra: c[2] as? [String] ?? [])
+            check(got.rawValue == c[3] as? String, "navigation \(c): \(got.rawValue)")
+        }
+        for c in rows(navigation, "fileRefSandbox") {
+            check(AkanNativeKernel.fileRefSandboxed(c[0] as! String) == c[1] as? Bool, "sandbox \(c)")
+        }
+        for item in (load("retained")["cases"] as? [[String: Any]]) ?? [] {
+            let events = AkanNativeRetained<String>()
+            var log: [String] = []
+            for op in item["ops"] as? [[Any]] ?? [] {
+                let name = op[1] as! String
+                switch op[0] as! String {
+                case "listen":
+                    let accepts = op[2] as! Bool
+                    events.listen(name) { value in
+                        if accepts { log.append("\(name):\(value)") }
+                        return accepts
+                    }
+                case "unlisten": events.unlisten(name)
+                default: events.emit(name, retain: op[2] as! Bool)
+                }
+            }
+            check(log == item["log"] as? [String], "retained \(item["name"] ?? ""): \(log)")
+        }
+        // Ed25519 as web bundle updates verify it on iOS (CryptoKit).
+        for c in rows(load("ed25519"), "cases") {
+            let bytes = { (hex: String) -> Data in Data(stride(from: 0, to: hex.count, by: 2).map { UInt8(hex.dropFirst($0).prefix(2), radix: 16)! }) }
+            let valid = (try? Curve25519.Signing.PublicKey(rawRepresentation: bytes(c[0] as! String)))?.isValidSignature(bytes(c[2] as! String), for: bytes(c[1] as! String)) ?? false
+            check(valid == c[3] as? Bool, "ed25519 \(c[4])")
+        }
+
+        // A missing or truncated file must not pass as fewer checks.
+        for (name, count) in AkanNativeVectorData.counts where ran[name, default: 0] != count {
+            failures.append("\(name): \(ran[name, default: 0]) of \(count) checks ran")
+        }
+        if AkanNativeVectorData.counts.isEmpty { failures.append("no vectors in this build") }
+        return (passed, failures)
+    }
+
+    /// The checks all files hold.
+    static var expected: Int { AkanNativeVectorData.counts.values.reduce(0, +) }
+}
+#endif