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

package/vendor/@akanjs/native/native/android/src/com/akanjs/runtime/AkanNativeUpdates.kt

@@ -0,0 +1,305 @@
+// Web bundle updates (UP-2): which bundle the shell serves, and the trial / confirm / rollback
+// state (the Android twin of native/ios/Sources/AkanNativeUpdates.swift, same rules and file format).
+// @akanjs/native/plugins/updates downloads and verifies bundles and calls stage/applyPending/confirm; the
+// activity picks the bundle at launch and rolls back a trial that never confirms.
+//
+// Layout: noBackupFilesDir/akan-native-updates/{state.json, bundles/<bundle>/{…, manifest.json,
+// manifest.json.sig}}: outside filesDir, which the filesystem plugin's `data` base exposes to the
+// page, and out of backups (bundles download again; state.json belongs to this install). A bundle
+// is served only while its signed manifest still verifies and its files are all there with their
+// sizes (checked at every launch). Main thread only.
+package com.akanjs.runtime
+
+import android.content.Context
+import android.util.AtomicFile
+import android.util.Base64
+import android.util.Log
+import java.io.File
+import java.io.IOException
+import java.security.KeyFactory
+import java.security.Signature
+import java.security.spec.X509EncodedKeySpec
+import org.json.JSONArray
+import org.json.JSONObject
+
+data class AkanNativeUpdateEntry(val bundle: String, val sequence: Double, val nativeApi: String, val attempts: Int = 0) {
+    fun toJson(): JSONObject = JSONObject().put("bundle", bundle).put("sequence", sequence).put("nativeApi", nativeApi).put("attempts", attempts)
+
+    companion object {
+        fun from(json: Any?): AkanNativeUpdateEntry? {
+            val o = json as? JSONObject ?: return null
+            val bundle = o.optString("bundle")
+            if (!AkanNativeUpdates.isBundleId(bundle) || !o.has("sequence") || !o.has("nativeApi")) return null
+            return AkanNativeUpdateEntry(bundle, o.optDouble("sequence"), o.optString("nativeApi"), o.optInt("attempts"))
+        }
+    }
+}
+
+class AkanNativeUpdateState(
+    var current: AkanNativeUpdateEntry? = null,
+    var pending: AkanNativeUpdateEntry? = null,
+    var trial: AkanNativeUpdateEntry? = null,
+    val failed: MutableList<String> = mutableListOf(),
+    var rolledBack: String? = null,
+) {
+    fun toJson(): JSONObject {
+        val o = JSONObject().put("failed", JSONArray(failed.takeLast(20)))
+        current?.let { o.put("current", it.toJson()) }
+        pending?.let { o.put("pending", it.toJson()) }
+        trial?.let { o.put("trial", it.toJson()) }
+        rolledBack?.let { o.put("rolledBack", it) }
+        return o
+    }
+
+    companion object {
+        fun from(o: JSONObject): AkanNativeUpdateState {
+            val failed = o.optJSONArray("failed")
+            return AkanNativeUpdateState(
+                current = AkanNativeUpdateEntry.from(o.opt("current")),
+                pending = AkanNativeUpdateEntry.from(o.opt("pending")),
+                trial = AkanNativeUpdateEntry.from(o.opt("trial")),
+                failed = MutableList(failed?.length() ?: 0) { failed!!.optString(it) }.filter(AkanNativeUpdates::isBundleId).toMutableList(),
+                rolledBack = o.optString("rolledBack").ifEmpty { null },
+            )
+        }
+    }
+}
+
+/** updates.json from the build (akan-native.config.ts `updates`), null when the app has no updates. */
+class AkanNativeUpdateConfig(
+    val app: String,
+    val platform: String,
+    val nativeApi: String,
+    val embeddedSequence: Double,
+    val url: String,
+    val publicKey: ByteArray,
+    val channel: String,
+    val readyTimeoutMs: Long,
+    val dev: Boolean,
+) {
+    companion object {
+        fun load(context: Context): AkanNativeUpdateConfig? {
+            val o = try {
+                JSONObject(context.assets.open("akan-native/updates.json").bufferedReader().use { it.readText() })
+            } catch (e: Exception) {
+                return null
+            }
+            val key = try {
+                Base64.decode(o.optString("publicKey"), Base64.DEFAULT)
+            } catch (e: IllegalArgumentException) {
+                return null
+            }
+            if (key.size != 32 || o.optString("url").isEmpty() || o.optString("nativeApi").isEmpty()) return null
+            return AkanNativeUpdateConfig(
+                app = o.optString("app"),
+                platform = o.optString("platform", "android"),
+                nativeApi = o.optString("nativeApi"),
+                embeddedSequence = o.optDouble("embeddedSequence", 0.0),
+                url = o.optString("url"),
+                publicKey = key,
+                channel = o.optString("channel", "production"),
+                readyTimeoutMs = o.optLong("readyTimeout", 10_000),
+                dev = o.optBoolean("dev"),
+            )
+        }
+    }
+}
+
+object AkanNativeUpdates {
+    private const val TAG = "AkanNativeUpdates"
+
+    var config: AkanNativeUpdateConfig? = null
+        private set
+    private lateinit var directory: File
+
+    /** The bundle served in this session (null: the one inside the APK). */
+    var active: AkanNativeUpdateEntry? = null
+        private set
+
+    /** The served bundle has not confirmed yet (notifyReady), so the ready timer runs. */
+    var onTrial = false
+        private set
+
+    fun isBundleId(s: String): Boolean = AkanNativeKernel.isBundleId(s)
+
+    fun init(context: Context) {
+        config = AkanNativeUpdateConfig.load(context)
+        // Earlier builds kept this in filesDir, where the page could write it: never trusted.
+        File(context.filesDir, "akan-native-updates").takeIf { it.exists() }?.deleteRecursively()
+        directory = File(context.noBackupFilesDir, "akan-native-updates")
+    }
+
+    /**
+     * Ed25519 over [data] with the raw 32-byte key of updates.json: the platform's on API 33+, below
+     * it AkanNativeEd25519 (RFC 8032 in plain Kotlin; Android 10 to 12 have no Ed25519 provider). Both pass
+     * the shared vectors (vectors/ed25519.json).
+     */
+    fun signed(data: ByteArray, signature: ByteArray, key: ByteArray): Boolean =
+        if (android.os.Build.VERSION.SDK_INT >= 33) platformSigned(data, signature, key) else AkanNativeEd25519.verify(data, signature, key)
+
+    private fun platformSigned(data: ByteArray, signature: ByteArray, key: ByteArray): Boolean = try {
+        // Raw key → X.509 SubjectPublicKeyInfo for KeyFactory("Ed25519").
+        val spki = byteArrayOf(0x30, 0x2a, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x03, 0x21, 0x00) + key
+        Signature.getInstance("Ed25519").run {
+            initVerify(KeyFactory.getInstance("Ed25519").generatePublic(X509EncodedKeySpec(spki)))
+            update(data)
+            verify(signature)
+        }
+    } catch (e: Exception) {
+        false
+    }
+
+    /**
+     * 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 fun verified(entry: AkanNativeUpdateEntry, config: AkanNativeUpdateConfig): Boolean {
+        val dir = bundleDirectory(entry.bundle)
+        return try {
+            val manifest = File(dir, "manifest.json").readBytes()
+            val signature = Base64.decode(File(dir, "manifest.json.sig").readText().trim(), Base64.DEFAULT)
+            if (!signed(manifest, signature, config.publicKey)) return false
+            val o = JSONObject(String(manifest))
+            val files = o.getJSONArray("files")
+            o.optString("bundle") == entry.bundle && o.optDouble("sequence") == entry.sequence && o.optString("nativeApi") == entry.nativeApi &&
+                o.optString("app") == config.app && o.optString("platform") == config.platform &&
+                (0 until files.length()).all { i ->
+                    val f = files.getJSONObject(i)
+                    File(dir, f.getString("path")).let { it.isFile && it.length() == f.getLong("size") }
+                }
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    fun bundleDirectory(bundle: String): File = File(File(directory, "bundles"), bundle)
+
+    private val stateFile get() = AtomicFile(File(directory, "state.json"))
+
+    fun readState(): AkanNativeUpdateState = try {
+        AkanNativeUpdateState.from(JSONObject(String(stateFile.readFully())))
+    } catch (e: Exception) {
+        AkanNativeUpdateState()
+    }
+
+    /**
+     * AtomicFile: a new file, synced, then renamed over the old one, so a crash or power loss 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.
+     */
+    fun writeState(state: AkanNativeUpdateState): Boolean {
+        directory.mkdirs()
+        val file = stateFile
+        val out = try {
+            file.startWrite()
+        } catch (e: IOException) {
+            Log.w(TAG, "cannot write state.json: $e")
+            return false
+        }
+        return try {
+            out.write(state.toJson().toString().toByteArray())
+            file.finishWrite(out)
+            true
+        } catch (e: IOException) {
+            file.failWrite(out)
+            Log.w(TAG, "cannot write state.json: $e")
+            false
+        }
+    }
+
+    fun usable(entry: AkanNativeUpdateEntry?, config: AkanNativeUpdateConfig): Boolean =
+        entry != null && entry.nativeApi == config.nativeApi && entry.sequence > config.embeddedSequence &&
+            File(bundleDirectory(entry.bundle), "index.html").isFile && verified(entry, config)
+
+    /** Picks the bundle for this launch; returns its folder, or null for the APK's own bundle. */
+    fun launch(): File? {
+        val config = config ?: return null
+        val state = readState()
+        if (!usable(state.current, config)) state.current = null
+        if (!usable(state.pending, config)) state.pending = null
+        if (!usable(state.trial, config)) state.trial = null
+        state.trial?.let {
+            // Launched again without notifyReady(): the trial crashed or hung.
+            state.failed.add(it.bundle)
+            state.rolledBack = it.bundle
+            state.trial = null
+            Log.w(TAG, "bundle ${it.bundle} did not confirm; rolled back")
+        }
+        state.pending?.let {
+            if (!state.failed.contains(it.bundle)) {
+                state.trial = it.copy(attempts = 1)
+                state.pending = null
+            }
+        }
+        // Not on record: the pending bundle waits for a launch that can record it.
+        if (!writeState(state)) state.trial = null
+        active = state.trial ?: state.current
+        onTrial = state.trial != null
+        return active?.let { bundleDirectory(it.bundle) }
+    }
+
+    /** A verified download (plugin): runs at the next launch, or right away through applyPending(). */
+    fun stage(entry: AkanNativeUpdateEntry) {
+        val state = readState()
+        state.pending = entry
+        state.failed.remove(entry.bundle)
+        writeState(state)
+    }
+
+    /** apply(): makes the pending bundle the trial now; returns its folder for the reload. */
+    fun applyPending(): File? {
+        val config = config ?: return null
+        val state = readState()
+        val pending = state.pending?.takeIf { usable(it, config) } ?: return null
+        state.trial = pending.copy(attempts = 1)
+        state.pending = null
+        if (!writeState(state)) return null
+        active = pending
+        onTrial = true
+        return bundleDirectory(pending.bundle)
+    }
+
+    /** notifyReady(): the served trial becomes current; bundles nothing refers to are removed. */
+    fun confirm() {
+        val trial = active
+        if (!onTrial || trial == null) return
+        val state = readState()
+        if (state.trial?.bundle != trial.bundle) return
+        state.current = trial.copy(attempts = 0)
+        state.trial = null
+        state.rolledBack = null
+        writeState(state)
+        onTrial = false
+        prune(listOfNotNull(state.current?.bundle, state.pending?.bundle))
+    }
+
+    /** The trial did not confirm in time: back to the previous bundle (null: the APK's own). */
+    fun rollback(): File? {
+        val trial = active
+        if (!onTrial || trial == null) return active?.let { bundleDirectory(it.bundle) }
+        val state = readState()
+        state.trial = null
+        state.failed.add(trial.bundle)
+        state.rolledBack = trial.bundle
+        writeState(state)
+        onTrial = false
+        val config = config
+        active = if (config != null && usable(state.current, config)) state.current else null
+        Log.w(TAG, "bundle ${trial.bundle} did not call notifyReady() in time; rolled back")
+        return active?.let { bundleDirectory(it.bundle) }
+    }
+
+    /** reset(): the APK's own bundle from the next launch on. */
+    fun reset() {
+        writeState(AkanNativeUpdateState())
+        prune(listOfNotNull(active?.bundle))
+    }
+
+    /** A download in progress (bundles/<bundle>.partial) is the plugin's, which removes it. */
+    private fun prune(keep: List<String>) {
+        val folder = File(directory, "bundles")
+        for (dir in folder.listFiles() ?: return) {
+            if (dir.name !in keep && dir.name != active?.bundle && !dir.name.endsWith(".partial")) dir.deleteRecursively()
+        }
+    }
+}

package/vendor/@akanjs/native/native/android/src/com/akanjs/runtime/AkanNativeVectors.kt

@@ -0,0 +1,132 @@
+package com.akanjs.runtime
+
+/**
+ * Runs the shared vectors (packages/core/vectors) against this host's kernel (AkanNativeKernel,
+ * AkanNativeGlob): on the JVM 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.
+ */
+object AkanNativeVectors {
+    class Result(val passed: Int, val failures: List<String>)
+
+    fun run(): Result {
+        var passed = 0
+        val failures = ArrayList<String>()
+        val ran = HashMap<String, Int>()
+        var current = ""
+        fun check(ok: Boolean, what: () -> String) {
+            ran[current] = (ran[current] ?: 0) + 1
+            if (ok) passed++ else failures.add(what())
+        }
+        fun load(name: String): Map<*, *> {
+            current = name
+            return AkanNativeVectorData.file(name) ?: emptyMap<String, Any?>()
+        }
+        fun rows(o: Map<*, *>?, key: String): List<List<Any?>> = (o?.get(key) as? List<*>)?.map { it as List<Any?> } ?: emptyList()
+
+        val scope = load("scope")
+        for (c in rows(scope, "glob")) check(AkanNativeGlob.match(c[0] as String, c[1] as String, c[2] != "plain", c[2] == "path-deny") == c[3]) { "glob $c" }
+        for (c in rows(scope, "permits")) {
+            val s = c[0] as Map<*, *>
+            fun entries(v: Any?) = (v as? List<*>)?.map { e -> (e as Map<*, *>).entries.associate { (k, x) -> k as String to x as String } }
+            val scope = AkanNativeScope(entries(s["allow"]), entries(s["deny"]) ?: emptyList())
+            val value = (c[1] as Map<*, *>).entries.associate { (k, x) -> k as String to x as String }
+            val ok = scope.permits(value, (c[2] as List<*>).map { it as String }.toSet(), (c[3] as List<*>).map { it as String }.toSet(), c[4] as Boolean)
+            check(ok == c[5]) { "permits $c" }
+        }
+        for (c in rows(scope, "url")) check(AkanNativeGlob.url(c[0] as String, c[1] as String, c[2] == "deny") == c[3]) { "url $c" }
+
+        val routes = load("routes")
+        val files = (routes["files"] as? List<*>)?.toSet() ?: emptySet<Any?>()
+        for (c in rows(routes, "cases")) {
+            val all = c[1] == "all"
+            val got = when (val r = AkanNativeKernel.route(c[0] as String) { all || it in files }) {
+                AkanNativeRoute.Init -> "init" to null
+                AkanNativeRoute.Ipc -> "ipc" to null
+                AkanNativeRoute.Hello -> "hello" to null
+                is AkanNativeRoute.File -> "file" to r.id
+                is AkanNativeRoute.Asset -> "asset" to r.path
+                AkanNativeRoute.NotFound -> "not-found" to null
+            }
+            check(got.first == c[2] && got.second == c[3]) { "route $c: $got" }
+        }
+        for (c in rows(routes, "hostPaths")) check(AkanNativeKernel.isHostPath(c[0] as String) == c[1]) { "host path $c" }
+
+        for (c in rows(load("ranges"), "cases")) {
+            val expected = (c[2] as List<*>).map { (it as Number).toLong() }
+            val got = when (val r = AkanNativeKernel.parseRange(c[0] as String?, (c[1] as Number).toLong())) {
+                AkanNativeRangeAnswer.Whole -> listOf(200L)
+                is AkanNativeRangeAnswer.Part -> listOf(206L, r.first, r.last)
+                AkanNativeRangeAnswer.Unsatisfiable -> listOf(416L)
+            }
+            check(got == expected) { "range $c: $got" }
+        }
+
+        val ids = load("ids")
+        val specs = mapOf("fileRef" to AkanNativeContract.ID_FILE_REF, "bundle" to AkanNativeContract.ID_BUNDLE, "document" to AkanNativeContract.ID_DOCUMENT, "name" to AkanNativeContract.ID_NAME)
+        for (c in rows(ids, "cases")) check(AkanNativeKernel.idValid(specs.getValue(c[0] as String), c[1] as String) == c[2]) { "id $c" }
+        for (c in rows(ids["mime"] as? Map<*, *>, "cases")) {
+            val path = c[0] as String
+            check(AkanNativeKernel.assetMime(path) == c[1] && AkanNativeKernel.fileMime(path) == c[2]) { "mime $c: ${AkanNativeKernel.assetMime(path)}" }
+        }
+
+        val bridge = load("bridge")
+        for (c in rows(bridge, "requests")) {
+            val got = AkanNativeKernel.validateRequest(c[0])
+            check(got == c[1]) { "request $c: $got" }
+        }
+        for (c in rows(bridge, "declarations")) check(AkanNativeKernel.declares(c[0], c[1] as String, c[2] as String?) == c[3]) { "declaration $c" }
+        for (c in rows(bridge, "documents")) {
+            val got = AkanNativeKernel.admitDocument(c[0] as String?, (c[1] as List<*>).map { it as String }, c[2] as String?)
+            check(got.wire == c[3]) { "document $c: ${got.wire}" }
+        }
+
+        for ((i, item) in ((load("acl")["cases"] as? List<*>) ?: emptyList<Any?>()).withIndex()) {
+            val case = item as Map<*, *>
+            val (acl, problem) = AkanNativeAcl.from(case)
+            check((problem != null) == case["problem"]) { "acl case $i: problem $problem" }
+            for (c in rows(case, "checks")) {
+                val (allowed, scope) = acl?.check(c[0] as String, c[1] as String, (c[2] as Number).toInt()) ?: (true to null)
+                val expected = c[4] as Map<*, *>?
+                val scopeOk = if (scope == null) expected == null else scope.allow == expected?.get("allow") && scope.deny == expected?.get("deny")
+                check(allowed == c[3] && scopeOk) { "acl case $i $c: $allowed ${scope?.allow} ${scope?.deny}" }
+            }
+        }
+
+        val navigation = load("navigation")
+        for (c in rows(navigation, "cases")) {
+            val got = AkanNativeKernel.decideNavigation(c[0] as String, c[1] as Boolean, "app://localhost", (c[2] as List<*>).map { it as String })
+            check(got.wire == c[3]) { "navigation $c: ${got.wire}" }
+        }
+        for (c in rows(navigation, "fileRefSandbox")) check(AkanNativeKernel.fileRefSandboxed(c[0] as String) == c[1]) { "sandbox $c" }
+        for (item in (load("retained")["cases"] as? List<*>) ?: emptyList<Any?>()) {
+            val case = item as Map<*, *>
+            val events = AkanNativeRetained<String>()
+            val log = ArrayList<String>()
+            for (op in (case["ops"] as List<*>).map { it as List<*> }) {
+                val name = op[1] as String
+                when (op[0]) {
+                    "listen" -> {
+                        val accepts = op[2] as Boolean
+                        events.listen(name) { value -> if (accepts) log.add("$name:$value"); accepts }
+                    }
+                    "unlisten" -> events.unlisten(name)
+                    else -> events.emit(name, op[2] as Boolean)
+                }
+            }
+            check(log == case["log"]) { "retained ${case["name"]}: $log" }
+        }
+        // Ed25519 as web bundle updates verify it below API 33 (AkanNativeEd25519, pure Kotlin).
+        fun bytes(hex: String) = ByteArray(hex.length / 2) { hex.substring(it * 2, it * 2 + 2).toInt(16).toByte() }
+        for (c in rows(load("ed25519"), "cases")) {
+            check(AkanNativeEd25519.verify(bytes(c[1] as String), bytes(c[2] as String), bytes(c[0] as String)) == c[3]) { "ed25519 ${c[4]}" }
+        }
+
+        // A missing or truncated file must not pass as fewer checks.
+        for ((name, count) in AkanNativeVectorData.counts) if ((ran[name] ?: 0) != count) failures.add("$name: ${ran[name] ?: 0} of $count checks ran")
+        if (AkanNativeVectorData.counts.isEmpty()) failures.add("no vectors in this build")
+        return Result(passed, failures)
+    }
+
+    /** The checks all files hold. */
+    val expected: Int get() = AkanNativeVectorData.counts.values.sum()
+}