chore(release): 2.5.3 [skip ci]

## [2.5.3](https://github.com/revanced/revanced-cli/compare/v2.5.2...v2.5.3) (2022-07-11)

### Bug Fixes

* Log not showing in CLI  ([#80](https://github.com/revanced/revanced-cli/issues/80)) ([d9c5a17](d9c5a179c5)), closes [#79](https://github.com/revanced/revanced-cli/issues/79)

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Create a bug report on the CLI. Do not submit suggestions for patches here.
+title: 'problem: some problem'
+labels: bug
+
+---
+
+# 🐞 Issue
+
+<!-- Describe your issue in detail here -->
+
+# ⚙ Reproduce
+
+<!-- Include your environment and steps to reproduce the issue as detailed as possible -->
+
+# 🛠 Solution
+
+<!-- If applicable, add a possible solution -->
+
+# ⚠ Additional context
+
+<!-- Add any other context about the problem here -->

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: Feature request
+about: Suggest a change to the CLI. Do not submit suggestions for patches here.
+title: 'feat: some feature'
+labels: feature-request
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.releaserc

@@ -7,7 +7,11 @@
     }
   ],
   "plugins": [
-    "@semantic-release/commit-analyzer",
+    ["@semantic-release/commit-analyzer", {
+      "releaseRules": [
+        {"type": "build", "release": "patch"}
+      ]
+    }],
     "@semantic-release/release-notes-generator",
     "@semantic-release/changelog",
     "gradle-semantic-release-plugin",

CHANGELOG.md

@@ -1,3 +1,197 @@
+## [2.5.3](https://github.com/revanced/revanced-cli/compare/v2.5.2...v2.5.3) (2022-07-11)
+
+
+### Bug Fixes
+
+* Log not showing in CLI  ([#80](https://github.com/revanced/revanced-cli/issues/80)) ([d9c5a17](https://github.com/revanced/revanced-cli/commit/d9c5a179c529c386f66df4fa63cd321d396836b5)), closes [#79](https://github.com/revanced/revanced-cli/issues/79)
+
+## [2.5.2](https://github.com/revanced/revanced-cli/compare/v2.5.1...v2.5.2) (2022-07-10)
+
+
+### Bug Fixes
+
+* `defaultExclude` unused ([2015c2a](https://github.com/revanced/revanced-cli/commit/2015c2a1dcc0290af237e2eb1ab4aaf5fc84d382))
+
+## [2.5.1](https://github.com/revanced/revanced-cli/compare/v2.5.0...v2.5.1) (2022-07-10)
+
+
+### Bug Fixes
+
+* Make clear what the --exclusive command actually does ([a26b0ea](https://github.com/revanced/revanced-cli/commit/a26b0ea64dcd0757b5b49c09137959751874d955))
+
+# [2.5.0](https://github.com/revanced/revanced-cli/compare/v2.4.0...v2.5.0) (2022-07-10)
+
+
+### Bug Fixes
+
+* null exception when resource patching is disabled ([#85](https://github.com/revanced/revanced-cli/issues/85)) ([125fa06](https://github.com/revanced/revanced-cli/commit/125fa06ca6bac66f790e4aba66887464189b3a63))
+* remove `excludePatches` check ([eb83cab](https://github.com/revanced/revanced-cli/commit/eb83cabfff6fbc28dd892f15b8e28278e284caa9))
+
+
+### Features
+
+* `--exclusive` switch ([#78](https://github.com/revanced/revanced-cli/issues/78)) ([8e91c12](https://github.com/revanced/revanced-cli/commit/8e91c12c5e3864c369005ef9fe7d9db668e86701))
+* `--uninstall` switch ([#84](https://github.com/revanced/revanced-cli/issues/84)) ([131100e](https://github.com/revanced/revanced-cli/commit/131100ef0043924a9c11eb9886b4f6b0373690d9))
+
+# [2.4.0](https://github.com/revanced/revanced-cli/compare/v2.3.3...v2.4.0) (2022-07-10)
+
+
+### Bug Fixes
+
+* wrong label in additional items [skip ci] ([cd3ded1](https://github.com/revanced/revanced-cli/commit/cd3ded1fbdb0c8eb7485912d5cbd6a2dd7455658))
+
+
+### Features
+
+* better output for excluded patches ([#77](https://github.com/revanced/revanced-cli/issues/77)) ([ac7c7a9](https://github.com/revanced/revanced-cli/commit/ac7c7a9a1a5c08322e3b206780d4f31104d8b570))
+* issue templates [skip ci] ([bac8c67](https://github.com/revanced/revanced-cli/commit/bac8c67d6f7bc10a38bb98a2f6e3f5cf6fa2e3e1))
+
+## [2.3.3](https://github.com/revanced/revanced-cli/compare/v2.3.2...v2.3.3) (2022-07-09)
+
+## [2.3.2](https://github.com/revanced/revanced-cli/compare/v2.3.1...v2.3.2) (2022-07-05)
+
+
+### Bug Fixes
+
+* fix noSuchMethodError ([00fec25](https://github.com/revanced/revanced-cli/commit/00fec2508a3421b7b5a246254e0cb08850eab6ea))
+
+## [2.3.1](https://github.com/revanced/revanced-cli/compare/v2.3.0...v2.3.1) (2022-07-04)
+
+# [2.3.0](https://github.com/revanced/revanced-cli/compare/v2.2.0...v2.3.0) (2022-07-03)
+
+
+### Features
+
+* separate logger to stdout & stderr ([#63](https://github.com/revanced/revanced-cli/issues/63)) ([0ddc2b5](https://github.com/revanced/revanced-cli/commit/0ddc2b54b739dae3e8ccc983bab73fc84e72be0a))
+
+# [2.2.0](https://github.com/revanced/revanced-cli/compare/v2.1.0...v2.2.0) (2022-07-03)
+
+
+### Features
+
+* separate options for `--list` ([#60](https://github.com/revanced/revanced-cli/issues/60)) ([52b3161](https://github.com/revanced/revanced-cli/commit/52b316150de397ebdee979caf51d4cb20961cf70))
+
+# [2.1.0](https://github.com/revanced/revanced-cli/compare/v2.0.5...v2.1.0) (2022-07-03)
+
+
+### Features
+
+* `--include` option ([#76](https://github.com/revanced/revanced-cli/issues/76)) ([57a1e7c](https://github.com/revanced/revanced-cli/commit/57a1e7c27fb0c4292e08332b88ccd57d69fa02c6))
+
+## [2.0.5](https://github.com/revanced/revanced-cli/compare/v2.0.4...v2.0.5) (2022-06-29)
+
+## [2.0.4](https://github.com/revanced/revanced-cli/compare/v2.0.3...v2.0.4) (2022-06-28)
+
+## [2.0.3](https://github.com/revanced/revanced-cli/compare/v2.0.2...v2.0.3) (2022-06-27)
+
+
+### Bug Fixes
+
+* wrong keystore output path ([20fa179](https://github.com/revanced/revanced-cli/commit/20fa17957e3e454b9755bc7b9b473b6c578cc593))
+
+## [2.0.2](https://github.com/revanced/revanced-cli/compare/v2.0.1...v2.0.2) (2022-06-27)
+
+
+### Bug Fixes
+
+* wrong separator when using `ZipFileSystemUtils` ([20e15de](https://github.com/revanced/revanced-cli/commit/20e15defc2b90aa5e79bad41c097bd0db8d5e12a))
+
+## [2.0.1](https://github.com/revanced/revanced-cli/compare/v2.0.0...v2.0.1) (2022-06-26)
+
+# [2.0.0](https://github.com/revanced/revanced-cli/compare/v1.11.1...v2.0.0) (2022-06-26)
+
+
+### Code Refactoring
+
+* migrate from `Signature` to `Fingerprint` ([88852a4](https://github.com/revanced/revanced-cli/commit/88852a45ac90ad9419c18f0cb3395745e62eadbf))
+
+
+### BREAKING CHANGES
+
+* Not backwards compatible, since a lot of classes where renamed.
+
+## [1.11.1](https://github.com/revanced/revanced-cli/compare/v1.11.0...v1.11.1) (2022-06-25)
+
+
+### Bug Fixes
+
+* update patcher version ([499ce0a](https://github.com/revanced/revanced-cli/commit/499ce0a6fb1993ad48ffdd9c9e8307e8d0c179c6))
+
+# [1.11.0](https://github.com/revanced/revanced-cli/compare/v1.10.2...v1.11.0) (2022-06-23)
+
+
+### Features
+
+* improve logging ([df85fa3](https://github.com/revanced/revanced-cli/commit/df85fa37ef067681a027e6fe9212c8a065d4981b))
+
+## [1.10.2](https://github.com/revanced/revanced-cli/compare/v1.10.1...v1.10.2) (2022-06-22)
+
+
+### Bug Fixes
+
+* keystore file not found exception ([#57](https://github.com/revanced/revanced-cli/issues/57)) ([5b8537e](https://github.com/revanced/revanced-cli/commit/5b8537e6b7922f1b44058c3a4fc2f56cb4e15e89))
+
+## [1.10.1](https://github.com/revanced/revanced-cli/compare/v1.10.0...v1.10.1) (2022-06-22)
+
+
+### Bug Fixes
+
+* show actual version in CLI ([1dcdbc9](https://github.com/revanced/revanced-cli/commit/1dcdbc9fe9e3ad2fe232ad3baa76d186817532a4))
+
+# [1.10.0](https://github.com/revanced/revanced-cli/compare/v1.9.3...v1.10.0) (2022-06-22)
+
+
+### Bug Fixes
+
+* add callback for addFiles ([87ffaa4](https://github.com/revanced/revanced-cli/commit/87ffaa4bdb25cb85c6ba7195f5d3b13b09a5f912))
+
+
+### Features
+
+* add logging back ([4a23cb6](https://github.com/revanced/revanced-cli/commit/4a23cb69bc385158d47b6ea8d3da54b0566a242c))
+
+## [1.9.3](https://github.com/revanced/revanced-cli/compare/v1.9.2...v1.9.3) (2022-06-22)
+
+
+### Bug Fixes
+
+* use absolute file path for key store ([d335846](https://github.com/revanced/revanced-cli/commit/d335846202b991e130882e9ce0ab268deb2e27ab))
+
+## [1.9.2](https://github.com/revanced/revanced-cli/compare/v1.9.1...v1.9.2) (2022-06-22)
+
+
+### Bug Fixes
+
+* update patcher version ([0df936e](https://github.com/revanced/revanced-cli/commit/0df936e99b01358a88a628af63eebb5ac92cae76))
+
+## [1.9.1](https://github.com/revanced/revanced-cli/compare/v1.9.0...v1.9.1) (2022-06-22)
+
+
+### Bug Fixes
+
+* add back in: option to specify keystore file path ([c94471f](https://github.com/revanced/revanced-cli/commit/c94471f4643e44b2b472ff0d826db0d2743bdc86))
+* remove logger from Signer.kt ([51e091c](https://github.com/revanced/revanced-cli/commit/51e091ce4021418508044029aa5af6aa7d5162a3))
+
+
+### Reverts
+
+* "feat: use of `java.util.logging.Logger`" ([2c8a106](https://github.com/revanced/revanced-cli/commit/2c8a10615192635202ddc137fc02f175c5914d8f))
+
+# [1.9.0](https://github.com/revanced/revanced-cli/compare/v1.8.0...v1.9.0) (2022-06-22)
+
+
+### Features
+
+* migrate logger to `slf4j` ([6c4c192](https://github.com/revanced/revanced-cli/commit/6c4c1924ee9ae75af3449749a6a82b7ae5572129))
+
+# [1.8.0](https://github.com/revanced/revanced-cli/compare/v1.7.1...v1.8.0) (2022-06-22)
+
+
+### Features
+
+* add option to specify keystore file path ([9331594](https://github.com/revanced/revanced-cli/commit/9331594706404df871d170110da753cde5058d02))
+* use of `java.util.logging.Logger` ([07f6bdf](https://github.com/revanced/revanced-cli/commit/07f6bdf33069da4e11fc40090feb726433de703e))
+
 ## [1.7.1](https://github.com/revanced/revanced-cli/compare/v1.7.0...v1.7.1) (2022-06-22)
 
 

build.gradle.kts

@@ -10,13 +10,7 @@ val githubPassword: String = project.findProperty("gpr.key") as? String ?: Syste
 
 repositories {
     mavenCentral()
-    maven {
-        url = uri("https://maven.pkg.github.com/revanced/multidexlib2")
-        credentials {
-            username = githubUsername
-            password = githubPassword
-        }
-    }
+    mavenLocal()
     maven {
         url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
         credentials {
@@ -32,7 +26,7 @@ dependencies {
     implementation(kotlin("stdlib"))
     implementation(kotlin("reflect"))
 
-    implementation("app.revanced:revanced-patcher:1.5.0")
+    implementation("app.revanced:revanced-patcher:2.4.0")
     implementation("info.picocli:picocli:4.6.3")
     implementation("com.android.tools.build:apksig:7.2.1")
     implementation("com.github.revanced:jadb:master-SNAPSHOT") // updated fork

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.7.1
+version = 2.5.3

src/main/kotlin/app/revanced/cli/command/MainCommand.kt

@@ -1,26 +1,52 @@
 package app.revanced.cli.command
 
+import app.revanced.cli.logging.impl.DefaultCliLogger
 import app.revanced.cli.patcher.Patcher
+import app.revanced.cli.patcher.logging.impl.PatcherLogger
 import app.revanced.cli.signing.Signing
+import app.revanced.cli.signing.SigningOptions
 import app.revanced.patcher.PatcherOptions
-import app.revanced.patcher.extensions.PatchExtensions.patchName
+import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
 import app.revanced.patcher.extensions.PatchExtensions.description
+import app.revanced.patcher.extensions.PatchExtensions.patchName
 import app.revanced.patcher.util.patch.implementation.JarPatchBundle
 import app.revanced.utils.adb.Adb
 import picocli.CommandLine.*
 import java.io.File
 import java.nio.file.Files
 
+private class CLIVersionProvider : IVersionProvider {
+    override fun getVersion() = arrayOf(
+        MainCommand::class.java.`package`.implementationVersion ?: "unknown"
+    )
+}
+
 @Command(
     name = "ReVanced-CLI",
-    version = ["1.0.0"],
-    mixinStandardHelpOptions = true
+    mixinStandardHelpOptions = true,
+    versionProvider = CLIVersionProvider::class
 )
 internal object MainCommand : Runnable {
+    val logger = DefaultCliLogger()
+
     @ArgGroup(exclusive = false, multiplicity = "1")
     lateinit var args: Args
 
     class Args {
+        @Option(names = ["-a", "--apk"], description = ["Input file to be patched"], required = true)
+        lateinit var inputFile: File
+
+        @Option(names = ["--uninstall"], description = ["Uninstall the mount variant"])
+        var uninstall: Boolean = false
+
+        @Option(names = ["-d", "--deploy-on"], description = ["If specified, deploy to adb device with given name"])
+        var deploy: String? = null
+
+        @ArgGroup(exclusive = false)
+        var sArgs: StartPatcherArgs? = null
+    }
+
+    class StartPatcherArgs {
         @Option(names = ["-b", "--bundles"], description = ["One or more bundles of patches"], required = true)
         var patchBundles = arrayOf<String>()
 
@@ -34,18 +60,30 @@ internal object MainCommand : Runnable {
     class ListingArgs {
         @Option(names = ["-l", "--list"], description = ["List patches only"], required = true)
         var listOnly: Boolean = false
+
+        @Option(names = ["--with-versions"], description = ["List patches with compatible versions"])
+        var withVersions: Boolean = false
+
+        @Option(names = ["--with-packages"], description = ["List patches with compatible packages"])
+        var withPackages: Boolean = false
+
+        @Option(names = ["--with-descriptions"], description = ["List patches with their descriptions"])
+        var withDescriptions: Boolean = true
     }
 
     class PatchingArgs {
-        @Option(names = ["-a", "--apk"], description = ["Input file to be patched"], required = true)
-        lateinit var inputFile: File
-
         @Option(names = ["-o", "--out"], description = ["Output file path"], required = true)
         lateinit var outputPath: String
 
         @Option(names = ["-e", "--exclude"], description = ["Explicitly exclude patches"])
         var excludedPatches = arrayOf<String>()
 
+        @Option(names = ["--exclusive"], description = ["Only installs the patches you include, not including any patch by default"])
+        var defaultExclude = false
+
+        @Option(names = ["-i", "--include"], description = ["Include patches"])
+        var includedPatches = arrayOf<String>()
+
         @Option(names = ["-r", "--resource-patcher"], description = ["Disable patching resources"])
         var disableResourcePatching: Boolean = false
 
@@ -61,12 +99,12 @@ internal object MainCommand : Runnable {
         @Option(names = ["--cn"], description = ["Overwrite the default CN for the signed file"])
         var cn = "ReVanced"
 
+        @Option(names = ["--keystore"], description = ["File path to your keystore"])
+        var keystorePath: String? = null
+
         @Option(names = ["-p", "--password"], description = ["Overwrite the default password for the signed file"])
         var password = "ReVanced"
 
-        @Option(names = ["-d", "--deploy-on"], description = ["If specified, deploy to adb device with given name"])
-        var deploy: String? = null
-
         @Option(names = ["-t", "--temp-dir"], description = ["Temporal resource cache directory"])
         var cacheDirectory = "revanced-cache"
 
@@ -78,53 +116,104 @@ internal object MainCommand : Runnable {
     }
 
     override fun run() {
-        if (args.lArgs?.listOnly == true) {
-            for (patchBundlePath in args.patchBundles) for (patch in JarPatchBundle(patchBundlePath).loadPatches()) {
-                println("[available] ${patch.patchName}: ${patch.description}")
-            }
+        if (args.sArgs?.lArgs?.listOnly == true) {
+            printListOfPatches()
             return
         }
 
-        val args = args.pArgs ?: return
+        if (args.uninstall) {
+            // temporarily get package name using Patcher method
+            // fix: abstract options in patcher
+            val patcher = app.revanced.patcher.Patcher(
+                PatcherOptions(
+                    args.inputFile,
+                    "uninstaller-cache",
+                    false
+                )
+            )
+            File("uninstaller-cache").deleteRecursively()
+
+            val adb: Adb? = args.deploy?.let {
+                Adb(File("placeholder_file"), patcher.data.packageMetadata.packageName, args.deploy!!, false)
+            }
+            adb?.uninstall()
+
+            return
+        }
+
+        val _args = args
+        val args = args.sArgs?.pArgs ?: return
 
         val patcher = app.revanced.patcher.Patcher(
             PatcherOptions(
-                args.inputFile, args.cacheDirectory, !args.disableResourcePatching
+                _args.inputFile,
+                args.cacheDirectory,
+                !args.disableResourcePatching,
+                logger = PatcherLogger
             )
         )
 
         val outputFile = File(args.outputPath)
 
-        val adb: Adb? = args.deploy?.let {
-            Adb(outputFile, patcher.data.packageMetadata.packageName, args.deploy!!, !args.mount)
+        val adb: Adb? = _args.deploy?.let {
+            Adb(outputFile, patcher.data.packageMetadata.packageName, _args.deploy!!, !args.mount)
         }
-
-        val patchedFile = if (!args.mount) {
-            File(args.cacheDirectory).resolve("${outputFile.nameWithoutExtension}_raw.apk")
-        } else outputFile
+        val patchedFile = if (args.mount) outputFile
+        else File(args.cacheDirectory).resolve("${outputFile.nameWithoutExtension}_raw.apk")
 
         Patcher.start(patcher, patchedFile)
 
-        println("[aligning & signing]")
-
         if (!args.mount) {
             Signing.start(
                 patchedFile,
                 outputFile,
-                args.cn,
-                args.password,
+                SigningOptions(
+                    args.cn,
+                    args.password,
+                    args.keystorePath ?: outputFile.absoluteFile.parentFile
+                        .resolve("${outputFile.nameWithoutExtension}.keystore")
+                        .canonicalPath
+                )
             )
         }
 
         if (args.clean) File(args.cacheDirectory).deleteRecursively()
 
-        adb?.let {
-            println("[deploying]")
-            it.deploy()
+        adb?.deploy()
+
+        if (args.clean && _args.deploy != null) Files.delete(outputFile.toPath())
+
+        logger.info("Finished")
+    }
+
+    private fun printListOfPatches() {
+        for (patchBundlePath in args.sArgs?.patchBundles!!) for (patch in JarPatchBundle(patchBundlePath).loadPatches()) {
+            for (compatiblePackage in patch.compatiblePackages!!) {
+                val packageEntryStr = buildString {
+                    // Add package if flag is set
+                    if (args.sArgs?.lArgs?.withPackages == true) {
+                        val packageName = compatiblePackage.name.substringAfterLast(".").padStart(10)
+                        append(packageName)
+                        append("\t")
+                    }
+                    // Add patch name
+                    val patchName = patch.patchName.padStart(25)
+                    append(patchName)
+                    // Add description if flag is set.
+                    if (args.sArgs?.lArgs?.withDescriptions == true) {
+                        append("\t")
+                        append(patch.description)
+                    }
+                    // Add compatible versions, if flag is set
+                    if (args.sArgs?.lArgs?.withVersions == true) {
+                        val compatibleVersions = compatiblePackage.versions.joinToString(separator = ", ")
+                        append("\t")
+                        append(compatibleVersions)
+                    }
+
+                }
+                logger.info(packageEntryStr)
+            }
         }
-
-        if (args.clean && args.deploy != null) Files.delete(outputFile.toPath())
-
-        println("[done]")
     }
 }

src/main/kotlin/app/revanced/cli/logging/CliLogger.kt

@@ -0,0 +1,8 @@
+package app.revanced.cli.logging
+
+internal interface CliLogger {
+     fun error(msg: String)
+     fun info(msg: String)
+     fun trace(msg: String)
+     fun warn(msg: String)
+}

src/main/kotlin/app/revanced/cli/logging/impl/DefaultCliLogger.kt

@@ -0,0 +1,30 @@
+package app.revanced.cli.logging.impl
+
+import app.revanced.cli.command.MainCommand
+import app.revanced.cli.logging.CliLogger
+import java.util.logging.Logger
+import java.util.logging.SimpleFormatter
+
+internal class DefaultCliLogger(
+    private val logger: Logger = Logger.getLogger(MainCommand::class.java.name),
+    private val errorLogger: Logger = Logger.getLogger(logger.name + "Err")
+) : CliLogger {
+
+    init {
+        logger.useParentHandlers = false
+        if (logger.handlers.isEmpty()) {
+            logger.addHandler(FlushingStreamHandler(System.out, SimpleFormatter()))
+        }
+    }
+
+    companion object {
+        init {
+            System.setProperty("java.util.logging.SimpleFormatter.format", "%4\$s: %5\$s %n")
+        }
+    }
+
+    override fun error(msg: String) = errorLogger.severe(msg)
+    override fun info(msg: String) = logger.info(msg)
+    override fun trace(msg: String) = logger.finest(msg)
+    override fun warn(msg: String) = errorLogger.warning(msg)
+}

src/main/kotlin/app/revanced/cli/logging/impl/FlushingStreamHandler.kt

@@ -0,0 +1,13 @@
+package app.revanced.cli.logging.impl
+
+import java.io.OutputStream
+import java.util.logging.Formatter
+import java.util.logging.LogRecord
+import java.util.logging.StreamHandler
+
+internal class FlushingStreamHandler(out: OutputStream, format: Formatter) : StreamHandler(out, format) {
+    override fun publish(record: LogRecord) {
+        super.publish(record)
+        flush()
+    }
+}

src/main/kotlin/app/revanced/cli/patcher/Patcher.kt

@@ -1,6 +1,7 @@
 package app.revanced.cli.patcher
 
 import app.revanced.cli.command.MainCommand.args
+import app.revanced.cli.command.MainCommand.logger
 import app.revanced.utils.filesystem.ZipFileSystemUtils
 import app.revanced.utils.patcher.addPatchesFiltered
 import app.revanced.utils.patcher.applyPatchesVerbose
@@ -10,35 +11,38 @@ import java.nio.file.Files
 
 internal object Patcher {
     internal fun start(patcher: app.revanced.patcher.Patcher, output: File) {
-        val args = args.pArgs!!
+        val inputFile = args.inputFile
+        val args = args.sArgs?.pArgs!!
 
         // merge files like necessary integrations
         patcher.mergeFiles()
         // add patches, but filter incompatible or excluded patches
-        patcher.addPatchesFiltered(excludePatches = args.excludedPatches.isNotEmpty())
+        patcher.addPatchesFiltered()
         // apply patches
         patcher.applyPatchesVerbose()
 
         // write output file
         if (output.exists()) Files.delete(output.toPath())
-        args.inputFile.copyTo(output)
+        inputFile.copyTo(output)
 
         val result = patcher.save()
-        val inputFile = if (!args.disableResourcePatching && result.resourceFile != null) {
-            result.resourceFile
-        } else null
-        ZipFileSystemUtils(inputFile, output).use { fileSystem ->
+        ZipFileSystemUtils(output).use { outputFileSystem ->
             // replace all dex files
             result.dexFiles.forEach {
-                fileSystem.write(it.name, it.dexFileInputStream.readAllBytes())
+                logger.info("Writing dex file ${it.name}")
+                outputFileSystem.write(it.name, it.dexFileInputStream.readAllBytes())
             }
 
-            // inputFile being null implies resource patching being disabled
-            if (inputFile != null) {
-                // write resources
-                fileSystem.writeInput()
-                fileSystem.uncompress(*result.doNotCompress!!.toTypedArray())
+            if (!args.disableResourcePatching) {
+                logger.info("Writing resources...")
+
+                ZipFileSystemUtils(result.resourceFile!!).use { resourceFileSystem ->
+                    val resourceFiles = resourceFileSystem.getFile(File.separator)
+                    outputFileSystem.writePathRecursively(resourceFiles)
+                }
             }
+
+            result.doNotCompress?.let { outputFileSystem.uncompress(*it.toTypedArray()) }
         }
     }
 }

src/main/kotlin/app/revanced/cli/patcher/logging/impl/PatcherLogger.kt

@@ -0,0 +1,13 @@
+package app.revanced.cli.patcher.logging.impl
+
+import app.revanced.cli.logging.impl.DefaultCliLogger
+import java.util.logging.Logger
+
+internal object PatcherLogger : app.revanced.patcher.logging.Logger{
+    private val logger = DefaultCliLogger(Logger.getLogger(app.revanced.patcher.Patcher::class.java.name))
+
+    override fun error(msg: String) = logger.error(msg)
+    override fun info(msg: String) = logger.info(msg)
+    override fun warn(msg: String)= logger.warn(msg)
+    override fun trace(msg: String)= logger.trace(msg)
+}

src/main/kotlin/app/revanced/cli/signing/Signing.kt

@@ -1,25 +1,28 @@
 package app.revanced.cli.signing
 
 import app.revanced.cli.command.MainCommand.args
+import app.revanced.cli.command.MainCommand.logger
 import app.revanced.utils.signing.Signer
 import app.revanced.utils.signing.align.ZipAligner
 import java.io.File
 
 object Signing {
-    fun start(inputFile: File, outputFile: File, cn: String, password: String) {
-        val cacheDirectory = File(args.pArgs!!.cacheDirectory)
+    fun start(inputFile: File, outputFile: File, signingOptions: SigningOptions) {
+        val cacheDirectory = File(args.sArgs?.pArgs?.cacheDirectory)
         val alignedOutput = cacheDirectory.resolve("${outputFile.nameWithoutExtension}_aligned.apk")
         val signedOutput = cacheDirectory.resolve("${outputFile.nameWithoutExtension}_signed.apk")
 
         // align the inputFile and write to alignedOutput
+        logger.info("Aligning ${inputFile.name}")
         ZipAligner.align(inputFile, alignedOutput)
         // sign the alignedOutput and write to signedOutput
         // the reason is, in case the signer fails
         // it does not damage the output file
-        val keyStore = Signer(cn, password).signApk(alignedOutput, signedOutput)
+        logger.info("Signing ${alignedOutput.name}")
+        Signer(signingOptions).signApk(alignedOutput, signedOutput)
 
-        // afterwards copy over the file and the keystore to the output
+        // afterwards copy over the file to the output
+        logger.info("Copying ${signedOutput.name} to ${outputFile.name}")
         signedOutput.copyTo(outputFile, true)
-        keyStore.copyTo(outputFile.resolveSibling(keyStore.name), true)
     }
 }

src/main/kotlin/app/revanced/cli/signing/SigningOptions.kt

@@ -0,0 +1,7 @@
+package app.revanced.cli.signing
+
+data class SigningOptions(
+    val cn: String,
+    val password: String,
+    val keyStoreFilePath: String
+)

src/main/kotlin/app/revanced/utils/adb/Adb.kt

@@ -1,5 +1,6 @@
 package app.revanced.utils.adb
 
+import app.revanced.cli.command.MainCommand.logger
 import se.vidstige.jadb.JadbConnection
 import se.vidstige.jadb.JadbDevice
 import se.vidstige.jadb.managers.PackageManager
@@ -20,7 +21,7 @@ internal class Adb(
             ?: throw IllegalArgumentException("No such device with name $deviceName")
 
         if (!modeInstall && device.run("su -h", false) != 0)
-            throw IllegalArgumentException("Root required on $deviceName. Deploying failed.")
+            throw IllegalArgumentException("Root required on $deviceName. Task failed")
     }
 
     private fun String.replacePlaceholder(with: String? = null): String {
@@ -29,12 +30,16 @@ internal class Adb(
 
     internal fun deploy() {
         if (modeInstall) {
+            logger.info("Installing without mounting")
+
             PackageManager(device).install(file)
         } else {
+            logger.info("Installing by mounting")
+
             // push patched file
             device.copy(Constants.PATH_INIT_PUSH, file)
 
-            // create revanced path
+            // create revanced folder path
             device.run("${Constants.COMMAND_CREATE_DIR} ${Constants.PATH_REVANCED}")
 
             // prepare mounting the apk
@@ -48,16 +53,8 @@ internal class Adb(
             // install mount script
             device.run(Constants.COMMAND_INSTALL_MOUNT.replacePlaceholder())
 
-            // push umount script
-            device.createFile(
-                Constants.PATH_INIT_PUSH,
-                Constants.CONTENT_UMOUNT_SCRIPT.replacePlaceholder()
-            )
-            // install mount script
-            device.run(Constants.COMMAND_INSTALL_UMOUNT.replacePlaceholder())
-
             // unmount the apk for sanity
-            device.run(Constants.PATH_UMOUNT.replacePlaceholder())
+            device.run(Constants.COMMAND_UMOUNT.replacePlaceholder())
             // mount the apk
             device.run(Constants.PATH_MOUNT.replacePlaceholder())
 
@@ -69,6 +66,21 @@ internal class Adb(
         }
     }
 
+    internal fun uninstall() {
+        logger.info("Uninstalling by unmounting")
+
+        // unmount the apk
+        device.run(Constants.COMMAND_UMOUNT.replacePlaceholder())
+
+        // delete revanced app
+        device.run(Constants.COMMAND_DELETE.replacePlaceholder(Constants.PATH_REVANCED_APP).replacePlaceholder())
+
+        // delete mount script
+        device.run(Constants.COMMAND_DELETE.replacePlaceholder(Constants.PATH_MOUNT).replacePlaceholder())
+
+        logger.info("Finished uninstalling")
+    }
+
     private fun log() {
         val executor = Executors.newSingleThreadExecutor()
         val pipe = if (logging) {
@@ -91,11 +103,11 @@ internal class Adb(
                 }
                 break
             } catch (e: Exception) {
-                throw RuntimeException("An error occurred while monitoring state of app", e)
+                throw RuntimeException("An error occurred while monitoring the state of app", e)
             }
         }
-        println("App closed, continuing.")
+        logger.info("Stopped logging because the app was closed")
         process.destroy()
         executor.shutdown()
     }
-}
+}

src/main/kotlin/app/revanced/utils/adb/Constants.kt

@@ -21,31 +21,25 @@ internal object Constants {
     internal const val PATH_REVANCED = "/data/adb/revanced/"
 
     // revanced apk path
-    private const val PATH_REVANCED_APP = "$PATH_REVANCED$PLACEHOLDER.apk"
+    internal const val PATH_REVANCED_APP = "$PATH_REVANCED$PLACEHOLDER.apk"
 
-    // (un)mount script paths
+    // delete command
+    internal const val COMMAND_DELETE = "rm -rf $PLACEHOLDER"
+
+    // mount script path
     internal const val PATH_MOUNT = "/data/adb/service.d/$NAME_MOUNT_SCRIPT"
-    internal const val PATH_UMOUNT = "/data/adb/post-fs-data.d/un$NAME_MOUNT_SCRIPT"
 
     // move to revanced apk path & set permissions
     internal const val COMMAND_PREPARE_MOUNT_APK =
         "base_path=\"$PATH_REVANCED_APP\" && mv $PATH_INIT_PUSH ${'$'}base_path && chmod 644 ${'$'}base_path && chown system:system ${'$'}base_path && chcon u:object_r:apk_data_file:s0  ${'$'}base_path"
 
+    // unmount command
+    internal const val COMMAND_UMOUNT =
+        "stock_path=${'$'}( pm path $PLACEHOLDER | grep base | sed 's/package://g' ) && umount -l ${'$'}stock_path"
+
     // install mount script & set permissions
     internal const val COMMAND_INSTALL_MOUNT = "mv $PATH_INIT_PUSH $PATH_MOUNT && $COMMAND_CHMOD_MOUNT $PATH_MOUNT"
 
-    // install umount script & set permissions
-    internal const val COMMAND_INSTALL_UMOUNT = "mv $PATH_INIT_PUSH $PATH_UMOUNT && $COMMAND_CHMOD_MOUNT $PATH_UMOUNT"
-
-    // unmount script
-    internal val CONTENT_UMOUNT_SCRIPT =
-        """
-            #!/system/bin/sh
-            
-            stock_path=${'$'}( pm path $PLACEHOLDER | grep base | sed 's/package://g' )
-            umount -l ${'$'}stock_path
-        """.trimIndent()
-
     // mount script
     internal val CONTENT_MOUNT_SCRIPT =
         """

src/main/kotlin/app/revanced/utils/filesystem/ZipFileSystemUtils.kt

@@ -7,15 +7,14 @@ import java.nio.file.Files
 import java.nio.file.Path
 import java.util.zip.ZipEntry
 
-internal class ZipFileSystemUtils(input: File?, output: File) : Closeable {
-    private val inFileSystem = if (input != null) {
-        FileSystems.newFileSystem(input.toPath())
-    } else null
-    private val outFileSystem = FileSystems.newFileSystem(output.toPath(), mapOf("noCompression" to true))
+internal class ZipFileSystemUtils(
+    file: File
+) : Closeable {
+    private var zipFileSystem = FileSystems.newFileSystem(file.toPath(), mapOf("noCompression" to true))
 
     private fun Path.deleteRecursively() {
         if (!Files.exists(this)) {
-            throw IllegalStateException("File exists in input but not in output, cannot delete")
+            throw IllegalStateException("File exists in real folder but not in zip file system")
         }
 
         if (Files.isDirectory(this)) {
@@ -27,25 +26,21 @@ internal class ZipFileSystemUtils(input: File?, output: File) : Closeable {
         Files.delete(this)
     }
 
-    internal fun writeInput() {
-        if (inFileSystem == null) {
-            throw IllegalArgumentException("Input file not set")
-        }
-        val root = inFileSystem.getPath(inFileSystem.separator)
+    internal fun getFile(path: String) = zipFileSystem.getPath(path)
 
-        Files.list(root).close()
-
-        Files.list(root).also { fileStream ->
+    internal fun writePathRecursively(path: Path) {
+        Files.list(path).use { fileStream ->
             fileStream.forEach { filePath ->
-                val fileSystemPath = filePath.getRelativePath(root)
+                val fileSystemPath = filePath.getRelativePath(path)
                 fileSystemPath.deleteRecursively()
             }
-        }.close()
+        }
 
-        Files.walk(root).also { fileStream ->
-            // don't include build directory by skipping the root node.
+        Files.walk(path).use { fileStream ->
+            // don't include build directory
+            // by skipping the root node.
             fileStream.skip(1).forEach { filePath ->
-                val relativePath = filePath.getRelativePath(root)
+                val relativePath = filePath.getRelativePath(path)
 
                 if (Files.isDirectory(filePath)) {
                     Files.createDirectory(relativePath)
@@ -54,18 +49,16 @@ internal class ZipFileSystemUtils(input: File?, output: File) : Closeable {
 
                 Files.copy(filePath, relativePath)
             }
-        }.close()
+        }
     }
 
-    internal fun write(path: String, content: ByteArray) = Files.write(outFileSystem.getPath(path), content)
+    internal fun write(path: String, content: ByteArray) = Files.write(zipFileSystem.getPath(path), content)
 
-    private fun Path.getRelativePath(path: Path): Path = outFileSystem.getPath(path.relativize(this).toString())
+    private fun Path.getRelativePath(path: Path): Path = zipFileSystem.getPath(path.relativize(this).toString())
 
+    // TODO: figure out why the file system is uncompressed by default and how to fix it
     internal fun uncompress(vararg paths: String) =
-        paths.forEach { Files.setAttribute(outFileSystem.getPath(it), "zip:method", ZipEntry.STORED) }
+        paths.forEach { Files.setAttribute(zipFileSystem.getPath(it), "zip:method", ZipEntry.STORED) }
 
-    override fun close() {
-        inFileSystem?.close()
-        outFileSystem.close()
-    }
+    override fun close() = zipFileSystem.close()
 }

src/main/kotlin/app/revanced/utils/patcher/Patcher.kt

@@ -2,53 +2,59 @@ package app.revanced.utils.patcher
 
 import app.revanced.cli.command.MainCommand
 import app.revanced.cli.command.MainCommand.args
+import app.revanced.cli.command.MainCommand.logger
 import app.revanced.patcher.Patcher
-import app.revanced.patcher.data.base.Data
+import app.revanced.patcher.data.Data
 import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
 import app.revanced.patcher.extensions.PatchExtensions.include
 import app.revanced.patcher.extensions.PatchExtensions.patchName
-import app.revanced.patcher.patch.base.Patch
+import app.revanced.patcher.patch.Patch
 import app.revanced.patcher.util.patch.implementation.JarPatchBundle
 
-fun Patcher.addPatchesFiltered(
-    excludePatches: Boolean = false
-) {
+fun Patcher.addPatchesFiltered() {
     val packageName = this.data.packageMetadata.packageName
     val packageVersion = this.data.packageMetadata.packageVersion
 
-    args.patchBundles.forEach { bundle ->
+    args.sArgs?.patchBundles!!.forEach { bundle ->
         val includedPatches = mutableListOf<Class<out Patch<Data>>>()
         JarPatchBundle(bundle).loadPatches().forEach patch@{ patch ->
             val compatiblePackages = patch.compatiblePackages
             val patchName = patch.patchName
 
-            val prefix = "[skipped] $patchName"
+            val prefix = "Skipping $patchName"
 
-            val args = MainCommand.args.pArgs!!
+            val args = MainCommand.args.sArgs?.pArgs!!
 
-            if (excludePatches && args.excludedPatches.contains(patchName)) {
-                println("$prefix: Explicitly excluded.")
+            if (args.excludedPatches.contains(patchName)) {
+                logger.info("$prefix: Explicitely excluded")
                 return@patch
-            } else if (!patch.include) {
-                println("$prefix: Implicitly excluded.")
+            } else if ((!patch.include || args.defaultExclude) && !args.includedPatches.contains(patchName)) {
+                logger.info("$prefix: Not explicitly included")
                 return@patch
             }
 
-            if (compatiblePackages == null) println("$prefix: Missing compatibility annotation. Continuing.")
+            if (compatiblePackages == null) logger.warn("$prefix: Missing compatibility annotation. Continuing.")
             else {
                 if (!compatiblePackages.any { it.name == packageName }) {
-                    println("$prefix: Incompatible package.")
+                    logger.warn("$prefix: Incompatible with $packageName. This patch is only compatible with ${
+                        compatiblePackages.joinToString(
+                            ", "
+                        ) { it.name }
+                    }")
                     return@patch
                 }
 
                 if (!(args.experimental || compatiblePackages.any { it.versions.isEmpty() || it.versions.any { version -> version == packageVersion } })) {
-                    println("$prefix: The package version is $packageVersion and is incompatible.")
+                    val compatibleWith = compatiblePackages.map { _package ->
+                        "${_package.name}: ${_package.versions.joinToString(", ")}"
+                    }.joinToString(";")
+                    logger.warn("$prefix: Incompatible with version $packageVersion. This patch is only compatible with version $compatibleWith")
                     return@patch
                 }
             }
 
+            logger.trace("Adding $patchName")
             includedPatches.add(patch)
-            println("[added] $patchName")
         }
         this.addPatches(includedPatches)
     }
@@ -57,14 +63,16 @@ fun Patcher.addPatchesFiltered(
 fun Patcher.applyPatchesVerbose() {
     this.applyPatches().forEach { (patch, result) ->
         if (result.isSuccess) {
-            println("[success] $patch")
+            logger.info("$patch succeeded")
             return@forEach
         }
-        println("[error] $patch:")
+        logger.error("$patch failed:")
         result.exceptionOrNull()!!.printStackTrace()
     }
 }
 
 fun Patcher.mergeFiles() {
-    this.addFiles(args.pArgs!!.mergeFiles)
-}
+    this.addFiles(args.sArgs?.pArgs!!.mergeFiles) { file ->
+        logger.info("Merging $file")
+    }
+}

src/main/kotlin/app/revanced/utils/signature/Signature.kt

@@ -1,54 +0,0 @@
-package app.revanced.utils.signature
-
-import app.revanced.patcher.Patcher
-
-object Signature {
-
-    fun checkSignatures(patcher: Patcher) {
-        TODO()
-        /**
-        val failed = mutableListOf<String>()
-        for (signature in patcher.resolveSignatures()) {
-        val signatureClass = signature::class.java
-        val signatureName = signature.name ?: signatureClass.simpleName
-        if (!signature.resolved) {
-        failed.add(signatureName)
-        continue
-        }
-
-        val method = signature.result!!.method
-        val matchingMethod = signature.matchingMethod ?: MatchingMethod()
-
-        println(
-        """
-        [Signature] $signatureName
-        [Method] ${matchingMethod.definingClass}->${matchingMethod.name}
-        [Match] ${method.definingClass}->${method.toStr()}
-        """.trimIndent()
-        )
-
-        signature.fuzzyThreshold.let {
-        val warnings = signature.result!!.scanResult.warnings!!
-        println(
-        """
-        [Warnings: ${warnings.count()}]
-        ${warnings.joinToString(separator = "\n") { warning -> "${warning.instructionIndex} / ${warning.patternIndex}: ${warning.wrongOpcode} (expected: ${warning.correctOpcode})" }}
-        """.trimIndent()
-        )
-        }
-        }
-
-        println(
-        """
-        ${"=".repeat(50)}
-        [Failed signatures: ${failed.size}]
-        ${failed.joinToString(separator = "\n") { it }}
-        """.trimIndent()
-        )
-         */
-    }
-
-    //private fun Method.toStr(): String {
-    //    return "${this.name}(${this.parameterTypes.joinToString("")})${this.returnType}"
-    //}
-}

src/main/kotlin/app/revanced/utils/signing/Signer.kt

@@ -1,5 +1,7 @@
 package app.revanced.utils.signing
 
+import app.revanced.cli.command.MainCommand.logger
+import app.revanced.cli.signing.SigningOptions
 import com.android.apksig.ApkSigner
 import org.bouncycastle.asn1.x500.X500Name
 import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo
@@ -17,9 +19,9 @@ import java.security.cert.X509Certificate
 import java.util.*
 
 internal class Signer(
-    private val cn: String, password: String
+    private val signingOptions: SigningOptions
 ) {
-    private val passwordCharArray = password.toCharArray()
+    private val passwordCharArray = signingOptions.password.toCharArray()
     private fun newKeystore(out: File) {
         val (publicKey, privateKey) = createKey()
         val privateKS = KeyStore.getInstance("BKS", "BC")
@@ -34,7 +36,7 @@ internal class Signer(
         val pair = gen.generateKeyPair()
         var serialNumber: BigInteger
         do serialNumber = BigInteger.valueOf(SecureRandom().nextLong()) while (serialNumber < BigInteger.ZERO)
-        val x500Name = X500Name("CN=$cn")
+        val x500Name = X500Name("CN=${signingOptions.cn}")
         val builder = X509v3CertificateBuilder(
             x500Name,
             serialNumber,
@@ -48,30 +50,30 @@ internal class Signer(
         return JcaX509CertificateConverter().getCertificate(builder.build(signer)) to pair.private
     }
 
-    fun signApk(input: File, output: File): File {
+    fun signApk(input: File, output: File) {
         Security.addProvider(BouncyCastleProvider())
 
         // TODO: keystore should be saved securely
-        val ks = File(input.parent, "${output.nameWithoutExtension}.keystore")
-        if (!ks.exists()) newKeystore(ks)
+        val ks = File(signingOptions.keyStoreFilePath)
+        if (!ks.exists()) newKeystore(ks) else {
+            logger.info("Found existing keystore: ${ks.nameWithoutExtension}")
+        }
 
         val keyStore = KeyStore.getInstance("BKS", "BC")
         FileInputStream(ks).use { fis -> keyStore.load(fis, null) }
         val alias = keyStore.aliases().nextElement()
 
         val config = ApkSigner.SignerConfig.Builder(
-            cn,
+            signingOptions.cn,
             keyStore.getKey(alias, passwordCharArray) as PrivateKey,
             listOf(keyStore.getCertificate(alias) as X509Certificate)
         ).build()
 
         val signer = ApkSigner.Builder(listOf(config))
-        signer.setCreatedBy(cn)
+        signer.setCreatedBy(signingOptions.cn)
         signer.setInputApk(input)
         signer.setOutputApk(output)
 
         signer.build().sign()
-
-        return ks
     }
 }