fix: Resilient patch bundle loading + quieter ADB logging + unique version output naming (#224)

- Failing to load a patch source now properly throws an error instead of
loading forever. We also show a banner mentioning that a patch source
has failed to load.
- abd logs are now quieter. Now only connect, disconnect, and status
transitions are logged.
- Output names already tried to encode the app version, but it came from
the input filename, so a renamed input fell back to "patched" and
different app versions overwrote each other. The app version is now read
from the APK manifest (versionName) properly.
- Also changed how the LEDs work on the source sheet and the source
pill. The LEDs now properly reflect the state of the patch source
instead of just showing what is active or inactive.
- Patcher version is now properly read from classpath instead of
trusting the libs.toml file.
- Patch load failures no longer surface as a blank "Failed to load".
Full chain is logged and shown in the UI. (Even when the .message is
null (might need more fixing in other places.)
- Log the patcher and library info in the logs and the tools dialog.

---------

Co-authored-by: semantic-release-bot <semantic-release-bot@martynus.net>

Author: prateek-who

build.gradle.kts

@@ -237,14 +237,46 @@ tasks {
         }
     }
 
+    // Write the *resolved* morphe library version (not the catalog pin). Patcher ships
+    // its own version.properties.
+    val writeMorpheComponents = register("writeMorpheComponents") {
+        description = "Writes the resolved morphe-library version to components.properties"
+        val outFile = layout.buildDirectory.file(
+            "generated/morphe-components/app/morphe/cli/components.properties",
+        )
+        val runtimeCp = configurations.named("runtimeClasspath")
+        inputs.files(runtimeCp)
+        outputs.file(outFile)
+        doLast {
+            val libraryVersion = runtimeCp.get().incoming.resolutionResult.allComponents
+                .mapNotNull { it.moduleVersion }
+                .firstOrNull { it.group == "app.morphe" && it.name.startsWith("morphe-library") }
+                ?.version
+                ?: "unknown"
+            outFile.get().asFile.apply {
+                parentFile.mkdirs()
+                writeText(
+                    "# Generated from resolved runtimeClasspath — do not edit\n" +
+                        "libraryVersion=$libraryVersion\n",
+                )
+            }
+        }
+    }
+
     processResources {
         // Make sure the licenses are generated before the resources are processed
-        dependsOn("exportLibraryDefinitions")
+        dependsOn("exportLibraryDefinitions", writeMorpheComponents)
         from(layout.buildDirectory.file("generated/aboutLibraries/aboutlibraries.json"))
+        from(layout.buildDirectory.dir("generated/morphe-components"))
 
-        // Only expand properties files, not binary files like PNG/ICO
+        // Only expand properties files, not binary files like PNG/ICO.
+        // Patcher is read from its jar at runtime. libraryVersion lives in
+        // components.properties generated above, skip token expansion for it.
         filesMatching("**/*.properties") {
-            expand("projectVersion" to project.version)
+            if (path.contains("components.properties")) return@filesMatching
+            expand(
+                "projectVersion" to project.version,
+            )
         }
         // Bundle the project's NOTICE (GPL 7b/7c) and LICENSE into META-INF so they
         // land in the main JAR before the Shadow merge. Source of truth stays at the

src/main/kotlin/app/morphe/engine/MorpheComponents.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2026 Morphe.
+ * https://github.com/MorpheApp/morphe-desktop
+ */
+
+package app.morphe.engine
+
+import java.util.Properties
+
+/**
+ * Versions of Morphe ecosystem components that this desktop build is running against.
+ *
+ * Prefer each library's own embedded resource when present (so composite/local
+ * substitutions report the truth). Fall back to build-time resolved metadata only
+ * when a library does not ship a version resource (currently: morphe-library).
+ */
+object MorpheComponents {
+
+    /** morphe-patcher on the classpath (`app/morphe/patcher/version.properties`). */
+    val patcherVersion: String? by lazy {
+        readVersionProperty("/app/morphe/patcher/version.properties", "version")
+    }
+
+    /**
+     * morphe-library on the classpath.
+     * Prefers `app/morphe/library/version.properties` if the library starts shipping it;
+     * otherwise the build-time resolved version in `app/morphe/cli/components.properties`.
+     */
+    val libraryVersion: String? by lazy {
+        readVersionProperty("/app/morphe/library/version.properties", "version")
+            ?: readVersionProperty("/app/morphe/cli/components.properties", "libraryVersion")
+    }
+
+    private fun readVersionProperty(resourcePath: String, key: String): String? =
+        runCatching {
+            MorpheComponents::class.java
+                .getResourceAsStream(resourcePath)
+                ?.use { Properties().apply { load(it) }.getProperty(key) }
+                ?.trim()
+                ?.takeUnless { it.isEmpty() || it.startsWith("\${") }
+        }.getOrNull()
+}

src/main/kotlin/app/morphe/engine/MultiSourceLoader.kt

@@ -13,6 +13,7 @@ import kotlinx.coroutines.awaitAll
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.withContext
 import java.io.File
+import java.util.logging.Level
 import java.util.logging.Logger
 
 /**
@@ -94,13 +95,36 @@ object MultiSourceLoader {
                 sourceName = input.sourceName,
                 patches = patches,
             )
-        } catch (e: Exception) {
-            logger.warning("MultiSourceLoader: failed to load '${input.sourceName}': ${e.message}")
+        } catch (e: Throwable) {
+            // Catch Throwable, not just Exception: a bundle built against a newer patcher
+            // throws java.lang.Error (NoSuchMethodError / NoClassDefFoundError / LinkageError)
+            // because it references patcher APIs missing here. As an Error it would escape a
+            // catch(Exception), sink the whole load, and hang the UI on "loading" forever.
+            // Isolating it per source keeps one bad bundle from taking the others down, and
+            // lets us surface a clear "update Morphe" message (mirrors morphe-manager).
+            //
+            // Do NOT swallow the real failure: many Errors have a null .message (e.g.
+            // ExceptionInInitializerError) with the useful text on .cause. We always store an
+            // exception whose message walks the full cause chain, and log the full stack.
+            val versionMsg = PatcherCompatibility.incompatibilityMessage(input.patchFile)
+            val error: Throwable = if (versionMsg != null) {
+                PatchBundleIncompatibleException(versionMsg)
+            } else {
+                PatchSourceLoadException(e.readableMessage(), e)
+            }
+            logger.log(
+                Level.WARNING,
+                "MultiSourceLoader: failed to load '${input.sourceName}': ${error.message}",
+                e,
+            )
+            // Also stderr so IDE runs / headless CLI see the stack even if JUL is unconfigured.
+            System.err.println("MultiSourceLoader: failed to load '${input.sourceName}': ${error.message}")
+            e.printStackTrace(System.err)
             LoadedSource(
                 sourceId = input.sourceId,
                 sourceName = input.sourceName,
                 patches = emptySet(),
-                error = e,
+                error = error,
             )
         } finally {
             tempCopy.deleteOnExit()

src/main/kotlin/app/morphe/engine/PatcherCompatibility.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2026 Morphe.
+ * https://github.com/MorpheApp/morphe-desktop
+ */
+
+package app.morphe.engine
+
+import java.io.File
+import java.util.zip.ZipInputStream
+import java.util.logging.Logger
+
+/**
+ * Detects when a patch bundle (.mpp) was built against a newer morphe-patcher than this
+ * build ships. Such a bundle fails to load with a `java.lang.Error` (NoSuchMethodError,
+ * NoClassDefFoundError, LinkageError) because it references patcher APIs that do not exist
+ * here, which otherwise surfaces as a cryptic failure. This turns it into a clear "update
+ * Morphe" message, mirroring how morphe-manager reads the bundle's `Patcher-Version`
+ * manifest attribute and compares it to the patcher it ships.
+ *
+ * The "ships" version is read from the **patcher library on the classpath**
+ * (`app/morphe/patcher/version.properties`), not from the desktop app's version catalog.
+ * That way a composite/local `morphe-patcher` (or any resolved artifact) reports its own
+ * version instead of a stale catalog pin in `libs.versions.toml`.
+ *
+ * Deliberately lenient: any doubt (missing attribute, unparseable version, unreadable file)
+ * returns null so a valid bundle is never wrongly rejected.
+ */
+object PatcherCompatibility {
+
+    private val logger = Logger.getLogger(PatcherCompatibility::class.java.name)
+
+    /**
+     * The morphe-patcher version on the classpath (see [MorpheComponents.patcherVersion]).
+     */
+    val currentPatcherVersion: String? get() = MorpheComponents.patcherVersion
+
+    /**
+     * The morphe-patcher version [mpp] requires, from its `Patcher-Version` manifest
+     * attribute. Null when the bundle predates that attribute or can't be read.
+     */
+    fun requiredPatcherVersion(mpp: File): String? = runCatching {
+        mpp.inputStream().use { fis ->
+            ZipInputStream(fis).use { zip ->
+                var entry = zip.nextEntry
+                while (entry != null) {
+                    if (entry.name == "META-INF/MANIFEST.MF") {
+                        return@runCatching manifestAttr(zip.bufferedReader().readText(), "Patcher-Version")
+                    }
+                    entry = zip.nextEntry
+                }
+                null
+            }
+        }
+    }.getOrNull()
+
+    /**
+     * A user-facing explanation when [mpp] needs a newer patcher than this build ships, or
+     * null when compatible / unknown (never blocks on doubt).
+     */
+    fun incompatibilityMessage(mpp: File): String? {
+        val required = requiredPatcherVersion(mpp) ?: return null
+        val current = currentPatcherVersion ?: return null
+        if (!isNewer(required, current)) return null
+        logger.info("Bundle ${mpp.name} needs patcher $required, this build ships $current")
+        return "This patch bundle needs Morphe patcher $required, but this build ships $current. " +
+            "Update Morphe to use it."
+    }
+
+    private fun manifestAttr(manifest: String, key: String): String? =
+        manifest.lineSequence()
+            .firstOrNull { it.substringBefore(':', "").trim().equals(key, ignoreCase = true) }
+            ?.substringAfter(':')?.trim()
+            ?.takeUnless { it.isBlank() || it.equals("na", ignoreCase = true) }
+
+    /** True when version [a] is newer than [b]. Compares numeric components, ignores pre-release. */
+    private fun isNewer(a: String, b: String): Boolean {
+        val pa = numericParts(a)
+        val pb = numericParts(b)
+        for (i in 0 until maxOf(pa.size, pb.size)) {
+            val x = pa.getOrElse(i) { 0 }
+            val y = pb.getOrElse(i) { 0 }
+            if (x != y) return x > y
+        }
+        return false
+    }
+
+    private fun numericParts(v: String): List<Int> =
+        v.substringBefore('-').split('.').map { it.trim().toIntOrNull() ?: 0 }
+}
+
+/**
+ * A patch bundle that could not be loaded because it needs a newer patcher than this build
+ * ships. Its [message] is already user-facing (from [PatcherCompatibility.incompatibilityMessage]).
+ */
+class PatchBundleIncompatibleException(message: String) : Exception(message)

src/main/kotlin/app/morphe/engine/ThrowableMessages.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2026 Morphe.
+ * https://github.com/MorpheApp/morphe-desktop
+ */
+
+package app.morphe.engine
+
+import java.io.PrintWriter
+import java.io.StringWriter
+
+/**
+ * Helpers for turning throwables into something a human (or log file) can actually use.
+ *
+ * Many JVM errors, notably [ExceptionInInitializerError] have a **null** [Throwable.message]
+ * and bury the real explanation on [Throwable.cause]. Call sites that only read `.message`
+ * then surface useless copy like "Failed to load".
+ */
+
+/**
+ * Quick description of this throwable and its cause chain.
+ *
+ * Example:
+ * `ExceptionInInitializerError:
+ * Cause by: UninitializedPropertyAccessException: lateinit property x has not been initialized`
+ */
+fun Throwable.readableMessage(): String {
+    val chain = generateSequence(this) { it.cause }.toList()
+    val parts = chain.map { t ->
+        val msg = t.message?.trim()?.takeIf { it.isNotEmpty() }
+        if (msg != null) "${t.javaClass.simpleName}: $msg" else t.javaClass.simpleName
+    }
+    // Drop pure type-only prefixes once we hit a frame that has a message, but keep the
+    // whole chain so nested init/reflection failures stay diagnosable.
+    return parts.joinToString("\nCaused by: ").ifBlank { javaClass.name }
+}
+
+/** Full stack trace as a string (for file / stderr logging). */
+fun Throwable.stackTraceString(): String {
+    val sw = StringWriter()
+    printStackTrace(PrintWriter(sw))
+    return sw.toString()
+}
+
+/**
+ * Load failure for one patch source. Always carries a non-blank [message] so UI layers
+ * never fall back to generic "Failed to load". The original throwable is [cause].
+ */
+class PatchSourceLoadException(
+    message: String,
+    cause: Throwable? = null,
+) : Exception(message, cause)

src/main/kotlin/app/morphe/engine/util/ApkOutputNaming.kt

@@ -67,6 +67,15 @@ object ApkOutputNaming {
     fun resolveAppDisplayName(apkFile: File): String? =
         ApkManifestReader.read(apkFile)?.applicationLabel?.takeIf { it.isNotBlank() }
 
+    /**
+     * The app's versionName from its manifest (engine [ApkManifestReader]), or null when it
+     * can't be read or is blank. The reliable source of the app version, unlike
+     * [extractApkVersionFromFilename], which only works when the input file follows the
+     * APKMirror naming convention.
+     */
+    fun resolveAppVersion(apkFile: File): String? =
+        ApkManifestReader.read(apkFile)?.versionName?.takeIf { it.isNotBlank() }
+
     /**
      * Compute the unified output APK path. Layout:
      * `<base>/<appName>/<appName>-Morphe-{apkVer}-patches-{patchesVer}.apk`
@@ -94,16 +103,34 @@ object ApkOutputNaming {
         patchesFile: File? = null,
         baseOutputDir: File? = null,
         appDisplayName: String? = null,
+        appVersion: String? = null,
     ): File {
         val appFolderName = (appDisplayName ?: inputApk.nameWithoutExtension)
             .replace(" ", "-")
         val base = baseOutputDir
             ?: inputApk.absoluteFile.parentFile
             ?: File("").absoluteFile
         val outputDir = File(base, appFolderName).also { it.mkdirs() }
-        val version = extractApkVersionFromFilename(inputApk.name) ?: "patched"
+        // App version, most reliable first: a version the caller already resolved, then the
+        // APK manifest's versionName, then the input filename (APKMirror convention), then a
+        // constant. Reading it from the manifest is what keeps the output unique by app
+        // version even when the input file was renamed (e.g. base.apk) — the filename-only
+        // path fell back to "patched" and collided across versions.
+        val version = sanitizeForFilename(
+            appVersion?.takeIf { it.isUsableVersion() }
+                ?: resolveAppVersion(inputApk)
+                ?: extractApkVersionFromFilename(inputApk.name)
+                ?: "patched"
+        )
         val patchesVersion = patchesFile?.name?.let { extractPatchesVersion(it) }
         val patchesSuffix = if (patchesVersion != null) "-patches-$patchesVersion" else ""
         return File(outputDir, "${appFolderName}-Morphe-${version}${patchesSuffix}.apk")
     }
+
+    private fun String.isUsableVersion(): Boolean =
+        isNotBlank() && !equals("unknown", ignoreCase = true)
+
+    /** Keep a versionName filename-safe: some apps put spaces or symbols in versionName. */
+    private fun sanitizeForFilename(v: String): String =
+        v.trim().replace(Regex("""[^A-Za-z0-9.\-_]"""), "-").ifBlank { "patched" }
 }

src/main/kotlin/app/morphe/gui/di/AppModule.kt

@@ -110,6 +110,7 @@ val appModule = module {
             params.get(),
             params.get(),
             params.get(),
+            params.get(),
         )
     }
     factory { params ->