chore(release): 1.9.2 [skip ci]

## [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](0df936e99b))

.github/workflows/release.yml

@@ -1,5 +1,6 @@
 name: Release
 on:
+  workflow_dispatch:
   push:
     branches:
       - main
@@ -27,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

.idea/vcs.xml

@@ -8,5 +8,7 @@
   </component>
   <component name="VcsDirectoryMappings">
     <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/../revanced-patcher" vcs="Git" />
+    <mapping directory="$PROJECT_DIR$/../revanced-patches" vcs="Git" />
   </component>
 </project>

.releaserc

@@ -20,6 +20,15 @@
         ]
       }
     ],
-    "@semantic-release/github"
+    [
+      "@semantic-release/github",
+      {
+        "assets": [
+          {
+            "path": "build/libs/*all.jar"
+          }
+        ]
+      }
+    ]
   ]
-}
+}

CHANGELOG.md

@@ -1,3 +1,257 @@
+## [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)
+
+
+### 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)
+
+
+### Bug Fixes
+
+* check if `packageVersion` is compatible with any from `compatiblePackages` ([32589c8](https://github.com/revanced/revanced-cli/commit/32589c88e438e0a1375c256e9bb8a93f5a4d319b))
+
+# [1.3.0](https://github.com/revanced/revanced-cli/compare/v1.2.0...v1.3.0) (2022-06-11)
+
+
+### Bug Fixes
+
+* `Main-Class` attribute pointing to wrong method ([6e82418](https://github.com/revanced/revanced-cli/commit/6e824189586bfa4f8aaac4a5f33aed8d59261115))
+* `ZipAligner` not correctly calculating the file offset ([2975a47](https://github.com/revanced/revanced-cli/commit/2975a47d0f682a92da7b3ed455f5078298b0cbaa))
+* broken control flow of `includeFilter` ([a0644c7](https://github.com/revanced/revanced-cli/commit/a0644c7045344e6a6c324392cb8f507a6d9dbfad))
+* check for root even though when not needed ([0d7581a](https://github.com/revanced/revanced-cli/commit/0d7581ad750525e59bd6c019d987c640588ead62))
+* overwrite output file ([2bfbbc2](https://github.com/revanced/revanced-cli/commit/2bfbbc2eb9057e66a362d37973a108baf44edf7a))
+* resource patcher ([9da4f70](https://github.com/revanced/revanced-cli/commit/9da4f707ac62d11993021871ef39f4f1709ba89d))
+* sign the aligned file instead of the input file ([22d2535](https://github.com/revanced/revanced-cli/commit/22d2535af8b3ea8fa58b6beb2938d240afa0a17d))
+
+
+### Features
+
+* support for `--install` ([d1ceab4](https://github.com/revanced/revanced-cli/commit/d1ceab45c89901f79d46c62f03186502021afb26))
+
+# [1.2.0](https://github.com/revanced/revanced-cli/compare/v1.1.5...v1.2.0) (2022-06-05)
+
+
+### Bug Fixes
+
+* migrate to latest patcher api changes ([ace70e4](https://github.com/revanced/revanced-cli/commit/ace70e417fdf280c7630a5a89a773879fd240e96))
+
+
+### Features
+
+* add path for `cacheDirectory` and enable resource patching by default ([54c0a03](https://github.com/revanced/revanced-cli/commit/54c0a03d44c8d1b586bc487ee1ca71859d6f0b57))
+* debugging option ([1b645c6](https://github.com/revanced/revanced-cli/commit/1b645c67db58eb4d49b5290fd247507c9b43a9c6))
+
+# [1.2.0-dev.2](https://github.com/revanced/revanced-cli/compare/v1.2.0-dev.1...v1.2.0-dev.2) (2022-06-05)
+
+
+### Features
+
+* debugging option ([1b645c6](https://github.com/revanced/revanced-cli/commit/1b645c67db58eb4d49b5290fd247507c9b43a9c6))
+
+# [1.2.0-dev.1](https://github.com/revanced/revanced-cli/compare/v1.1.6-dev.1...v1.2.0-dev.1) (2022-06-04)
+
+
+### Features
+
+* add path for `cacheDirectory` and enable resource patching by default ([54c0a03](https://github.com/revanced/revanced-cli/commit/54c0a03d44c8d1b586bc487ee1ca71859d6f0b57))
+
+## [1.1.6-dev.1](https://github.com/revanced/revanced-cli/compare/v1.1.5...v1.1.6-dev.1) (2022-05-31)
+
+
+### Bug Fixes
+
+* migrate to latest patcher api changes ([ace70e4](https://github.com/revanced/revanced-cli/commit/ace70e417fdf280c7630a5a89a773879fd240e96))
+
+## [1.1.5](https://github.com/revanced/revanced-cli/compare/v1.1.4...v1.1.5) (2022-05-27)
+
+
+### Bug Fixes
+
+* invalid code flow when adding patches ([206f202](https://github.com/revanced/revanced-cli/commit/206f2029d7498b6474c16a47cbe451c170fdd31f))
+
+## [1.1.4](https://github.com/revanced/revanced-cli/compare/v1.1.3...v1.1.4) (2022-05-26)
+
+
+### Bug Fixes
+
+* migrate from `PatchLoader.load(...)` to `JarPatchBundle(...).loadPatches()` ([cabd32f](https://github.com/revanced/revanced-cli/commit/cabd32fda41d32616a61ae450c60e1ee7c35bc59))
+
+## [1.1.3](https://github.com/revanced/revanced-cli/compare/v1.1.2...v1.1.3) (2022-05-25)
+
+
+### Bug Fixes
+
+* only accept directories when looking for files in resource patch ([c76da7e](https://github.com/revanced/revanced-cli/commit/c76da7e5ffa208860eea008dad358e4e3bb3d735))
+
+## [1.1.2](https://github.com/revanced/revanced-cli/compare/v1.1.1...v1.1.2) (2022-05-22)
+
+
+### Bug Fixes
+
+* delete `outputFile` after deploying ([329f8a3](https://github.com/revanced/revanced-cli/commit/329f8a383fe52f4c2a66075d893c6599d3550bee))
+
+## [1.1.1](https://github.com/revanced/revanced-cli/compare/v1.1.0...v1.1.1) (2022-05-22)
+
+
+### Bug Fixes
+
+* breaking changes by `revanced-patcher` dependency ([51d2504](https://github.com/revanced/revanced-cli/commit/51d250491f390695aedc64e7ee71a9dcf99d695c))
+* wrong use of dependency to `revanced-patches` ([351de6c](https://github.com/revanced/revanced-cli/commit/351de6cb90aa0f2ec93e8b8f6c10d7d312082079))
+* wrong use of variable substitution / typo ([81d53b5](https://github.com/revanced/revanced-cli/commit/81d53b5518454e479b7a8f2e9be934bee30702af)), closes [revanced/revanced-cli#12](https://github.com/revanced/revanced-cli/issues/12)
+
+# [1.1.0-dev.3](https://github.com/revanced/revanced-cli/compare/v1.1.0-dev.2...v1.1.0-dev.3) (2022-05-15)
+
+
+### Bug Fixes
+
+* wrong use of variable substitution / typo ([81d53b5](https://github.com/revanced/revanced-cli/commit/81d53b5518454e479b7a8f2e9be934bee30702af)), closes [revanced/revanced-cli#12](https://github.com/revanced/revanced-cli/issues/12)
+
 # [1.1.0-dev.2](https://github.com/revanced/revanced-cli/compare/v1.1.0-dev.1...v1.1.0-dev.2) (2022-05-07)
 
 

build.gradle.kts

@@ -1,40 +1,42 @@
 plugins {
-    kotlin("jvm") version "1.6.20"
+    kotlin("jvm") version "1.7.0"
     id("com.github.johnrengelman.shadow") version "7.1.2"
-    java
-    `maven-publish`
 }
 
 group = "app.revanced"
 
+val githubUsername: String = project.findProperty("gpr.user") as? String ?: System.getenv("GITHUB_ACTOR")
+val githubPassword: String = project.findProperty("gpr.key") as? String ?: System.getenv("GITHUB_TOKEN")
+
 repositories {
     mavenCentral()
-    mavenLocal()
     maven {
         url = uri("https://maven.pkg.github.com/revanced/multidexlib2")
         credentials {
-            username = project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR") // DO NOT CHANGE!
-            password = project.findProperty("gpr.key") as String? ?: System.getenv("GITHUB_TOKEN") // DO NOT CHANGE!
+            username = githubUsername
+            password = githubPassword
         }
     }
     maven {
-        url = uri("https://jitpack.io")
+        url = uri("https://maven.pkg.github.com/revanced/revanced-patcher")
+        credentials {
+            username = githubUsername
+            password = githubPassword
+        }
     }
+    maven { url = uri("https://jitpack.io") }
+    google()
 }
 
 dependencies {
     implementation(kotlin("stdlib"))
-    implementation("app.revanced:revanced-patcher:+")
-    implementation("info.picocli:picocli:+")
+    implementation(kotlin("reflect"))
 
-    implementation("me.tongfei:progressbar:+")
-    implementation("com.github.li-wjohnson:jadb:master-SNAPSHOT") // using a fork instead.
-    implementation("org.bouncycastle:bcpkix-jdk15on:+")
-}
-
-java {
-    withSourcesJar()
-    withJavadocJar()
+    implementation("app.revanced:revanced-patcher:1.7.1")
+    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")
 }
 
 tasks {
@@ -43,27 +45,17 @@ tasks {
     }
     shadowJar {
         manifest {
-            attributes("Main-Class" to "app.revanced.cli.MainKt")
+            attributes("Main-Class" to "app.revanced.cli.main.MainKt")
             attributes("Implementation-Title" to project.name)
             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)
+    }
 }
-
-publishing {
-    repositories {
-        maven {
-            name = "GitHubPackages"
-            url = uri("https://maven.pkg.github.com/revanced/revanced-cli")
-            credentials {
-                username = System.getenv("GITHUB_ACTOR")
-                password = System.getenv("GITHUB_TOKEN")
-            }
-        }
-    }
-    publications {
-        register<MavenPublication>("gpr") {
-            from(components["java"])
-        }
-    }
-}

gradle.properties

@@ -1,2 +1,2 @@
 kotlin.code.style = official
-version = 1.1.0-dev.2
+version = 1.9.2

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-all.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -1,82 +0,0 @@
-package app.revanced.cli
-
-import app.revanced.patch.Patches
-import app.revanced.utils.adb.Adb
-import picocli.CommandLine.*
-import java.io.File
-
-@Command(
-    name = "ReVanced-CLI", version = ["1.0.0"], mixinStandardHelpOptions = true
-)
-internal object MainCommand : Runnable {
-    @Parameters(
-        paramLabel = "INCLUDE",
-        description = ["Which patches to include. If none is specified, all compatible patches will be included"]
-    )
-    internal var includedPatches = arrayOf<String>()
-
-    @Option(names = ["-p", "--patches"], description = ["One or more bundles of patches"])
-    internal var patchBundles = arrayOf<File>()
-
-    @Option(names = ["-t", "--temp-dir"], description = ["Temporal resource cache directory"], required = true)
-    internal lateinit var cacheDirectory: String
-
-    @Option(names = ["-r", "--resource-patcher"], description = ["Enable patching resources"])
-    internal var patchResources: Boolean = false
-
-    @Option(
-        names = ["-c", "--clean"],
-        description = ["Clean the temporal resource cache directory. This will be done anyways when running the patcher"]
-    )
-    internal var clean: Boolean = false
-
-    @Option(names = ["-l", "--list"], description = ["List patches only"])
-    internal var listOnly: Boolean = false
-
-    @Option(names = ["-m", "--merge"], description = ["One or more dex file containers to merge"])
-    internal var mergeFiles = listOf<File>()
-
-    @Option(names = ["-a", "--apk"], description = ["Input file to be patched"], required = true)
-    internal lateinit var inputFile: File
-
-    @Option(names = ["-o", "--out"], description = ["Output file path"], required = true)
-    internal lateinit var outputPath: String
-
-    @Option(names = ["-d", "--deploy-on"], description = ["If specified, deploy to adb device with given name"])
-    internal var deploy: String? = null
-
-    override fun run() {
-        if (listOnly) {
-            patchBundles.forEach {
-                Patches.load(it).forEach {
-                    println(it().metadata)
-                }
-            }
-            return
-        }
-
-        val patcher = app.revanced.patcher.Patcher(
-            inputFile,
-            cacheDirectory,
-            patchResources
-        )
-
-        Patcher.start(patcher)
-
-        if (clean) {
-            File(cacheDirectory).deleteRecursively()
-        }
-
-        val outputFile = File(outputPath)
-
-        deploy?.let {
-            Adb(
-                outputFile,
-                patcher.packageName,
-                deploy!!
-            ).deploy()
-        }
-
-        if (clean) outputFile.delete()
-    }
-}

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

@@ -1,87 +0,0 @@
-package app.revanced.cli
-
-import app.revanced.patch.Patches
-import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
-import app.revanced.utils.filesystem.FileSystemUtils
-import app.revanced.utils.signing.Signer
-import java.io.File
-
-internal class Patcher {
-    internal companion object {
-        internal fun start(patcher: app.revanced.patcher.Patcher) {
-            // merge files like necessary integrations
-            patcher.addFiles(MainCommand.mergeFiles)
-            // add patches, but filter incompatible or excluded patches
-            patcher.addPatchesFiltered()
-            // apply patches
-            for ((meta, result) in patcher.applyPatches {
-                println("Applying $it.")
-            }) {
-                println("Applied ${meta.name}. The result was $result.")
-            }
-
-            // write output file
-            val outFile = File(MainCommand.outputPath)
-            if (outFile.exists()) outFile.delete()
-            MainCommand.inputFile.copyTo(outFile)
-
-            val zipFileSystem = FileSystemUtils(outFile)
-
-            // replace all dex files
-            for ((name, data) in patcher.save()) {
-                zipFileSystem.replaceFile(name, data.data)
-            }
-
-            if (MainCommand.patchResources) {
-                for (file in File(MainCommand.cacheDirectory).resolve("build/").listFiles().first().listFiles()) {
-                    if (!file.isDirectory) {
-                        zipFileSystem.replaceFile(file.name, file.readBytes())
-                        continue
-                    }
-                    zipFileSystem.replaceDirectory(file)
-                }
-            }
-
-            // finally close the stream
-            zipFileSystem.close()
-
-            // and sign the apk file
-            Signer.signApk(outFile)
-        }
-
-        private fun app.revanced.patcher.Patcher.addPatchesFiltered() {
-            val packageName = this.packageName
-            val packageVersion = this.packageVersion
-
-            val checkInclude = MainCommand.includedPatches.isNotEmpty()
-
-            MainCommand.patchBundles.forEach { bundle ->
-                val includedPatches = mutableListOf<Patch<Data>>()
-                Patches.load(bundle).forEach patch@{
-                    val patch = it()
-
-                    val filterOutPatches = true
-                    if (filterOutPatches && !patch.metadata.compatiblePackages.any { packageMetadata ->
-                            packageMetadata.name == packageName && packageMetadata.versions.any {
-                                it == packageVersion
-                            }
-                        }) {
-
-                        println("Skipping ${patch.metadata.name} due to incompatibility with current package $packageName.")
-                        return@patch
-                    }
-
-                    if (checkInclude && !MainCommand.includedPatches.contains(patch.metadata.shortName)) {
-                        return@patch
-                    }
-
-                    println("Adding ${patch.metadata.name}.")
-                    includedPatches.add(patch)
-
-                }
-                this.addPatches(includedPatches)
-            }
-        }
-    }
-}

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

@@ -0,0 +1,134 @@
+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.*
+import java.io.File
+import java.nio.file.Files
+
+@Command(
+    name = "ReVanced-CLI", version = ["1.0.0"], mixinStandardHelpOptions = true
+)
+internal object MainCommand : Runnable {
+    @ArgGroup(exclusive = false, multiplicity = "1")
+    lateinit var args: Args
+
+    class Args {
+        @Option(names = ["-b", "--bundles"], description = ["One or more bundles of patches"], required = true)
+        var patchBundles = arrayOf<String>()
+
+        @ArgGroup(exclusive = false)
+        var lArgs: ListingArgs? = null
+
+        @ArgGroup(exclusive = false)
+        var pArgs: PatchingArgs? = null
+    }
+
+    class ListingArgs {
+        @Option(names = ["-l", "--list"], description = ["List patches only"], required = true)
+        var listOnly: Boolean = false
+    }
+
+    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 = ["-r", "--resource-patcher"], description = ["Disable patching resources"])
+        var disableResourcePatching: Boolean = false
+
+        @Option(names = ["--experimental"], description = ["Disable patch version compatibility patch"])
+        var experimental: Boolean = false
+
+        @Option(names = ["-m", "--merge"], description = ["One or more dex file containers to merge"])
+        var mergeFiles = listOf<File>()
+
+        @Option(names = ["--mount"], description = ["If specified, instead of installing, mount"])
+        var mount: Boolean = false
+
+        @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"
+
+        @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 (args.lArgs?.listOnly == true) {
+            for (patchBundlePath in args.patchBundles) for (patch in JarPatchBundle(patchBundlePath).loadPatches()) {
+                println("[available] ${patch.patchName}: ${patch.description}")
+            }
+            return
+        }
+
+        val args = args.pArgs ?: return
+
+        val patcher = app.revanced.patcher.Patcher(
+            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 (args.mount) outputFile
+        else File(args.cacheDirectory).resolve("${outputFile.nameWithoutExtension}_raw.apk")
+
+        Patcher.start(patcher, patchedFile)
+
+        if (!args.mount) {
+            Signing.start(
+                patchedFile,
+                outputFile,
+                SigningOptions(
+                    args.cn,
+                    args.password,
+                    args.keystorePath ?: outputFile.parentFile
+                        .resolve("${outputFile.nameWithoutExtension}.keystore")
+                        .name
+                )
+            )
+        }
+
+        if (args.clean) File(args.cacheDirectory).deleteRecursively()
+
+        adb?.let {
+            println("[deploying]")
+            it.deploy()
+        }
+
+        if (args.clean && args.deploy != null) Files.delete(outputFile.toPath())
+
+        println("[done]")
+    }
+}

src/main/kotlin/app/revanced/cli/main/Main.kt

@@ -1,5 +1,6 @@
-package app.revanced.cli
+package app.revanced.cli.main
 
+import app.revanced.cli.command.MainCommand
 import picocli.CommandLine
 
 internal fun main(args: Array<String>) {

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

@@ -0,0 +1,44 @@
+package app.revanced.cli.patcher
+
+import app.revanced.cli.command.MainCommand.args
+import app.revanced.utils.filesystem.ZipFileSystemUtils
+import app.revanced.utils.patcher.addPatchesFiltered
+import app.revanced.utils.patcher.applyPatchesVerbose
+import app.revanced.utils.patcher.mergeFiles
+import java.io.File
+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(excludePatches = args.excludedPatches.isNotEmpty())
+        // apply patches
+        patcher.applyPatchesVerbose()
+
+        // write output file
+        if (output.exists()) Files.delete(output.toPath())
+        args.inputFile.copyTo(output)
+
+        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
+            result.dexFiles.forEach {
+                fileSystem.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())
+            }
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+package app.revanced.cli.signing
+
+import app.revanced.cli.command.MainCommand.args
+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, signingOptions: SigningOptions) {
+        val cacheDirectory = File(args.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
+        println("[aligning]")
+        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
+        println("[signing]")
+        val keyStore = Signer(signingOptions).signApk(alignedOutput, signedOutput)
+
+        // 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/patch/Patches.kt

@@ -1,26 +0,0 @@
-package app.revanced.patch
-
-import app.revanced.patcher.data.base.Data
-import app.revanced.patcher.patch.base.Patch
-import java.io.File
-import java.net.URLClassLoader
-
-internal object Patches {
-
-    /**
-     * This method loads patches from a given patch file
-     * @return the loaded patches represented as a list of functions returning instances of [Patch]
-     */
-    internal fun load(patchesJar: File): List<() -> Patch<Data>> {
-        val url = patchesJar.toURI().toURL()
-        val classLoader = URLClassLoader(arrayOf(url))
-
-        val indexClass = classLoader.loadClass("app.revanced.patches.Index")
-
-        val index = indexClass.declaredFields.last()
-        index.isAccessible = true
-
-        @Suppress("UNCHECKED_CAST")
-        return index.get(null) as List<() -> Patch<Data>>
-    }
-}

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

@@ -2,13 +2,15 @@ package app.revanced.utils.adb
 
 import se.vidstige.jadb.JadbConnection
 import se.vidstige.jadb.JadbDevice
+import se.vidstige.jadb.managers.PackageManager
 import java.io.File
 import java.util.concurrent.Executors
 
 internal class Adb(
-    private val apk: File,
+    private val file: File,
     private val packageName: String,
     deviceName: String,
+    private val modeInstall: Boolean = false,
     private val logging: Boolean = true
 ) {
     private val device: JadbDevice
@@ -17,49 +19,54 @@ internal class Adb(
         device = JadbConnection().devices.find { it.serial == deviceName }
             ?: throw IllegalArgumentException("No such device with name $deviceName")
 
-        if (device.run("su -h", false) != 0)
+        if (!modeInstall && device.run("su -h", false) != 0)
             throw IllegalArgumentException("Root required on $deviceName. Deploying failed.")
     }
 
-    private fun String.replacePlaceholder(): String {
-        return this.replace(Constants.PLACEHOLDER, packageName)
+    private fun String.replacePlaceholder(with: String? = null): String {
+        return this.replace(Constants.PLACEHOLDER, with ?: packageName)
     }
 
     internal fun deploy() {
-        // create revanced path
-        device.run("${Constants.COMMAND_CREATE_DIR} ${Constants.PATH_REVANCED}")
+        if (modeInstall) {
+            PackageManager(device).install(file)
+        } else {
+            // push patched file
+            device.copy(Constants.PATH_INIT_PUSH, file)
 
-        // push patched file
-        device.copy(Constants.PATH_INIT_PUSH, apk)
-        // install apk
-        device.run(Constants.COMMAND_INSTALL_APK.replacePlaceholder())
+            // create revanced path
+            device.run("${Constants.COMMAND_CREATE_DIR} ${Constants.PATH_REVANCED}")
 
-        // push mount script
-        device.createFile(
-            Constants.PATH_INIT_PUSH,
-            Constants.CONTENT_MOUNT_SCRIPT.replacePlaceholder()
-        )
-        // install mount script
-        device.run(Constants.COMMAND_INSTALL_MOUNT.replacePlaceholder())
+            // prepare mounting the apk
+            device.run(Constants.COMMAND_PREPARE_MOUNT_APK.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())
+            // push mount script
+            device.createFile(
+                Constants.PATH_INIT_PUSH,
+                Constants.CONTENT_MOUNT_SCRIPT.replacePlaceholder()
+            )
+            // install mount script
+            device.run(Constants.COMMAND_INSTALL_MOUNT.replacePlaceholder())
 
-        // unmount the apk for sanity
-        device.run(Constants.PATH_UMOUNT.replacePlaceholder())
-        // mount the apk
-        device.run(Constants.PATH_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())
 
-        // relaunch app
-        device.run(Constants.COMMAND_RESTART.replacePlaceholder())
+            // unmount the apk for sanity
+            device.run(Constants.PATH_UMOUNT.replacePlaceholder())
+            // mount the apk
+            device.run(Constants.PATH_MOUNT.replacePlaceholder())
 
-        // log the app
-        log()
+            // relaunch app
+            device.run(Constants.COMMAND_RESTART.replacePlaceholder())
+
+            // log the app
+            log()
+        }
     }
 
     private fun log() {

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

@@ -8,14 +8,14 @@ internal object Constants {
     private const val COMMAND_CHMOD_MOUNT = "chmod +x"
     internal const val COMMAND_PID_OF = "pidof -s"
     internal const val COMMAND_CREATE_DIR = "mkdir -p"
-    internal const val COMMAND_LOGCAT = "logcat -c && logcat --pid=$($COMMAND_PID_OF $PLACEHOLDER)"
+    internal const val COMMAND_LOGCAT = "logcat -c && logcat | grep AndroidRuntime"
     internal const val COMMAND_RESTART = "monkey -p $PLACEHOLDER 1 && kill ${'$'}($COMMAND_PID_OF $PLACEHOLDER)"
 
     // default mount file name
     private const val NAME_MOUNT_SCRIPT = "mount_revanced_$PLACEHOLDER.sh"
 
     // initial directory to push files to via adb push
-    internal const val PATH_INIT_PUSH = "/sdcard/revanced.delete"
+    internal const val PATH_INIT_PUSH = "/data/local/tmp/revanced.delete"
 
     // revanced path
     internal const val PATH_REVANCED = "/data/adb/revanced/"
@@ -28,7 +28,7 @@ internal object Constants {
     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_INSTALL_APK =
+    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"
 
     // install mount script & set permissions
@@ -42,7 +42,7 @@ internal object Constants {
         """
             #!/system/bin/sh
             
-            stock_path=${'$'}{ pm path $PLACEHOLDER | grep base | sed 's/package://g' }
+            stock_path=${'$'}( pm path $PLACEHOLDER | grep base | sed 's/package://g' )
             umount -l ${'$'}stock_path
         """.trimIndent()
 
@@ -53,7 +53,9 @@ internal object Constants {
             while [ "${'$'}(getprop sys.boot_completed | tr -d '\r')" != "1" ]; do sleep 1; done
             
             base_path="$PATH_REVANCED_APP"
-            stock_path=${'$'}{ pm path $PLACEHOLDER | grep base | sed 's/package://g' }
+            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/FileSystemUtils.kt

@@ -1,63 +0,0 @@
-package app.revanced.utils.filesystem
-
-import java.io.Closeable
-import java.io.File
-import java.nio.file.FileSystem
-import java.nio.file.FileSystems
-import java.nio.file.Files
-
-internal class FileSystemUtils(
-    file: File
-) : Closeable {
-    private var fileSystem: FileSystem
-
-    init {
-        fileSystem = FileSystems.newFileSystem(file.toPath(), null as ClassLoader?)
-    }
-
-    private fun deleteDirectory(dirPath: String) {
-        val files = Files.walk(fileSystem.getPath("$dirPath/"))
-
-        files
-            .sorted(Comparator.reverseOrder())
-            .forEach {
-
-                Files.delete(it)
-            }
-
-        files.close()
-    }
-
-
-    internal fun replaceDirectory(replacement: File) {
-        if (!replacement.isDirectory) throw Exception("${replacement.name} is not a directory.")
-
-        // FIXME: make this delete the directory recursively
-        //deleteDirectory(replacement.name)
-        //val path = Files.createDirectory(fileSystem.getPath(replacement.name))
-
-        val excludeFromPath = replacement.path.removeSuffix(replacement.name)
-        for (path in Files.walk(replacement.toPath())) {
-            val file = path.toFile()
-            if (file.isDirectory) {
-                val relativePath = path.toString().removePrefix(excludeFromPath)
-                val fileSystemPath = fileSystem.getPath(relativePath)
-                if (!Files.exists(fileSystemPath)) Files.createDirectory(fileSystemPath)
-
-                continue
-            }
-
-            replaceFile(path.toString().removePrefix(excludeFromPath), file.readBytes())
-        }
-    }
-
-    internal fun replaceFile(sourceFile: String, content: ByteArray) {
-        val path = fileSystem.getPath(sourceFile)
-        Files.deleteIfExists(path)
-        Files.write(path, content)
-    }
-
-    override fun close() {
-        fileSystem.close()
-    }
-}

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

@@ -0,0 +1,71 @@
+package app.revanced.utils.filesystem
+
+import java.io.Closeable
+import java.io.File
+import java.nio.file.FileSystems
+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))
+
+    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()
+            }
+        }
+
+        Files.delete(this)
+    }
+
+    internal fun writeInput() {
+        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(root)
+                fileSystemPath.deleteRecursively()
+            }
+        }.close()
+
+        Files.walk(root).also { fileStream ->
+            // don't include build directory by skipping the root node.
+            fileStream.skip(1).forEach { filePath ->
+                val relativePath = filePath.getRelativePath(root)
+
+                if (Files.isDirectory(filePath)) {
+                    Files.createDirectory(relativePath)
+                    return@forEach
+                }
+
+                Files.copy(filePath, relativePath)
+            }
+        }.close()
+    }
+
+    internal fun write(path: String, content: ByteArray) = Files.write(outFileSystem.getPath(path), content)
+
+    private fun Path.getRelativePath(path: Path): Path = outFileSystem.getPath(path.relativize(this).toString())
+
+    internal fun uncompress(vararg paths: String) =
+        paths.forEach { Files.setAttribute(outFileSystem.getPath(it), "zip:method", ZipEntry.STORED) }
+
+    override fun close() {
+        inFileSystem?.close()
+        outFileSystem.close()
+    }
+}

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

@@ -0,0 +1,70 @@
+package app.revanced.utils.patcher
+
+import app.revanced.cli.command.MainCommand
+import app.revanced.cli.command.MainCommand.args
+import app.revanced.patcher.Patcher
+import app.revanced.patcher.data.base.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.util.patch.implementation.JarPatchBundle
+
+fun Patcher.addPatchesFiltered(
+    excludePatches: Boolean = false
+) {
+    val packageName = this.data.packageMetadata.packageName
+    val packageVersion = this.data.packageMetadata.packageVersion
+
+    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 args = MainCommand.args.pArgs!!
+
+            if (excludePatches && args.excludedPatches.contains(patchName)) {
+                println("$prefix: Explicitly excluded.")
+                return@patch
+            } else if (!patch.include) {
+                println("$prefix: Implicitly excluded.")
+                return@patch
+            }
+
+            if (compatiblePackages == null) println("$prefix: Missing compatibility annotation. Continuing.")
+            else {
+                if (!compatiblePackages.any { it.name == packageName }) {
+                    println("$prefix: Incompatible package.")
+                    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.")
+                    return@patch
+                }
+            }
+
+            includedPatches.add(patch)
+            println("[added] $patchName")
+        }
+        this.addPatches(includedPatches)
+    }
+}
+
+fun Patcher.applyPatchesVerbose() {
+    this.applyPatches().forEach { (patch, result) ->
+        if (result.isSuccess) {
+            println("[success] $patch")
+            return@forEach
+        }
+        println("[error] $patch:")
+        result.exceptionOrNull()!!.printStackTrace()
+    }
+}
+
+fun Patcher.mergeFiles() {
+    this.addFiles(args.pArgs!!.mergeFiles)
+}

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

@@ -0,0 +1,54 @@
+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/KeySet.kt

@@ -1,9 +0,0 @@
-package app.revanced.utils.signing
-
-import java.security.PrivateKey
-import java.security.cert.X509Certificate
-
-data class KeySet(
-    val publicKey: X509Certificate,
-    val privateKey: PrivateKey
-)

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

@@ -1,65 +1,41 @@
-/*
- * Copyright (c) 2021 Juby210 & Vendicated
- * Licensed under the Open Software License version 3.0
- */
-
 package app.revanced.utils.signing
 
+import app.revanced.cli.signing.SigningOptions
+import com.android.apksig.ApkSigner
 import org.bouncycastle.asn1.x500.X500Name
 import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo
 import org.bouncycastle.cert.X509v3CertificateBuilder
-import org.bouncycastle.cert.jcajce.JcaCertStore
 import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter
-import org.bouncycastle.cms.*
-import org.bouncycastle.cms.jcajce.JcaSignerInfoGeneratorBuilder
 import org.bouncycastle.jce.provider.BouncyCastleProvider
 import org.bouncycastle.operator.ContentSigner
-import org.bouncycastle.operator.DigestCalculatorProvider
 import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder
-import org.bouncycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder
-import org.bouncycastle.util.encoders.Base64
-import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.math.BigInteger
-import java.nio.file.FileSystems
-import java.nio.file.Files
-import java.nio.file.Path
 import java.security.*
 import java.security.cert.X509Certificate
 import java.util.*
-import java.util.jar.Attributes
-import java.util.jar.JarFile
-import java.util.jar.Manifest
-import java.util.regex.Pattern
 
-
-const val CN = "ReVanced"
-val PASSWORD = "revanced".toCharArray() // TODO: make it secure; random password should be enough
-
-/**
- * APK Signer.
- * @author Aliucord authors
- * @author ReVanced team
- */
-object Signer {
+internal class Signer(
+    private val signingOptions: SigningOptions
+) {
+    private val passwordCharArray = signingOptions.password.toCharArray()
     private fun newKeystore(out: File) {
-        val key = createKey()
+        val (publicKey, privateKey) = createKey()
         val privateKS = KeyStore.getInstance("BKS", "BC")
-        privateKS.load(null, PASSWORD)
-        privateKS.setKeyEntry("alias", key.privateKey, PASSWORD, arrayOf(key.publicKey))
-        privateKS.store(FileOutputStream(out), PASSWORD)
+        privateKS.load(null, passwordCharArray)
+        privateKS.setKeyEntry("alias", privateKey, passwordCharArray, arrayOf(publicKey))
+        privateKS.store(FileOutputStream(out), passwordCharArray)
     }
 
-    private fun createKey(): KeySet {
+    private fun createKey(): Pair<X509Certificate, PrivateKey> {
         val gen = KeyPairGenerator.getInstance("RSA")
         gen.initialize(2048)
         val pair = gen.generateKeyPair()
         var serialNumber: BigInteger
-        do serialNumber =
-            BigInteger.valueOf(SecureRandom().nextLong()) while (serialNumber < BigInteger.ZERO)
-        val x500Name = X500Name("CN=$CN")
+        do serialNumber = BigInteger.valueOf(SecureRandom().nextLong()) while (serialNumber < BigInteger.ZERO)
+        val x500Name = X500Name("CN=${signingOptions.cn}")
         val builder = X509v3CertificateBuilder(
             x500Name,
             serialNumber,
@@ -69,143 +45,36 @@ object Signer {
             x500Name,
             SubjectPublicKeyInfo.getInstance(pair.public.encoded)
         )
-        val signer: ContentSigner = JcaContentSignerBuilder("SHA1withRSA").build(pair.private)
-        return KeySet(JcaX509CertificateConverter().getCertificate(builder.build(signer)), pair.private)
+        val signer: ContentSigner = JcaContentSignerBuilder("SHA256withRSA").build(pair.private)
+        return JcaX509CertificateConverter().getCertificate(builder.build(signer)) to pair.private
     }
 
-    private val stripPattern: Pattern = Pattern.compile("^META-INF/(.*)[.](MF|SF|RSA|DSA)$")
-
-    // based on https://gist.github.com/mmuszkow/10288441
-    // and https://github.com/fornwall/apksigner/blob/master/src/main/java/net/fornwall/apksigner/ZipSigner.java
-    fun signApk(apkFile: File) {
+    fun signApk(input: File, output: File): File {
         Security.addProvider(BouncyCastleProvider())
 
-        val ks = File(apkFile.parent, "revanced-cli.keystore")
-        if (!ks.exists()) newKeystore(ks)
+        // TODO: keystore should be saved securely
+        val ks = File(signingOptions.keyStoreFilePath)
+        if (!ks.exists()) newKeystore(ks) else {
+            println("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 keySet = KeySet(
-            (keyStore.getCertificate(alias) as X509Certificate),
-            (keyStore.getKey(alias, PASSWORD) as PrivateKey)
-        )
 
-        val zip = FileSystems.newFileSystem(apkFile.toPath(), null as ClassLoader?)
+        val config = ApkSigner.SignerConfig.Builder(
+            signingOptions.cn,
+            keyStore.getKey(alias, passwordCharArray) as PrivateKey,
+            listOf(keyStore.getCertificate(alias) as X509Certificate)
+        ).build()
 
-        val dig = MessageDigest.getInstance("SHA1")
-        val digests: MutableMap<String, String> = LinkedHashMap()
+        val signer = ApkSigner.Builder(listOf(config))
+        signer.setCreatedBy(signingOptions.cn)
+        signer.setInputApk(input)
+        signer.setOutputApk(output)
 
-        for (entry in zip.allEntries) {
-            val name = entry.toString()
-            if (stripPattern.matcher(name).matches()) {
-                Files.delete(entry)
-            } else {
-                digests[name] = toBase64(dig.digest(Files.readAllBytes(entry)))
-            }
-        }
+        signer.build().sign()
 
-        val sectionDigests: MutableMap<String, String> = LinkedHashMap()
-        var manifest = Manifest()
-        var attrs = manifest.mainAttributes
-        attrs[Attributes.Name.MANIFEST_VERSION] = "1.0"
-        attrs[Attributes.Name("Created-By")] = CN
-
-        val digestAttr = Attributes.Name("SHA1-Digest")
-        for ((name, value) in digests) {
-            val attributes = Attributes()
-            attributes[digestAttr] = value
-            manifest.entries[name] = attributes
-            sectionDigests[name] = hashEntrySection(name, attributes, dig)
-        }
-        ByteArrayOutputStream().use { baos ->
-            manifest.write(baos)
-            zip.writeFile(JarFile.MANIFEST_NAME, baos.toByteArray())
-        }
-
-        val manifestHash = getManifestHash(manifest, dig)
-        val tmpManifest = Manifest()
-        tmpManifest.mainAttributes.putAll(attrs)
-        val manifestMainHash = getManifestHash(tmpManifest, dig)
-
-        manifest = Manifest()
-        attrs = manifest.mainAttributes
-        attrs[Attributes.Name.SIGNATURE_VERSION] = "1.0"
-        attrs[Attributes.Name("Created-By")] = CN
-        attrs[Attributes.Name("SHA1-Digest-Manifest")] = manifestHash
-        attrs[Attributes.Name("SHA1-Digest-Manifest-Main-Attributes")] = manifestMainHash
-
-        for ((key, value) in sectionDigests) {
-            val attributes = Attributes()
-            attributes[digestAttr] = value
-            manifest.entries[key] = attributes
-        }
-        var sigBytes: ByteArray
-        ByteArrayOutputStream().use { sigStream ->
-            manifest.write(sigStream)
-            sigBytes = sigStream.toByteArray()
-            zip.writeFile("META-INF/CERT.SF", sigBytes)
-        }
-
-        val signature = signSigFile(keySet, sigBytes)
-        zip.writeFile("META-INF/CERT.RSA", signature)
-
-        zip.close()
+        return ks
     }
-
-    private fun hashEntrySection(name: String, attrs: Attributes, dig: MessageDigest): String {
-        val manifest = Manifest()
-        manifest.mainAttributes[Attributes.Name.MANIFEST_VERSION] = "1.0"
-        ByteArrayOutputStream().use { baos ->
-            manifest.write(baos)
-            val emptyLen = baos.toByteArray().size
-            manifest.entries[name] = attrs
-            baos.reset()
-            manifest.write(baos)
-            var ob = baos.toByteArray()
-            ob = Arrays.copyOfRange(ob, emptyLen, ob.size)
-            return toBase64(dig.digest(ob))
-        }
-    }
-
-    private fun getManifestHash(manifest: Manifest, dig: MessageDigest): String {
-        ByteArrayOutputStream().use { baos ->
-            manifest.write(baos)
-            return toBase64(dig.digest(baos.toByteArray()))
-        }
-    }
-
-    private fun signSigFile(keySet: KeySet, content: ByteArray): ByteArray {
-        val msg: CMSTypedData = CMSProcessableByteArray(content)
-        val certs = JcaCertStore(Collections.singletonList(keySet.publicKey))
-        val gen = CMSSignedDataGenerator()
-        val jcaContentSignerBuilder = JcaContentSignerBuilder("SHA1withRSA")
-        val sha1Signer: ContentSigner = jcaContentSignerBuilder.build(keySet.privateKey)
-        val jcaDigestCalculatorProviderBuilder = JcaDigestCalculatorProviderBuilder()
-        val digestCalculatorProvider: DigestCalculatorProvider = jcaDigestCalculatorProviderBuilder.build()
-        val jcaSignerInfoGeneratorBuilder = JcaSignerInfoGeneratorBuilder(digestCalculatorProvider)
-        jcaSignerInfoGeneratorBuilder.setDirectSignature(true)
-        val signerInfoGenerator: SignerInfoGenerator = jcaSignerInfoGeneratorBuilder.build(sha1Signer, keySet.publicKey)
-        gen.addSignerInfoGenerator(signerInfoGenerator)
-        gen.addCertificates(certs)
-        val sigData: CMSSignedData = gen.generate(msg, false)
-        return sigData.toASN1Structure().getEncoded("DER")
-    }
-
-    private fun toBase64(data: ByteArray): String {
-        return String(Base64.encode(data))
-    }
-}
-
-private val java.nio.file.FileSystem.allEntries: List<Path>
-    get() = buildList {
-        this@allEntries.rootDirectories.forEach { dir ->
-            Files.walk(dir).filter(Files::isRegularFile).forEach { file ->
-                this@buildList.add(file)
-            }
-        }
-    }
-
-private fun java.nio.file.FileSystem.writeFile(path: String, bytes: ByteArray) {
-    Files.write(this.getPath("/$path"), bytes)
 }

src/main/kotlin/app/revanced/utils/signing/align/ZipAligner.kt

@@ -0,0 +1,63 @@
+package app.revanced.utils.signing.align
+
+import app.revanced.utils.signing.align.stream.MultiOutputStream
+import app.revanced.utils.signing.align.stream.PeekingFakeStream
+import java.io.BufferedOutputStream
+import java.io.File
+import java.util.*
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import java.util.zip.ZipOutputStream
+
+internal object ZipAligner {
+    fun align(input: File, output: File, alignment: Int = 4) {
+        val zipFile = ZipFile(input)
+
+        val entries: Enumeration<out ZipEntry?> = zipFile.entries()
+
+        // fake
+        val peekingFakeStream = PeekingFakeStream()
+        val fakeOutputStream = ZipOutputStream(peekingFakeStream)
+        // real
+        val zipOutputStream = ZipOutputStream(BufferedOutputStream(output.outputStream()))
+
+        val multiOutputStream = MultiOutputStream(
+            listOf(
+                fakeOutputStream, // fake, used to add the data to the fake stream
+                zipOutputStream // real
+            )
+        )
+
+        var bias = 0
+        while (entries.hasMoreElements()) {
+            var padding = 0
+
+            val entry: ZipEntry = entries.nextElement()!!
+            // fake, used to calculate the file offset of the entry
+            fakeOutputStream.putNextEntry(entry)
+
+            if (entry.size == entry.compressedSize) {
+                val fileOffset = peekingFakeStream.peek()
+                val newOffset = fileOffset + bias
+                padding = ((alignment - (newOffset % alignment)) % alignment).toInt()
+
+                // real
+                entry.extra = if (entry.extra == null) ByteArray(padding)
+                else Arrays.copyOf(entry.extra, entry.extra.size + padding)
+            }
+
+            zipOutputStream.putNextEntry(entry)
+            zipFile.getInputStream(entry).copyTo(multiOutputStream)
+
+            // fake, used to add remaining bytes
+            fakeOutputStream.closeEntry()
+            // real
+            zipOutputStream.closeEntry()
+
+            bias += padding
+        }
+
+        zipFile.close()
+        zipOutputStream.close()
+    }
+}

src/main/kotlin/app/revanced/utils/signing/align/stream/MultiOutputStream.kt

@@ -0,0 +1,20 @@
+package app.revanced.utils.signing.align.stream
+
+import java.io.OutputStream
+
+internal class MultiOutputStream(
+    private val streams: Iterable<OutputStream>,
+) : OutputStream() {
+    override fun write(b: ByteArray, off: Int, len: Int) = streams.forEach {
+        it.write(b, off, len)
+    }
+
+    override fun write(b: ByteArray) = streams.forEach {
+        it.write(b)
+    }
+
+    override fun write(b: Int) = streams.forEach {
+        it.write(b)
+    }
+
+}

src/main/kotlin/app/revanced/utils/signing/align/stream/PeekingFakeStream.kt

@@ -0,0 +1,21 @@
+package app.revanced.utils.signing.align.stream
+
+import java.io.OutputStream
+
+internal class PeekingFakeStream : OutputStream() {
+    private var numberOfBytes: Long = 0
+
+    fun peek() = numberOfBytes
+
+    override fun write(b: Int) {
+        numberOfBytes++
+    }
+
+    override fun write(b: ByteArray) {
+        numberOfBytes += b.size
+    }
+
+    override fun write(b: ByteArray, offset: Int, len: Int) {
+        numberOfBytes += len
+    }
+}