catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/androidProject/app/build.gradle.kts

@@ -87,6 +87,11 @@ fun getLocalIpAddress(): String {
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.jetbrains.kotlin.android)
+    jacoco
+}
+
+jacoco {
+    toolVersion = libs.versions.jacoco.get()
 }
 
 android {
@@ -215,18 +220,24 @@ android {
                 java.srcDirs("src/noFcm/java")
             }
             // AI has no source-set swap — CatalystAIBridge self-registers via ServiceLoader
-            // when @catalyst/cloud-ai is on the classpath.
+            // when catalyst-ai is on the classpath.
         }
     }
 }
 
 configurations.all {
     resolutionStrategy.eachDependency {
+        // kotlin-reflect is deliberately NOT forced here (unlike the
+        // stdlib artifacts below) — mockito-kotlin 6.x requires
+        // kotlin-reflect >=2.1.20, newer than this project's 2.0.21
+        // compiler version. kotlin-reflect is forward-compatible with
+        // older stdlib/compiler versions for the reflection use cases
+        // actually exercised in tests, so it resolves to whatever's
+        // requested (libs.kotlin.reflect, currently 2.1.20) instead.
         if (requested.group == "org.jetbrains.kotlin" &&
             (requested.name == "kotlin-stdlib" ||
              requested.name == "kotlin-stdlib-jdk7" ||
-             requested.name == "kotlin-stdlib-jdk8" ||
-             requested.name == "kotlin-reflect")) {
+             requested.name == "kotlin-stdlib-jdk8")) {
             useVersion("2.0.21")
         }
     }
@@ -238,6 +249,16 @@ dependencies {
     implementation(libs.material)
     implementation(libs.androidx.constraintlayout)
     testImplementation(libs.junit)
+    // #413: Mockito for JVM unit tests (app/src/test). mockito-core 5.x
+    // defaults to the inline mock-maker, so Kotlin's final classes don't
+    // need extra `open` keywords. mockito-kotlin adds the idiomatic
+    // whenever()/mock<T>() DSL on top. kotlinx-coroutines-test matches
+    // the existing kotlinx-coroutines-android dependency's release line
+    // for testing suspend funs in NativeBridge/OfflineCacheService.
+    testImplementation(libs.mockito.core)
+    testImplementation(libs.mockito.kotlin)
+    testImplementation(libs.kotlin.reflect)
+    testImplementation(libs.kotlinx.coroutines.test)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)
     implementation(libs.androidx.webkit)
@@ -252,11 +273,18 @@ dependencies {
     implementation("io.ktor:ktor-server-sse:3.0.3")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
 
-    // Native AI — compileOnly always (for types), implementation only when ai.enabled=true (for runtime bundling)
-    if (project.findProject(":catalyst-cloud-ai") != null) {
-        compileOnly(project(":catalyst-cloud-ai"))
+    // Native AI (catalyst-ai). The module is only ever on the classpath when
+    // ai.enabled=true -- that's the sole sync trigger (settings.gradle.kts
+    // guards on node_modules/catalyst-ai/android existing, and the auto-sync
+    // in buildAndroid/index.js only runs for ai.enabled). The app has no
+    // compile-time dependency on it: NativeBridge.kt discovers CatalystAIBridge
+    // at runtime via Class.forName + ServiceLoader. compileOnly is kept so the
+    // module still builds/type-checks when present; implementation adds it to
+    // the APK for runtime bundling.
+    if (project.findProject(":catalyst-ai") != null) {
+        compileOnly(project(":catalyst-ai"))
         if (isAIEnabled()) {
-            implementation(project(":catalyst-cloud-ai"))
+            implementation(project(":catalyst-ai"))
         }
     }
 
@@ -284,6 +312,113 @@ dependencies {
     }
 }
 
+// JVM unit test coverage (Tier 1). Mirrors the CatalystCoreLogic
+// llvm-cov setup on iOS (#432): real, measured line coverage for
+// app/src/test, not just a pass/fail count. Scoped to testDebugUnitTest —
+// enableUnitTestCoverage=true on the debug build type (above) already
+// makes Gradle emit the raw .exec coverage data; this task turns that
+// into the human/CI-readable XML + HTML report.
+tasks.register<JacocoReport>("jacocoTestReport") {
+    dependsOn("testDebugUnitTest")
+    group = "verification"
+    description = "Generates JVM unit test coverage report for app/src/test (Tier 1)."
+
+    reports {
+        xml.required.set(true)
+        html.required.set(true)
+    }
+
+    // Excludes are split into two groups. The first is generated/non-authored
+    // code (R.class, BuildConfig, view/data binding scaffolding) — no
+    // coverage story either way, always excluded.
+    //
+    // The second is the Tier 2 classification below: files that build real
+    // Android Views, extend Activity/Fragment, or otherwise structurally
+    // require Robolectric or a real device/emulator to exercise (confirmed
+    // via a full-repo classification pass, not a guess from filenames —
+    // see PR description / issue for the per-file reasoning). These ARE
+    // real, authored logic — excluding them isn't "inflating" the number,
+    // it's making the gate honest: a Tier 1/Tier 2 coverage gate that
+    // includes Tier 2 in its denominator would fail any PR that touches
+    // WebView/Activity/View code regardless of how well-tested that PR's
+    // actual testable logic is. Mirrors the CoreLogic/UI split already
+    // accepted on iOS (#432).
+    //
+    // Each Tier 2 file's top-level class, Kt-file facade, and compiled
+    // lambda/inner classes are all excluded, so nothing structurally
+    // untestable is left counting against the gate. The one exception is
+    // NativeBridge, which has an already-tested companion object
+    // (parseAndValidateMessage, compiled separately as
+    // NativeBridge$Companion.class) — Gradle's Ant-style exclude() does
+    // not reliably support "!" negation, so instead of pattern-negating
+    // the companion out, its lambda exclude uses "$*$*" (two "$"
+    // segments), which Kotlin lambda class names always have and the
+    // single-"$" companion class name never does. See the comment next
+    // to that pattern below for the concrete example.
+    val generatedCodeFilter = listOf(
+        "**/R.class", "**/R$*.class",
+        "**/BuildConfig.*",
+        "**/Manifest*.*",
+        "**/*Test*.*",
+        "android/**/*.*",
+        "**/databinding/**",
+        "**/android/databinding/**",
+        "**/androidx/databinding/**",
+        "**/*_ViewBinding*.*",
+        "**/*\$ViewInjector*.*",
+        "**/*\$ViewBinder*.*",
+        "**/*_MembersInjector.class"
+    )
+
+    val tier2FrameworkBoundFilter = listOf(
+        // Real WebView/Activity construction, ViewBinding, real lifecycle.
+        // Each file's top-level class, Kt-file facade, and compiled lambda
+        // classes (Kotlin: OuterClass$methodName$N.class) are all excluded.
+        // None of these files has a companion object worth protecting
+        // (that only applies to NativeBridge, handled separately below),
+        // so a plain "$*" is safe here.
+        "**/CustomWebView.class", "**/CustomWebView\$*.class", "**/CustomWebViewKt.class",
+        "**/MainActivity.class", "**/MainActivity\$*.class",
+        "**/SplashActivity.class", "**/SplashActivity\$*.class",
+        "**/NativeCameraManager.class", "**/NativeCameraManager\$*.class",
+        "**/camera/CameraSessionManager.class", "**/camera/CameraSessionManager\$*.class",
+        "**/TransitionManager.class", "**/TransitionManager\$*.class",
+        "**/utils/KeyboardUtil.class", "**/utils/KeyboardUtil\$*.class",
+        "**/security/SecurityAlertUI.class", "**/security/SecurityAlertUI\$*.class",
+        "**/security/SecurityAlertHandler.class", "**/security/SecurityAlertHandler\$*.class",
+        "**/security/SecurityBottomSheet.class", "**/security/SecurityBottomSheet\$*.class",
+        // NativeBridge has an already-tested companion (parseAndValidateMessage,
+        // compiled as NativeBridge$Companion.class — one "$"). Kotlin lambda
+        // classes always carry two "$" segments (e.g.
+        // NativeBridge$downloadAndOpenFile$1.class), so "$*$*" excludes every
+        // lambda while a single-"$" glob would be needed to also exclude the
+        // companion — which this pattern does NOT match, by construction.
+        "**/NativeBridge.class", "**/NativeBridgeKt.class", "**/NativeBridge\$*\$*.class"
+    )
+
+    val debugTree = fileTree(layout.buildDirectory.dir("intermediates/javac/debug/compileDebugJavaWithJavac/classes")) {
+        exclude(generatedCodeFilter + tier2FrameworkBoundFilter)
+    }
+    val kotlinDebugTree = fileTree(layout.buildDirectory.dir("tmp/kotlin-classes/debug")) {
+        exclude(generatedCodeFilter + tier2FrameworkBoundFilter)
+    }
+    // Both noFcm/withFcm are listed (not just whichever isNotificationsEnabled()
+    // picked for this build) purely so the HTML report can resolve source
+    // lines for whichever one actually got compiled — listing the inactive
+    // one is harmless, Jacoco just won't find matching class files for it.
+    val sourceDirs = listOf(
+        "${project.projectDir}/src/main/java",
+        "${project.projectDir}/src/noFcm/java",
+        "${project.projectDir}/src/withFcm/java"
+    )
+
+    sourceDirectories.setFrom(files(sourceDirs))
+    classDirectories.setFrom(files(debugTree, kotlinDebugTree))
+    executionData.setFrom(fileTree(layout.buildDirectory) {
+        include("outputs/unit_test_code_coverage/debugUnitTest/testDebugUnitTest.exec")
+    })
+}
+
 // Task to verify local IP
 tasks.register("printLocalIp") {
     doLast {

package/dist/native/androidProject/app/src/main/AndroidManifest.xml

@@ -5,6 +5,10 @@
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.VIBRATE" />
+    <!-- Runtime-guarded in NotificationUtils.showNotification (checkSelfPermission
+         || SDK_INT < TIRAMISU); only requested/used when the notifications
+         feature is enabled at build time. -->
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-feature android:name="android.hardware.camera" android:required="false" />
     <queries>
         <intent>

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/NativeBridge.kt

@@ -27,7 +27,7 @@ import java.util.Properties
 import java.util.ServiceLoader
 import java.util.concurrent.atomic.AtomicBoolean
 
-private data class FilePickerOptions(
+internal data class FilePickerOptions(
     val mimeType: String = "*/*",
     val multiple: Boolean = false,
     val minFiles: Int? = null,
@@ -96,7 +96,7 @@ private fun JSONObject.optIntNullable(key: String): Int? =
 private fun JSONObject.optLongNullable(key: String): Long? =
     if (has(key) && !isNull(key)) getLong(key) else null
 
-private data class GoogleSignInOptions(
+internal data class GoogleSignInOptions(
     val clientId: String,
     val nonce: String? = null,
     val autoSelect: Boolean = false,

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/camera/BarcodeDetector.kt

@@ -1,6 +1,8 @@
 package io.yourname.androidproject.camera
 
 import android.util.Log
+import androidx.annotation.OptIn
+import androidx.camera.core.ExperimentalGetImage
 import androidx.camera.core.ImageAnalysis
 import androidx.camera.core.ImageProxy
 import com.google.mlkit.vision.barcode.BarcodeScanner
@@ -72,6 +74,7 @@ class BarcodeDetector(
         scanner = null
     }
 
+    @OptIn(ExperimentalGetImage::class)
     private fun processFrame(imageProxy: ImageProxy, activeScanner: BarcodeScanner) {
         val mediaImage = imageProxy.image
         if (mediaImage == null) {

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/camera/CameraSessionManager.kt

@@ -7,7 +7,9 @@ import android.util.Size
 import android.view.View
 import android.hardware.camera2.CaptureRequest
 import android.util.Range
+import androidx.annotation.OptIn
 import androidx.camera.camera2.interop.Camera2Interop
+import androidx.camera.camera2.interop.ExperimentalCamera2Interop
 import androidx.camera.core.Camera
 import androidx.camera.core.CameraSelector
 import androidx.camera.core.ImageAnalysis
@@ -152,6 +154,7 @@ class CameraSessionManager(
 
     // ---- Internal ----
 
+    @OptIn(ExperimentalCamera2Interop::class)
     private fun bindCamera() {
         val future = ProcessCameraProvider.getInstance(activity)
         future.addListener({

package/dist/native/androidProject/app/src/main/java/io/yourname/androidproject/utils/FrameworkServerUtils.kt

@@ -64,8 +64,23 @@ object FrameworkServerUtils {
     // System prompt injected into every native AI request (built from attachmentComponents at initAI time)
     private var nativeSystemPrompt: String = ""
 
-    // Coroutine scope for server operations
-    private val serverScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    // Coroutine scope for server operations. A `var`, re-created at the
+    // top of startServer() rather than a `val` created once — stopServer()
+    // calls serverScope.cancel(), and a CoroutineScope is single-use: once
+    // cancelled it never accepts new coroutines again. With this as a
+    // `val`, any startServer() after a stop() launched startCleanupTask()
+    // into an already-cancelled scope, silently disabling periodic served-
+    // file cleanup for the rest of that server's lifetime. Found via a
+    // real start/stop/restart sequence in FrameworkServerUtilsTest.
+    // @Volatile: startServer()/stopServer() can run on different threads
+    // (this object is a singleton reached from NativeBridge's coroutine
+    // scope and from test code alike) — without it, a reassignment in
+    // startServer() has no guaranteed visibility to a reader on another
+    // thread (e.g. a coroutine already launched via serverScope.launch{}
+    // from a prior start), same class of bug as a non-volatile double-
+    // checked-locking field.
+    @Volatile
+    private var serverScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     
     data class ServedFile(
         val file: File,
@@ -90,6 +105,14 @@ object FrameworkServerUtils {
         }
         
         return try {
+            // A cancelled CoroutineScope never accepts new coroutines —
+            // re-create it here so startCleanupTask() below (and any
+            // other serverScope.launch call during this server's
+            // lifetime) works correctly even after a prior stopServer().
+            if (!serverScope.isActive) {
+                serverScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+            }
+
             // Initialize cache directory
             initializeCacheDirectory(context)
 
@@ -504,12 +527,24 @@ object FrameworkServerUtils {
                     call.response.header(HttpHeaders.AccessControlAllowMethods, "GET, OPTIONS")
                     call.response.header(HttpHeaders.AccessControlAllowHeaders, "*")
 
-                    call.respond(HttpStatusCode.OK, mapOf(
-                        "status" to "running",
-                        "sessionId" to sessionId,
-                        "port" to serverPort,
-                        "servedFiles" to servedFiles.size
-                    ))
+                    // respondText with a manually-built JSONObject, not
+                    // call.respond(status, mapOf(...)) — that call needs a
+                    // registered ContentNegotiation converter to serialize
+                    // a raw Map, which this server never installs, so it
+                    // was returning 406 Not Acceptable to every real HTTP
+                    // client (confirmed via a real loopback request in
+                    // FrameworkServerUtilsTest — no test caught this
+                    // before because no test made a real request against
+                    // this route). Matches the /ai/generate route's own
+                    // JSONObject + respondText pattern elsewhere in this
+                    // file, avoiding a new ContentNegotiation dependency
+                    // for one endpoint.
+                    val statusJson = JSONObject()
+                        .put("status", "running")
+                        .put("sessionId", sessionId)
+                        .put("port", serverPort)
+                        .put("servedFiles", servedFiles.size)
+                    call.respondText(statusJson.toString(), ContentType.Application.Json, HttpStatusCode.OK)
                 }
 
                 // Handle OPTIONS preflight requests for CORS

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/BridgeUtilsTest.kt

@@ -1,9 +1,15 @@
 package io.yourname.androidproject
 
+import android.webkit.WebView
 import io.yourname.androidproject.utils.BridgeUtils
 import org.json.JSONObject
 import org.junit.Assert.*
 import org.junit.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.isNull
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
 
 /**
  * Unit tests for BridgeUtils
@@ -12,8 +18,15 @@ import org.junit.Test
  * - Bridge message formatting (3 tests)
  * - Response serialization (2 tests)
  * - Error message formatting (3 tests)
+ * - notifyWeb-family, emitPerfEvent, and log-family calls against a
+ *   mocked WebView (extension — these were previously untested; only the
+ *   pure string/JSON helpers above had coverage). Looper.myLooper() and
+ *   Looper.getMainLooper() both return the SDK stub's default null in a
+ *   JVM unit test, so `null != null` is false and every notifyWeb/
+ *   emitPerfEvent call below takes the synchronous "already on main
+ *   thread" branch directly — no WebView.post dispatch to account for.
  *
- * Total: 8 tests
+ * Total: 8 original + 12 extension tests
  *
  * Note: Tests focus on testable logic and string formatting without WebView
  * following the same pattern as FileUtilsTest.kt
@@ -283,4 +296,171 @@ class BridgeUtilsTest {
         assertTrue(kbFormatted.contains("."))
         assertTrue(kbFormatted.endsWith("KB"))
     }
+
+    // ============================================================
+    // CATEGORY 4: notifyWeb* against a mocked WebView (extension)
+    // ============================================================
+
+    @Test
+    fun `notifyWeb evaluates a null-data callback when data is null`() {
+        val webView: WebView = mock()
+
+        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.ON_CAMERA_CAPTURE, null)
+
+        verify(webView).evaluateJavascript(
+            eq("window.WebBridge.callback('ON_CAMERA_CAPTURE', null)"),
+            isNull()
+        )
+    }
+
+    @Test
+    fun `notifyWeb quotes plain-string data as a JS string literal`() {
+        val webView: WebView = mock()
+
+        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.ON_INTENT_SUCCESS, "GRANTED")
+
+        verify(webView).evaluateJavascript(
+            eq("window.WebBridge.callback('ON_INTENT_SUCCESS', ${JSONObject.quote("GRANTED")})"),
+            isNull()
+        )
+    }
+
+    @Test
+    fun `notifyWeb injects JSON-object-shaped data raw, not double-quoted`() {
+        val webView: WebView = mock()
+
+        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.ON_DEVICE_INFO_SUCCESS, """{"a":1}""")
+
+        verify(webView).evaluateJavascript(
+            eq("""window.WebBridge.callback('ON_DEVICE_INFO_SUCCESS', {"a":1})"""),
+            isNull()
+        )
+    }
+
+    @Test
+    fun `notifyWeb swallows an exception from evaluateJavascript`() {
+        val webView: WebView = mock()
+        org.mockito.kotlin.whenever(webView.evaluateJavascript(any(), isNull()))
+            .thenThrow(RuntimeException("boom"))
+
+        // Does not propagate — notifyWeb catches and logs internally.
+        BridgeUtils.notifyWeb(webView, BridgeUtils.WebEvents.ON_CAMERA_ERROR, "x")
+    }
+
+    @Test
+    fun `notifyWebError defaults to a fallback message when errorMessage is null`() {
+        val webView: WebView = mock()
+
+        BridgeUtils.notifyWebError(webView, BridgeUtils.WebEvents.ON_CAMERA_ERROR, null)
+
+        verify(webView).evaluateJavascript(
+            eq("window.WebBridge.callback('ON_CAMERA_ERROR', ${JSONObject.quote("Unknown error occurred")})"),
+            isNull()
+        )
+    }
+
+    @Test
+    fun `notifyWebSuccess defaults to SUCCESS when successMessage is not provided`() {
+        val webView: WebView = mock()
+
+        BridgeUtils.notifyWebSuccess(webView, BridgeUtils.WebEvents.ON_INTENT_SUCCESS)
+
+        verify(webView).evaluateJavascript(
+            eq("window.WebBridge.callback('ON_INTENT_SUCCESS', ${JSONObject.quote("SUCCESS")})"),
+            isNull()
+        )
+    }
+
+    @Test
+    fun `notifyWebJson injects the JSON payload raw`() {
+        val webView: WebView = mock()
+        val payload = JSONObject().apply { put("ok", true) }
+
+        BridgeUtils.notifyWebJson(webView, BridgeUtils.WebEvents.ON_DEVICE_INFO_SUCCESS, payload)
+
+        verify(webView).evaluateJavascript(
+            eq("window.WebBridge.callback('ON_DEVICE_INFO_SUCCESS', ${payload})"),
+            isNull()
+        )
+    }
+
+    // ============================================================
+    // CATEGORY 5: emitPerfEvent / bridgeCallReceived / bridgeCallDispatched
+    // ============================================================
+
+    @Test
+    fun `emitPerfEvent is a no-op when PerfEventBuffer is disabled`() {
+        val webView: WebView = mock()
+        io.yourname.androidproject.utils.PerfEventBuffer.configure(enabled = false)
+
+        BridgeUtils.emitPerfEvent(webView, JSONObject().apply { put("type", "test") })
+
+        verify(webView, org.mockito.kotlin.never()).evaluateJavascript(any(), any())
+    }
+
+    @Test
+    fun `emitPerfEvent calls evaluateJavascript when enabled`() {
+        val webView: WebView = mock()
+        io.yourname.androidproject.utils.PerfEventBuffer.configure(enabled = true)
+
+        try {
+            BridgeUtils.emitPerfEvent(webView, JSONObject().apply { put("type", "test") })
+            verify(webView).evaluateJavascript(any(), isNull())
+        } finally {
+            io.yourname.androidproject.utils.PerfEventBuffer.configure(enabled = false)
+        }
+    }
+
+    @Test
+    fun `bridgeCallReceived and bridgeCallDispatched do not throw`() {
+        // BuildConfig.DEBUG's value in a JVM unit test depends on the build
+        // variant under test; either branch (no-op or delegate to
+        // PerfEventBuffer) should complete without throwing.
+        BridgeUtils.bridgeCallReceived("call-1", "getDeviceInfo")
+        BridgeUtils.bridgeCallDispatched("call-1")
+    }
+
+    // ============================================================
+    // CATEGORY 6: log helpers
+    // ============================================================
+
+    @Test
+    fun `logDebug, logError, logInfo, and logWarning do not throw`() {
+        BridgeUtils.logDebug("TAG", "debug message")
+        BridgeUtils.logError("TAG", "error message")
+        BridgeUtils.logError("TAG", "error with throwable", RuntimeException("boom"))
+        BridgeUtils.logInfo("TAG", "info message")
+        BridgeUtils.logWarning("TAG", "warning message")
+    }
+
+    // ============================================================
+    // CATEGORY 7: safeExecute
+    // ============================================================
+
+    @Test
+    fun `safeExecute runs the block and does not notify web on success`() {
+        val webView: WebView = mock()
+        var ran = false
+
+        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.ON_CAMERA_ERROR, "test op") {
+            ran = true
+        }
+
+        assertTrue(ran)
+        verify(webView, org.mockito.kotlin.never()).evaluateJavascript(any(), any())
+    }
+
+    @Test
+    fun `safeExecute catches an exception and notifies web with a formatted error`() {
+        val webView: WebView = mock()
+
+        BridgeUtils.safeExecute(webView, BridgeUtils.WebEvents.ON_CAMERA_ERROR, "test op") {
+            throw RuntimeException("boom")
+        }
+
+        verify(webView).evaluateJavascript(
+            eq("window.WebBridge.callback('ON_CAMERA_ERROR', ${JSONObject.quote("Failed to test op: boom")})"),
+            isNull()
+        )
+    }
 }