chore(release): 1.9.0 [skip ci]

# [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](6c4c1924ee))

.github/workflows/release.yml

@@ -28,12 +28,10 @@ jobs:
         uses: actions/setup-node@v2
         with:
           node-version: "lts/*"
-      - name: Make gradlew executable
-        run: chmod +x gradlew
       - name: Build with Gradle
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: ./gradlew build
+        run: ./gradlew build clean
       - name: Setup semantic-release
         run: npm install -g semantic-release @semantic-release/git @semantic-release/changelog gradle-semantic-release-plugin -D
       - name: Release

.releaserc

@@ -10,6 +10,7 @@
     "@semantic-release/commit-analyzer",
     "@semantic-release/release-notes-generator",
     "@semantic-release/changelog",
+    "gradle-semantic-release-plugin",
     [
       "@semantic-release/git",
       {
@@ -24,7 +25,7 @@
       {
         "assets": [
           {
-            "path": "build/libs/*.jar"
+            "path": "build/libs/*all.jar"
           }
         ]
       }

CHANGELOG.md

@@ -1,3 +1,134 @@
+# [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)
+
+
+### Bug Fixes
+
+* migrate to changes of patcher ([b30c737](https://github.com/revanced/revanced-cli/commit/b30c7375a7ea61184be5dca19062ee74d1f97692))
+* wrong variable inverted ([f694542](https://github.com/revanced/revanced-cli/commit/f694542d64ccb06bfa4d042f26b6b7192d1e912e))
+
+# [1.7.0](https://github.com/revanced/revanced-cli/compare/v1.6.3...v1.7.0) (2022-06-21)
+
+
+### Features
+
+* show description when listing patches ([af32572](https://github.com/revanced/revanced-cli/commit/af32572f29d0f0a45ee5c3e01ba4cf1f91fe2f10))
+
+## [1.6.3](https://github.com/revanced/revanced-cli/compare/v1.6.2...v1.6.3) (2022-06-21)
+
+
+### Bug Fixes
+
+* update patcher version ([80c11fe](https://github.com/revanced/revanced-cli/commit/80c11fef734bdba9026e91f95ee0a4a522cbefab))
+
+## [1.6.2](https://github.com/revanced/revanced-cli/compare/v1.6.1...v1.6.2) (2022-06-21)
+
+
+### Bug Fixes
+
+* CLI not working ([29105ba](https://github.com/revanced/revanced-cli/commit/29105bab3dabd9d16af6b511caef9727f98afd1a))
+* improper use of mount variable ([31853fe](https://github.com/revanced/revanced-cli/commit/31853fe5393af04805857b78a54434e1c51e4c8e))
+
+## [1.6.1](https://github.com/revanced/revanced-cli/compare/v1.6.0...v1.6.1) (2022-06-21)
+
+
+### Bug Fixes
+
+* remove `-e` from `experimental` option ([3829136](https://github.com/revanced/revanced-cli/commit/3829136c49ddce1dc6b01eda04ce013540b213c2))
+
+# [1.6.0](https://github.com/revanced/revanced-cli/compare/v1.5.1...v1.6.0) (2022-06-21)
+
+
+### Features
+
+* rename `debugging` option to `experimental` ([98bd6f3](https://github.com/revanced/revanced-cli/commit/98bd6f3f4b3eb34c445cbd5e3a3196f399f8bb3b))
+* use `install` mode by default ([1a3db77](https://github.com/revanced/revanced-cli/commit/1a3db77c21b5795220fbac1ec36827fc521fface))
+
+## [1.5.1](https://github.com/revanced/revanced-cli/compare/v1.5.0...v1.5.1) (2022-06-21)
+
+
+### Bug Fixes
+
+* update patcher version ([09b9027](https://github.com/revanced/revanced-cli/commit/09b9027e5e28f0483e74b711cf65a7876267a339)), closes [#45](https://github.com/revanced/revanced-cli/issues/45)
+
+# [1.5.0](https://github.com/revanced/revanced-cli/compare/v1.4.5...v1.5.0) (2022-06-20)
+
+
+### Features
+
+* allow listing patches without other parameters ([#42](https://github.com/revanced/revanced-cli/issues/42)) ([b977d70](https://github.com/revanced/revanced-cli/commit/b977d7039f877be242823a4eef0fb8df6550dd05))
+
+## [1.4.5](https://github.com/revanced/revanced-cli/compare/v1.4.4...v1.4.5) (2022-06-20)
+
+
+### Bug Fixes
+
+* update patcher version (fix apktool) ([496f821](https://github.com/revanced/revanced-cli/commit/496f82121879443609667a792cc1e16441ef5c2f))
+
+## [1.4.4](https://github.com/revanced/revanced-cli/compare/v1.4.3...v1.4.4) (2022-06-18)
+
+
+### Bug Fixes
+
+* add execute permission to `./gradlew` file ([#36](https://github.com/revanced/revanced-cli/issues/36)) ([072d9e1](https://github.com/revanced/revanced-cli/commit/072d9e15d7e44b1080923f3afeb194eeb4fe4682))
+
+## [1.4.3](https://github.com/revanced/revanced-cli/compare/v1.4.2...v1.4.3) (2022-06-18)
+
+
+### Bug Fixes
+
+* update patcher to 1.2.5 ([055c282](https://github.com/revanced/revanced-cli/commit/055c282dd3d147e3600bdfdf4fd6b4bd72cbf379))
+
+## [1.4.2](https://github.com/revanced/revanced-cli/compare/v1.4.1...v1.4.2) (2022-06-16)
+
+
+### Bug Fixes
+
+* dummy publish task (1/2) [skip ci] ([afff4c8](https://github.com/revanced/revanced-cli/commit/afff4c8418bd33959440a3ac9e6c46816b3153ad))
+* releases (2/2) ([227d8d9](https://github.com/revanced/revanced-cli/commit/227d8d94c89ec24051bd5bc20808049164d92492))
+
+## [1.4.1](https://github.com/revanced/revanced-cli/compare/v1.4.0...v1.4.1) (2022-06-14)
+
+
+### Bug Fixes
+
+* move the keystore to the output directory ([6ceb449](https://github.com/revanced/revanced-cli/commit/6ceb449cf8539a92d89eeba8136fdc686319e2ef))
+
+# [1.4.0](https://github.com/revanced/revanced-cli/compare/v1.3.3...v1.4.0) (2022-06-14)
+
+
+### Features
+
+* chcon on mount ([e1c7d10](https://github.com/revanced/revanced-cli/commit/e1c7d1082a6946d1082c8744a1d0118c1a2263ea))
+
+## [1.3.3](https://github.com/revanced/revanced-cli/compare/v1.3.2...v1.3.3) (2022-06-13)
+
+
+### Bug Fixes
+
+* missing implementation ([48102c6](https://github.com/revanced/revanced-cli/commit/48102c66077c4ae17e3de1076e9da72de5f00366))
+
+## [1.3.2](https://github.com/revanced/revanced-cli/compare/v1.3.1...v1.3.2) (2022-06-13)
+
+
+### Bug Fixes
+
+* only upload `-all.jar` asset ([ca8e1ba](https://github.com/revanced/revanced-cli/commit/ca8e1ba6af00e275c6981476f773b13b103799d1))
+
 ## [1.3.1](https://github.com/revanced/revanced-cli/compare/v1.3.0...v1.3.1) (2022-06-13)
 
 

build.gradle.kts

@@ -29,14 +29,15 @@ repositories {
 }
 
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.7.0")
+    implementation(kotlin("stdlib"))
-    implementation("app.revanced:revanced-patcher:1.1.0")
+    implementation(kotlin("reflect"))
 
+    implementation("app.revanced:revanced-patcher:1.6.0")
+    implementation("org.slf4j:slf4j-api:1.7.36")
     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
     implementation("org.bouncycastle:bcpkix-jdk15on:1.70")
-    implementation("org.jetbrains.kotlin:kotlin-reflect:1.7.0")
 }
 
 tasks {
@@ -50,4 +51,12 @@ tasks {
             attributes("Implementation-Version" to project.version)
         }
     }
+    // Dummy task to fix the Gradle semantic-release plugin.
+    // Remove this if you forked it to support building only.
+    // Tracking issue: https://github.com/KengoTODA/gradle-semantic-release-plugin/issues/435
+    register<DefaultTask>("publish") {
+        group = "publish"
+        description = "Dummy task"
+        dependsOn(build)
+    }
 }

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.3.0
+version = 1.9.0

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

@@ -2,107 +2,135 @@ package app.revanced.cli.command
 
 import app.revanced.cli.patcher.Patcher
 import app.revanced.cli.signing.Signing
+import app.revanced.cli.signing.SigningOptions
 import app.revanced.patcher.PatcherOptions
+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.Command
+import org.slf4j.Logger
-import picocli.CommandLine.Option
+import org.slf4j.LoggerFactory
+import picocli.CommandLine.*
 import java.io.File
 import java.nio.file.Files
+import kotlin.io.path.Path
+import kotlin.io.path.name
 
 @Command(
-    name = "ReVanced-CLI", version = ["1.0.0"], mixinStandardHelpOptions = true,
+    name = "ReVanced-CLI", version = ["1.0.0"], mixinStandardHelpOptions = true
 )
 internal object MainCommand : Runnable {
-    @Option(names = ["-a", "--apk"], description = ["Input file to be patched"], required = true)
+    val logger: Logger = LoggerFactory.getLogger(MainCommand::class.java)
-    lateinit var inputFile: File
 
-    @Option(names = ["-o", "--out"], description = ["Output file path"], required = true)
+    @ArgGroup(exclusive = false, multiplicity = "1")
-    lateinit var outputPath: String
+    lateinit var args: Args
 
-    @Option(
+    class Args {
-        names = ["-i", "--include"],
+        @Option(names = ["-b", "--bundles"], description = ["One or more bundles of patches"], required = true)
-        description = ["Which patches to include. If none is specified, all compatible default patches will be included"]
+        var patchBundles = arrayOf<String>()
-    )
-    var includedPatches = arrayOf<String>()
 
-    @Option(names = ["-r", "--resource-patcher"], description = ["Disable patching resources"])
+        @ArgGroup(exclusive = false)
-    var disableResourcePatching: Boolean = false
+        var lArgs: ListingArgs? = null
 
-    @Option(names = ["--debugging"], description = ["Disable patch version compatibility"])
+        @ArgGroup(exclusive = false)
-    var debugging: Boolean = false
+        var pArgs: PatchingArgs? = null
+    }
 
-    @Option(names = ["-m", "--merge"], description = ["One or more dex file containers to merge"])
+    class ListingArgs {
-    var mergeFiles = listOf<File>()
+        @Option(names = ["-l", "--list"], description = ["List patches only"], required = true)
+        var listOnly: Boolean = false
+    }
 
-    @Option(names = ["-b", "--bundles"], description = ["One or more bundles of patches"])
+    class PatchingArgs {
-    var patchBundles = arrayOf<String>()
+        @Option(names = ["-a", "--apk"], description = ["Input file to be patched"], required = true)
+        lateinit var inputFile: File
 
-    @Option(names = ["-l", "--list"], description = ["List patches only"])
+        @Option(names = ["-o", "--out"], description = ["Output file path"], required = true)
-    var listOnly: Boolean = false
+        lateinit var outputPath: String
 
-    @Option(names = ["--install"], description = ["If specified, instead of mounting, install"])
+        @Option(names = ["-e", "--exclude"], description = ["Explicitly exclude patches"])
-    var install: Boolean = false
+        var excludedPatches = arrayOf<String>()
 
-    @Option(names = ["--cn"], description = ["Overwrite the default CN for the signed file"])
+        @Option(names = ["-r", "--resource-patcher"], description = ["Disable patching resources"])
-    var cn = "ReVanced"
+        var disableResourcePatching: Boolean = false
 
-    @Option(names = ["-p", "--password"], description = ["Overwrite the default password for the signed file"])
+        @Option(names = ["--experimental"], description = ["Disable patch version compatibility patch"])
-    var password = "ReVanced"
+        var experimental: Boolean = false
 
-    @Option(names = ["-d", "--deploy-on"], description = ["If specified, deploy to adb device with given name"])
+        @Option(names = ["-m", "--merge"], description = ["One or more dex file containers to merge"])
-    var deploy: String? = null
+        var mergeFiles = listOf<File>()
 
-    @Option(names = ["-t", "--temp-dir"], description = ["Temporal resource cache directory"])
+        @Option(names = ["--mount"], description = ["If specified, instead of installing, mount"])
-    var cacheDirectory = "revanced-cache"
+        var mount: Boolean = false
 
-    @Option(
+        @Option(names = ["--cn"], description = ["Overwrite the default CN for the signed file"])
-        names = ["-c", "--clean"],
+        var cn = "ReVanced"
-        description = ["Clean the temporal resource cache directory. This will be done anyways when running the patcher"]
+
-    )
+        @Option(names = ["--keystore"], description = ["File path to your keystore"])
-    var clean: Boolean = false
+        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"
+
+        @Option(
+            names = ["-c", "--clean"],
+            description = ["Clean the temporal resource cache directory. This will be done anyways when running the patcher"]
+        )
+        var clean: Boolean = false
+    }
 
     override fun run() {
-        if (listOnly) {
+        if (args.lArgs?.listOnly == true) {
-            for (patchBundlePath in patchBundles) for (patch in JarPatchBundle(patchBundlePath).loadPatches()) {
+            for (patchBundlePath in args.patchBundles) for (patch in JarPatchBundle(patchBundlePath).loadPatches()) {
-                println("[available] ${patch.patchName}")
+                logger.info("${patch.patchName}: ${patch.description}")
             }
             return
         }
 
-        val patcher = app.revanced.patcher.Patcher(PatcherOptions(inputFile, cacheDirectory, !disableResourcePatching))
+        val args = args.pArgs ?: return
 
-        val outputFile = File(outputPath)
+        logger.info("Initialize patcher")
 
-        val adb: Adb? = deploy?.let {
+        val patcher = app.revanced.patcher.Patcher(
-            Adb(outputFile, patcher.data.packageMetadata.packageName, deploy!!, install)
+            PatcherOptions(
+                args.inputFile, args.cacheDirectory, !args.disableResourcePatching
+            )
+        )
+
+        val outputFile = File(args.outputPath)
+
+        val adb: Adb? = args.deploy?.let {
+            Adb(outputFile, patcher.data.packageMetadata.packageName, args.deploy!!, !args.mount)
         }
 
-        val patchedFile = if (install) File(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) {
-
-        if (install) {
             Signing.start(
-                patchedFile,
+                patchedFile, outputFile, SigningOptions(
-                outputFile,
+                    args.cn,
-                cn,
+                    args.password,
-                password,
+                    args.keystorePath
+                        ?: Path(outputFile.parent).resolve("${outputFile.nameWithoutExtension}.keystore").name
+                )
             )
         }
 
-        if (clean) File(cacheDirectory).deleteRecursively()
+        if (args.clean) File(args.cacheDirectory).deleteRecursively()
 
-        adb?.let {
+        adb?.deploy()
-            println("[deploying]")
-            it.deploy()
-        }
 
-        if (clean && deploy != null) Files.delete(outputFile.toPath())
+        if (args.clean && args.deploy != null) Files.delete(outputFile.toPath())
 
-        println("[done]")
+        logger.info("Done")
     }
 }

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

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

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

@@ -1,24 +1,31 @@
 package app.revanced.cli.signing
 
-import app.revanced.cli.command.MainCommand.cacheDirectory
+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) {
+    fun start(inputFile: File, outputFile: File, signingOptions: SigningOptions) {
-        val cacheDirectory = File(cacheDirectory)
+        val cacheDirectory = File(args.pArgs!!.cacheDirectory)
         val alignedOutput = cacheDirectory.resolve("${outputFile.nameWithoutExtension}_aligned.apk")
         val signedOutput = cacheDirectory.resolve("${outputFile.nameWithoutExtension}_signed.apk")
 
+        logger.info("Align zip entries")
+
         // align the inputFile and write to alignedOutput
         ZipAligner.align(inputFile, alignedOutput)
+
+        logger.info("Sign zip file")
+
         // sign the alignedOutput and write to signedOutput
         // the reason is, in case the signer fails
         // it does not damage the output file
-        Signer(cn, password).signApk(alignedOutput, signedOutput)
+        val keyStore = Signer(signingOptions).signApk(alignedOutput, signedOutput)
 
-        // afterwards copy over the file to the output
+        // afterwards copy over the file and the keystore to the output
         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
@@ -29,8 +30,12 @@ internal class Adb(
 
     internal fun deploy() {
         if (modeInstall) {
+            logger.info("Install without mount")
+
             PackageManager(device).install(file)
         } else {
+            logger.info("Install by mount")
+
             // push patched file
             device.copy(Constants.PATH_INIT_PUSH, file)
 

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

@@ -54,6 +54,8 @@ internal object Constants {
             
             base_path="$PATH_REVANCED_APP"
             stock_path=${'$'}( pm path $PLACEHOLDER | grep base | sed 's/package://g' )
+
+            chcon u:object_r:apk_data_file:s0  ${'$'}base_path
             mount -o bind ${'$'}base_path ${'$'}stock_path
         """.trimIndent()
 }

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

@@ -7,12 +7,17 @@ import java.nio.file.Files
 import java.nio.file.Path
 import java.util.zip.ZipEntry
 
-internal class ZipFileSystemUtils(
+internal class ZipFileSystemUtils(input: File?, output: File) : Closeable {
-    file: File
+    private val inFileSystem = if (input != null) {
-) : Closeable {
+        FileSystems.newFileSystem(input.toPath())
-    private var zipFileSystem = FileSystems.newFileSystem(file.toPath(), mapOf("noCompression" to true))
+    } else null
+    private val outFileSystem = FileSystems.newFileSystem(output.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")
+        }
+
         if (Files.isDirectory(this)) {
             Files.list(this).forEach { path ->
                 path.deleteRecursively()
@@ -22,19 +27,25 @@ internal class ZipFileSystemUtils(
         Files.delete(this)
     }
 
-    internal fun writePathRecursively(path: Path) {
+    internal fun writeInput() {
-        Files.list(path).let { fileStream ->
+        if (inFileSystem == null) {
+            throw IllegalArgumentException("Input file not set")
+        }
+        val root = inFileSystem.getPath(inFileSystem.separator)
+
+        Files.list(root).close()
+
+        Files.list(root).also { fileStream ->
             fileStream.forEach { filePath ->
-                val fileSystemPath = filePath.getRelativePath(path)
+                val fileSystemPath = filePath.getRelativePath(root)
                 fileSystemPath.deleteRecursively()
             }
-
-            fileStream
         }.close()
 
-        Files.walk(path).let { fileStream ->
+        Files.walk(root).also { fileStream ->
+            // don't include build directory by skipping the root node.
             fileStream.skip(1).forEach { filePath ->
-                val relativePath = filePath.getRelativePath(path)
+                val relativePath = filePath.getRelativePath(root)
 
                 if (Files.isDirectory(filePath)) {
                     Files.createDirectory(relativePath)
@@ -43,17 +54,18 @@ internal class ZipFileSystemUtils(
 
                 Files.copy(filePath, relativePath)
             }
-
-            fileStream
         }.close()
     }
 
-    internal fun write(path: String, content: ByteArray) = Files.write(zipFileSystem.getPath(path), content)
+    internal fun write(path: String, content: ByteArray) = Files.write(outFileSystem.getPath(path), content)
 
-    private fun Path.getRelativePath(path: Path): Path = zipFileSystem.getPath(path.relativize(this).toString())
+    private fun Path.getRelativePath(path: Path): Path = outFileSystem.getPath(path.relativize(this).toString())
 
     internal fun uncompress(vararg paths: String) =
-        paths.forEach { Files.setAttribute(zipFileSystem.getPath(it), "zip:method", ZipEntry.STORED) }
+        paths.forEach { Files.setAttribute(outFileSystem.getPath(it), "zip:method", ZipEntry.STORED) }
 
-    override fun close() = zipFileSystem.close()
+    override fun close() {
+        inFileSystem?.close()
+        outFileSystem.close()
+    }
 }

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

@@ -1,8 +1,8 @@
 package app.revanced.utils.patcher
 
 import app.revanced.cli.command.MainCommand
-import app.revanced.cli.command.MainCommand.debugging
+import app.revanced.cli.command.MainCommand.args
-import app.revanced.cli.command.MainCommand.patchBundles
+import app.revanced.cli.command.MainCommand.logger
 import app.revanced.patcher.Patcher
 import app.revanced.patcher.data.base.Data
 import app.revanced.patcher.extensions.PatchExtensions.compatiblePackages
@@ -12,44 +12,45 @@ import app.revanced.patcher.patch.base.Patch
 import app.revanced.patcher.util.patch.implementation.JarPatchBundle
 
 fun Patcher.addPatchesFiltered(
-    includeFilter: Boolean = false
+    excludePatches: Boolean = false
 ) {
     val packageName = this.data.packageMetadata.packageName
     val packageVersion = this.data.packageMetadata.packageVersion
 
-    patchBundles.forEach { bundle ->
+    args.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 = "Skip $patchName"
 
-            if (includeFilter) {
+            val args = MainCommand.args.pArgs!!
-                if (!MainCommand.includedPatches.contains(patchName)) {
+
-                    println("$prefix: Explicitly excluded.")
+            if (excludePatches && args.excludedPatches.contains(patchName)) {
-                    return@patch
+                logger.info("$prefix: Explicitly excluded")
-                }
+                return@patch
             } else if (!patch.include) {
-                println("$prefix: Implicitly excluded.")
+                logger.info("$prefix: Implicitly excluded")
                 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.info("$prefix: Incompatible package")
                     return@patch
                 }
 
-                if (!(debugging || compatiblePackages.any { it.versions.isEmpty() || it.versions.any { version -> version == packageVersion }})) {
+                if (!(args.experimental || compatiblePackages.any { it.versions.isEmpty() || it.versions.any { version -> version == packageVersion } })) {
-                    println("$prefix: The package version is $packageVersion and is incompatible.")
+                    logger.info("$prefix: The package version is $packageVersion and is incompatible")
                     return@patch
                 }
             }
 
+            logger.info("Add $patchName")
+
             includedPatches.add(patch)
-            println("[added] $patchName")
         }
         this.addPatches(includedPatches)
     }
@@ -58,14 +59,16 @@ fun Patcher.addPatchesFiltered(
 fun Patcher.applyPatchesVerbose() {
     this.applyPatches().forEach { (patch, result) ->
         if (result.isSuccess) {
-            println("[success] $patch")
+            logger.info("Success: $patch")
+
             return@forEach
         }
-        println("[error] $patch:")
+        logger.error("Error: $patch")
+
         result.exceptionOrNull()!!.printStackTrace()
     }
 }
 
 fun Patcher.mergeFiles() {
-    this.addFiles(MainCommand.mergeFiles)
+    this.addFiles(args.pArgs!!.mergeFiles)
 }

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

@@ -1,7 +1,6 @@
 package app.revanced.utils.signature
 
 import app.revanced.patcher.Patcher
-import org.jf.dexlib2.iface.Method
 
 object Signature {
 
@@ -49,7 +48,7 @@ object Signature {
          */
     }
 
-    private fun Method.toStr(): String {
+    //private fun Method.toStr(): String {
-        return "${this.name}(${this.parameterTypes.joinToString("")})${this.returnType}"
+    //    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,27 +50,30 @@ internal class Signer(
         return JcaX509CertificateConverter().getCertificate(builder.build(signer)) to pair.private
     }
 
-    fun signApk(input: File, output: File) {
+    fun signApk(input: File, output: File): File {
         Security.addProvider(BouncyCastleProvider())
 
-        val ks = File(input.parent, "revanced-cli.keystore")
+        // TODO: keystore should be saved securely
-        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
     }
 }