chore: Merge branch dev to main

Author: AzyrRuthless

CHANGELOG.md

@@ -1,17 +1,11 @@
-# 1.0.0 (2026-01-11)
-
-
-### Bug Fixes
-
-* Migrate to new package, use maven patcher dependency ([0b50811](https://github.com/AzyrRuthless/morphe-cli/commit/0b50811a5a2a0a574538b2fbffe027c04613db6c))
-* Use patcher / library 1.0.1 release ([0ca02e9](https://github.com/AzyrRuthless/morphe-cli/commit/0ca02e920b9e3189ac2b3a18587f0fb9efd0de4e))
-* Use repo library release ([0e4fae1](https://github.com/AzyrRuthless/morphe-cli/commit/0e4fae1b24bb21baa5004126df364b736d84270b))
+# [1.1.0-dev.1](https://github.com/AzyrRuthless/morphe-cli/compare/v1.0.0...v1.1.0-dev.1) (2026-02-06)
 
 
 ### Features
 
-* add command option `unsigned` ([#20](https://github.com/AzyrRuthless/morphe-cli/issues/20)) ([4505091](https://github.com/AzyrRuthless/morphe-cli/commit/4505091624b854706b39656bae642e5dc1132dcd))
-* Initial release ([874ecbc](https://github.com/AzyrRuthless/morphe-cli/commit/874ecbce34d6499882f7a5cf648bd828c823935a))
+* Add ability to write patching results to JSON file ([#25](https://github.com/AzyrRuthless/morphe-cli/issues/25)) ([ed0d1ef](https://github.com/AzyrRuthless/morphe-cli/commit/ed0d1ef4150411c8027156bad8338194480b4e88))
+* Update to Morphe patcher / library 1.1.0 ([2445b24](https://github.com/AzyrRuthless/morphe-cli/commit/2445b24656228dd5c487e18fe6e441d5b8b6204b))
+* Update to Morphe patcher 1.1.1 ([8fa5a83](https://github.com/AzyrRuthless/morphe-cli/commit/8fa5a83d18fa35668d1d07a852bda62a452c0ad7))
 
 # 1.0.0-dev.1 (2026-01-11)
 

build.gradle.kts

@@ -2,6 +2,7 @@ import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     alias(libs.plugins.kotlin)
+    alias(libs.plugins.kotlin.serialization)
     alias(libs.plugins.shadow)
     application
     `maven-publish`
@@ -35,6 +36,7 @@ dependencies {
     implementation(libs.morphe.patcher)
     implementation(libs.morphe.library)
     implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.kotlinx.serialization.json)
     implementation(libs.picocli)
 
     testImplementation(libs.kotlin.test)

gradle.properties

@@ -1,4 +1,4 @@
 org.gradle.parallel = true
 org.gradle.caching = true
 kotlin.code.style = official
-version = 1.0.0
+version = 1.1.0-dev.1

gradle/libs.versions.toml

@@ -1,18 +1,20 @@
 [versions]
 shadow = "8.3.9"
-kotlin = "2.0.21"
-kotlinx = "1.8.1"
+kotlin = "2.3.0"
+kotlinx = "1.9.0"
 picocli = "4.7.7"
-morphe-patcher = "1.0.1"
-morphe-library = "1.0.1"
+morphe-patcher = "1.1.1"
+morphe-library = "1.2.0"
 
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx" }
 picocli = { module = "info.picocli:picocli", version.ref = "picocli" }
 morphe-patcher = { module = "app.morphe:morphe-patcher", version.ref = "morphe-patcher" }
 morphe-library = { module = "app.morphe:morphe-library-jvm", version.ref = "morphe-library" }
 
 [plugins]
 shadow = { id = "com.gradleup.shadow", version.ref = "shadow" }
 kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

src/main/kotlin/app/morphe/cli/command/PatchCommand.kt

@@ -1,5 +1,11 @@
 package app.morphe.cli.command
 
+import app.morphe.cli.command.model.FailedPatch
+import app.morphe.cli.command.model.PatchingResult
+import app.morphe.cli.command.model.PatchingStep
+import app.morphe.cli.command.model.PatchingStepResult
+import app.morphe.cli.command.model.addStepResult
+import app.morphe.cli.command.model.toSerializablePatch
 import app.morphe.library.ApkUtils
 import app.morphe.library.ApkUtils.applyTo
 import app.morphe.library.installation.installer.*
@@ -9,6 +15,9 @@ import app.morphe.patcher.PatcherConfig
 import app.morphe.patcher.patch.Patch
 import app.morphe.patcher.patch.loadPatchesFromJar
 import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.encodeToStream
 import picocli.CommandLine
 import picocli.CommandLine.ArgGroup
 import picocli.CommandLine.Help.Visibility.ALWAYS
@@ -25,6 +34,7 @@ import java.util.zip.ZipEntry
 import java.util.zip.ZipFile
 import java.util.zip.ZipOutputStream
 
+@OptIn(ExperimentalSerializationApi::class)
 @CommandLine.Command(
     name = "patch",
     description = ["Patch an APK file."],
@@ -121,6 +131,17 @@ internal object PatchCommand : Runnable {
         this.outputFilePath = outputFilePath?.absoluteFile
     }
 
+    private var patchingResultOutputFilePath: File? = null
+
+    @CommandLine.Option(
+        names = ["-r", "--result-file"],
+        description = ["Path to save the patching result file to"],
+    )
+    @Suppress("unused")
+    private fun setPatchingResultOutputFilePath(outputFilePath: File?) {
+        this.patchingResultOutputFilePath = outputFilePath?.absoluteFile
+    }
+
     @CommandLine.Option(
         names = ["-i", "--install"],
         description = ["Serial of the ADB device to install to. If not specified, the first connected device will be used."],
@@ -310,118 +331,168 @@ internal object PatchCommand : Runnable {
 
         val patcherTemporaryFilesPath = temporaryFilesPath.resolve("patcher")
 
-        val (packageName, patcherResult) = Patcher(
-            PatcherConfig(
-                apk,
-                patcherTemporaryFilesPath,
-                aaptBinaryPath?.path,
-                patcherTemporaryFilesPath.absolutePath,
-            ),
-        ).use { patcher ->
-            val packageName = patcher.context.packageMetadata.packageName
-            val packageVersion = patcher.context.packageMetadata.packageVersion
-
-            val filteredPatches = patches.filterPatchSelection(packageName, packageVersion)
-
-            logger.info("Setting patch options")
-
-            val patchesList = patches.toList()
-            selection.filter { it.enabled != null }.associate {
-                val enabledSelection = it.enabled!!
-
-                (enabledSelection.selector.name ?: patchesList[enabledSelection.selector.index!!].name!!) to
-                    enabledSelection.options
-            }.let(filteredPatches::setOptions)
-
-            patcher += filteredPatches
-
-            // Execute patches.
-            runBlocking {
-                patcher().collect { patchResult ->
-                    val exception = patchResult.exception
-                        ?: return@collect logger.info("\"${patchResult.patch}\" succeeded")
-
-                    StringWriter().use { writer ->
-                        exception.printStackTrace(PrintWriter(writer))
-
-                        logger.severe("\"${patchResult.patch}\" failed:\n$writer")
+        val patchingResult = PatchingResult()
+
+        try {
+            val (packageName, patcherResult) = Patcher(
+                PatcherConfig(
+                    apk,
+                    patcherTemporaryFilesPath,
+                    aaptBinaryPath?.path,
+                    patcherTemporaryFilesPath.absolutePath,
+                ),
+            ).use { patcher ->
+                val packageName = patcher.context.packageMetadata.packageName
+                val packageVersion = patcher.context.packageMetadata.packageVersion
+
+                patchingResult.packageName = packageName
+                patchingResult.packageVersion = packageVersion
+
+                val filteredPatches = patches.filterPatchSelection(packageName, packageVersion)
+
+                logger.info("Setting patch options")
+
+                val patchesList = patches.toList()
+                selection.filter { it.enabled != null }.associate {
+                    val enabledSelection = it.enabled!!
+
+                    (enabledSelection.selector.name ?: patchesList[enabledSelection.selector.index!!].name!!) to
+                        enabledSelection.options
+                }.let(filteredPatches::setOptions)
+
+                patcher += filteredPatches
+
+                // Execute patches.
+                patchingResult.addStepResult(
+                    PatchingStep.PATCHING,
+                    {
+                        runBlocking {
+                            patcher().collect { patchResult ->
+                                patchResult.exception?.let { exception ->
+                                    StringWriter().use { writer ->
+                                        exception.printStackTrace(PrintWriter(writer))
+
+                                        logger.severe("\"${patchResult.patch}\" failed:\n$writer")
+
+                                        patchingResult.failedPatches.add(
+                                            FailedPatch(
+                                                patchResult.patch.toSerializablePatch(),
+                                                writer.toString()
+                                            )
+                                        )
+                                        patchingResult.success = false
+                                    }
+                                } ?: patchResult.patch.let {
+                                    patchingResult.appliedPatches.add(patchResult.patch.toSerializablePatch())
+                                    logger.info("\"${patchResult.patch}\" succeeded")
+                                }
+                            }
+                        }
                     }
-                }
+                )
+
+                patcher.context.packageMetadata.packageName to patcher.get()
             }
 
-            patcher.context.packageMetadata.packageName to patcher.get()
-        }
+            // region Save.
 
-        // region Save.
+            apk.copyTo(temporaryFilesPath.resolve(apk.name), overwrite = true).apply {
+                patchingResult.addStepResult(
+                    PatchingStep.REBUILDING,
+                    {
+                        // 1. Apply patches to the APK
+                        patcherResult.applyTo(this)
 
-        apk.copyTo(temporaryFilesPath.resolve(apk.name), overwrite = true).apply {
-            patcherResult.applyTo(this)
-        }.let { patchedApkFile ->
+                        // 2. Rip Libraries (if requested)
+                        if (ripLibs.isNotEmpty()) {
+                            ripLibraries(this, ripLibs)
+                        }
 
-            if (ripLibs.isNotEmpty()) {
-                ripLibraries(patchedApkFile, ripLibs)
-            }
+                        // 3. Zipalign (if not mounting)
+                        if (!mount) {
+                            logger.info("Running zipalign")
+                            val alignedApk = File.createTempFile("aligned", ".apk", temporaryFilesPath)
+                            val zipalign = zipalignBinaryPath?.absolutePath ?: "zipalign"
 
-            // zipalign logic start
-            if (!mount) {
-                logger.info("Running zipalign")
-                val alignedApk = File.createTempFile("aligned", ".apk", temporaryFilesPath)
-                val zipalign = zipalignBinaryPath?.absolutePath ?: "zipalign"
+                            val process = ProcessBuilder(
+                                zipalign, "-p", "-f", "4",
+                                this.absolutePath,
+                                alignedApk.absolutePath
+                            ).redirectErrorStream(true).start()
 
-                val process = ProcessBuilder(
-                    zipalign, "-p", "-f", "4",
-                    patchedApkFile.absolutePath,
-                    alignedApk.absolutePath
-                ).redirectErrorStream(true).start()
+                            // Consume output to prevent buffer blocking and for debug logging
+                            val output = process.inputStream.bufferedReader().use { it.readText() }
+                            val exitCode = process.waitFor()
 
-                // Consume output to prevent buffer blocking and for debug logging
-                val output = process.inputStream.bufferedReader().use { it.readText() }
-                val exitCode = process.waitFor()
+                            if (exitCode != 0) {
+                                throw RuntimeException("zipalign failed (exit code $exitCode):\n$output")
+                            }
 
-                if (exitCode != 0) {
-                    throw RuntimeException("zipalign failed (exit code $exitCode):\n$output")
+                            Files.move(alignedApk.toPath(), this.toPath(), StandardCopyOption.REPLACE_EXISTING)
+                            logger.info("zipalign completed")
+                        }
+                    }
+                )
+            }.let { patchedApkFile ->
+                if (!mount && !unsigned) {
+                    patchingResult.addStepResult(
+                        PatchingStep.SIGNING,
+                        {
+                            ApkUtils.signApk(
+                                patchedApkFile,
+                                outputFilePath,
+                                signer,
+                                ApkUtils.KeyStoreDetails(
+                                    keystoreFilePath,
+                                    keyStorePassword,
+                                    keyStoreEntryAlias,
+                                    keyStoreEntryPassword,
+                                ),
+                            )
+                        }
+                    )
+                } else {
+                    patchedApkFile.copyTo(outputFilePath, overwrite = true)
                 }
-
-                Files.move(alignedApk.toPath(), patchedApkFile.toPath(), StandardCopyOption.REPLACE_EXISTING)
-                logger.info("zipalign completed")
             }
-            // zipalign logic end
-
-            if (!mount && !unsigned) {
-                ApkUtils.signApk(
-                    patchedApkFile,
-                    outputFilePath,
-                    signer,
-                    ApkUtils.KeyStoreDetails(
-                        keystoreFilePath,
-                        keyStorePassword,
-                        keyStoreEntryAlias,
-                        keyStoreEntryPassword,
-                    ),
+            logger.info("Saved to $outputFilePath")
+
+            // endregion
+
+            // region Install.
+
+            deviceSerial?.let {
+                patchingResult.addStepResult(
+                    PatchingStep.INSTALLING,
+                    {
+                        runBlocking {
+                            val result = installer!!.install(Installer.Apk(outputFilePath, packageName))
+                            when (result) {
+                                RootInstallerResult.FAILURE -> {
+                                    logger.severe("Failed to mount the patched APK file")
+                                    throw IllegalStateException("Failed to mount the patched APK file")
+                                }
+                                is AdbInstallerResult.Failure -> {
+                                    logger.severe(result.exception.toString())
+                                    throw result.exception
+                                }
+                                else -> logger.info("Installed the patched APK file")
+                            }
+                        }
+                    }
                 )
-            } else {
-                patchedApkFile.copyTo(outputFilePath, overwrite = true)
             }
-        }
 
-        logger.info("Saved to $outputFilePath")
-
-        // endregion
-
-        // region Install.
-
-        deviceSerial?.let {
-            runBlocking {
-                when (val result = installer!!.install(Installer.Apk(outputFilePath, packageName))) {
-                    RootInstallerResult.FAILURE -> logger.severe("Failed to mount the patched APK file")
-                    is AdbInstallerResult.Failure -> logger.severe(result.exception.toString())
-                    else -> logger.info("Installed the patched APK file")
+            // endregion
+        } finally {
+            patchingResultOutputFilePath?.let { outputFile ->
+                outputFile.outputStream().use { outputStream ->
+                    Json.encodeToStream(patchingResult, outputStream)
                 }
+                logger.info("Patching result saved to $outputFile")
             }
         }
 
-        // endregion
-
         if (purge) {
             logger.info("Purging temporary files")
             purge(temporaryFilesPath)

src/main/kotlin/app/morphe/cli/command/model/FailedPatch.kt

@@ -0,0 +1,11 @@
+package app.morphe.cli.command.model
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.Serializable
+
+@ExperimentalSerializationApi
+@Serializable
+data class FailedPatch(
+    val patch: SerializablePatch,
+    val reason: String
+)