chore(release): 5.0.0-dev.1 [skip ci]

# [5.0.0-dev.1](https://github.com/ReVanced/revanced-cli/compare/v4.6.0...v5.0.0-dev.1) (2024-08-12)

### Features

* Set patch options via CLI ([#336](https://github.com/ReVanced/revanced-cli/issues/336)) ([2300243](23002434b2))

### BREAKING CHANGES

* This commit changes various CLI options and removes the `options.json` file. Instead, patch options can now be passed via CLI options

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -70,7 +70,7 @@ body:
 
         Before creating a new bug report, please keep the following in mind:
 
-        - **Do not submit a duplicate bug report**: You can review existing bug reports [here](https://github.com/ReVanced/revanced-cli/labels/Bug%20report).
+        - **Do not submit a duplicate bug report**: Search for existing bug reports [here](https://github.com/ReVanced/revanced-cli/issues?q=label%3A%22Bug+report%22).
         - **Review the contribution guidelines**: Make sure your bug report adheres to it. You can find the guidelines [here](https://github.com/ReVanced/revanced-cli/blob/main/CONTRIBUTING.md).
         - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
   - type: textarea
@@ -102,7 +102,7 @@ body:
       label: Acknowledgements
       description: Your bug report will be closed if you don't follow the checklist below.
       options:
-        - label: This issue is not a duplicate of an existing bug report.
+        - label: I have checked all open and closed bug reports and this is not a duplicate.
           required: true
         - label: I have chosen an appropriate title.
           required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -70,8 +70,8 @@ body:
 
         Before creating a new feature request, please keep the following in mind:
 
-        - **Do not submit a duplicate feature request**: You can review existing feature requests [here](https://github.com/ReVanced/revanced-cli//labels/Feature%20request).
+        - **Do not submit a duplicate feature request**: Search for existing feature requests [here](https://github.com/ReVanced/revanced-cli/issues?q=label%3A%22Feature+request%22).
-        - **Review the contribution guidelines**: Make sure your bug report adheres to it. You can find the guidelines [here](https://github.com/ReVanced/revanced-cli//blob/main/CONTRIBUTING.md).
+        - **Review the contribution guidelines**: Make sure your feature request adheres to it. You can find the guidelines [here](https://github.com/ReVanced/revanced-cli//blob/main/CONTRIBUTING.md).
         - **Do not use the issue page for support**: If you need help or have questions, check out other platforms on [revanced.app](https://revanced.app).
   - type: textarea
     attributes:
@@ -98,7 +98,7 @@ body:
       label: Acknowledgements
       description: Your feature request will be closed if you don't follow the checklist below.
       options:
-        - label: This issue is not a duplicate of an existing feature request.
+        - label: I have checked all open and closed feature requests and this is not a duplicate.
           required: true
         - label: I have chosen an appropriate title.
           required: true

.github/workflows/release.yml

@@ -42,7 +42,7 @@ jobs:
         with:
           gpg_private_key: ${{ secrets.GPG_PRIVATE_KEY }}
           passphrase: ${{ secrets.GPG_PASSPHRASE }}
-          fingerprint: ${{ env.GPG_FINGERPRINT }}
+          fingerprint: ${{ vars.GPG_FINGERPRINT }}
 
       - name: Release
         env:

.gitignore

@@ -121,5 +121,5 @@ node_modules/
 revanced-cache/
 options.toml
 
-# Generated by an Android project (such as ReVanced Integrations)
+# Generated by Android projects
 local.properties

CHANGELOG.md

@@ -1,3 +1,86 @@
+# [5.0.0-dev.1](https://github.com/ReVanced/revanced-cli/compare/v4.6.0...v5.0.0-dev.1) (2024-08-12)
+
+
+### Features
+
+* Set patch options via CLI ([#336](https://github.com/ReVanced/revanced-cli/issues/336)) ([2300243](https://github.com/ReVanced/revanced-cli/commit/23002434b2d51c2a3b30b33dd0526261432d90ce))
+
+
+### BREAKING CHANGES
+
+* This commit changes various CLI options and removes the `options.json` file. Instead, patch options can now be passed via CLI options
+
+# [4.6.0](https://github.com/ReVanced/revanced-cli/compare/v4.5.0...v4.6.0) (2024-04-01)
+
+
+### Bug Fixes
+
+* Copy APK to output path when it is not being signed ([366f400](https://github.com/ReVanced/revanced-cli/commit/366f400c5a46491f3f262c7ff4b0df1ae3721f74))
+* Use correct option description ([45a2ffa](https://github.com/ReVanced/revanced-cli/commit/45a2ffa2dd95ee8ac3c4d466463c9a5b869b8da1))
+
+
+### Features
+
+* Use more consistent option name ([223629c](https://github.com/ReVanced/revanced-cli/commit/223629c663dcd94d237110e09e4e152aa03867f9))
+
+# [4.6.0-dev.1](https://github.com/ReVanced/revanced-cli/compare/v4.5.1-dev.1...v4.6.0-dev.1) (2024-03-14)
+
+
+### Bug Fixes
+
+* Use correct option description ([45a2ffa](https://github.com/ReVanced/revanced-cli/commit/45a2ffa2dd95ee8ac3c4d466463c9a5b869b8da1))
+
+
+### Features
+
+* Use more consistent option name ([223629c](https://github.com/ReVanced/revanced-cli/commit/223629c663dcd94d237110e09e4e152aa03867f9))
+
+## [4.5.1-dev.1](https://github.com/ReVanced/revanced-cli/compare/v4.5.0...v4.5.1-dev.1) (2024-03-12)
+
+
+### Bug Fixes
+
+* Copy APK to output path when it is not being signed ([366f400](https://github.com/ReVanced/revanced-cli/commit/366f400c5a46491f3f262c7ff4b0df1ae3721f74))
+
+# [4.5.0](https://github.com/ReVanced/revanced-cli/compare/v4.4.2...v4.5.0) (2024-03-11)
+
+
+### Bug Fixes
+
+* Show path for missing files instead of just the name ([f0f3e56](https://github.com/ReVanced/revanced-cli/commit/f0f3e5614b99b34391e0492177706f9c09781cad))
+* Sign APKs correctly ([5ff105c](https://github.com/ReVanced/revanced-cli/commit/5ff105cf6b3fac9cd12478efd10caf90d1ecf589))
+
+
+### Features
+
+* Remove deprecated CLI options ([48a1a39](https://github.com/ReVanced/revanced-cli/commit/48a1a39b94dd9121c400d28e3e93dec3fc13e3be))
+
+# [4.5.0-dev.1](https://github.com/ReVanced/revanced-cli/compare/v4.4.2...v4.5.0-dev.1) (2024-03-11)
+
+
+### Bug Fixes
+
+* Show path for missing files instead of just the name ([f0f3e56](https://github.com/ReVanced/revanced-cli/commit/f0f3e5614b99b34391e0492177706f9c09781cad))
+* Sign APKs correctly ([5ff105c](https://github.com/ReVanced/revanced-cli/commit/5ff105cf6b3fac9cd12478efd10caf90d1ecf589))
+
+
+### Features
+
+* Remove deprecated CLI options ([48a1a39](https://github.com/ReVanced/revanced-cli/commit/48a1a39b94dd9121c400d28e3e93dec3fc13e3be))
+
+## [4.4.2](https://github.com/ReVanced/revanced-cli/compare/v4.4.1...v4.4.2) (2024-03-10)
+
+## [4.4.2-dev.2](https://github.com/ReVanced/revanced-cli/compare/v4.4.2-dev.1...v4.4.2-dev.2) (2024-03-10)
+
+## [4.4.2-dev.1](https://github.com/ReVanced/revanced-cli/compare/v4.4.1...v4.4.2-dev.1) (2024-03-09)
+
+## [4.4.1](https://github.com/ReVanced/revanced-cli/compare/v4.4.0...v4.4.1) (2024-03-06)
+
+
+### Bug Fixes
+
+* Bump dependencies to support BCS keystore ([1c10a77](https://github.com/ReVanced/revanced-cli/commit/1c10a7760d76ea850260ca49b448be7ad121de44))
+
 ## [4.4.1-dev.2](https://github.com/ReVanced/revanced-cli/compare/v4.4.1-dev.1...v4.4.1-dev.2) (2024-03-04)
 
 

build.gradle.kts

@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
 plugins {
     alias(libs.plugins.kotlin)
     alias(libs.plugins.shadow)
@@ -14,10 +16,9 @@ application {
 
 repositories {
     mavenCentral()
-    mavenLocal()
     google()
     maven {
-        // A repository must be speficied for some reason. "registry" is a dummy.
+        // A repository must be specified for some reason. "registry" is a dummy.
         url = uri("https://maven.pkg.github.com/revanced/registry")
         credentials {
             username = project.findProperty("gpr.user") as String? ?: System.getenv("GITHUB_ACTOR")
@@ -35,7 +36,15 @@ dependencies {
     testImplementation(libs.kotlin.test)
 }
 
-kotlin { jvmToolchain(11) }
+kotlin {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_11)
+    }
+}
+
+java {
+    targetCompatibility = JavaVersion.VERSION_11
+}
 
 tasks {
     test {

docs/1_usage.md

@@ -1,129 +1,171 @@
 # 🛠️ Using ReVanced CLI
 
 Learn how to use ReVanced CLI.
+The following examples will show you how to perform basic operations.
+You can list patches, patch an app, uninstall, and install an app.
 
-## 🔨 Usage
+## 🚀 Show all commands
 
-ReVanced CLI is divided into the following fundamental commands:
+```bash
+java -jar revanced-cli.jar -h
+```
 
-- ### 🚀 Show all available options for ReVanced CLI
+## 📃 List patches
 
-  ```bash
+```bash
-  java -jar revanced-cli.jar -h
+java -jar revanced-cli.jar list-patches --with-packages --with-versions --with-options revanced-patches.rvp
-  ```
+```
 
-- ### 📃 List patches
+## 💉 Patch an app
 
-  ```bash
+To patch an app using the default list of patches, use the `patch` command:
-  java -jar revanced-cli.jar list-patches \
-   --with-packages \
-   --with-versions \
-   --with-options \
-   revanced-patches.jar [<patch-bundle> ...]
-  ```
 
-- ### ⚙️ Generate options
+```bash
+java -jar revanced-cli.jar patch -b revanced-patches.rvp input.apk
+```
 
-  This will generate an `options.json` file for the patches from a list of supplied patch bundles.
+You can also use multiple patch bundles:
-  The file can be supplied to ReVanced CLI later on.
 
-  ```bash
+```bash
-  java -jar revanced-cli.jar options \
+java -jar revanced-cli.jar patch -b revanced-patches.rvp -b another-patches.rvp input.apk
-   --path options.json \
+```
-   --overwrite \
-   revanced-patches.jar [<patch-bundle> ...]
-  ```
 
-  > **ℹ️ Note**  
+To change the default set of used patches, use the option `-i` or `-e` to use or disuse specific patches.
-  > A default `options.json` file will be automatically created if it does not exist
+You can use the `list-patches` command to see which patches are used by default.
-  > without any need for intervention when using the `patch` command.
 
-- ### 💉 Patch an app
+To only use specific patches, you can use the option `--exclusive` combined with `-i`.
+Remember that the options `-i` and `-e` match the patch's name exactly. Here is an example:
 
-  You can patch apps by supplying patch bundles and the app to patch.
+```bash
-  After patching, ReVanced CLI can install the patched app on your device using two methods:
+java -jar revanced-cli.jar patch -b revanced-patches.rvp --exclusive -i "Patch name" -i "Another patch name" input.apk
+```
 
-  > **💡 Tip**  
+You can also use the options `--ii` and `--ie` to use or disuse patches by their index.
-  > For ReVanced CLI to be able to install the patched app on your device, make sure ADB is working:
+This is useful, if two patches happen to have the same name.
-  >
+To know the indices of patches, use the command `list-patches`:
-  > ```bash
-  > adb shell exit
-  > ```
-  >
-  > If you want to mount the patched app on top of the un-patched app, make sure you have root permissions:
-  >
-  > ```bash
-  > adb shell su -c exit
-  > ```
 
-  > **⚠️ Warning**  
+```bash
-  > Some patches may require integrations
+java -jar revanced-cli.jar list-patches revanced-patches.rvp
-  > such as [ReVanced Integrations](https://github.com/revanced/revanced-integrations).
+```
-  > Supply them with the option `--merge`. ReVanced Patcher will automatically determine if they are necessary.
 
-  - #### 👾 Patch an app and install it on your device regularly
+Then you can use the indices to use or disuse patches:
 
-    ```bash
+```bash
-    java -jar revanced-cli.jar patch \
+java -jar revanced-cli.jar patch -b revanced-patches.rvp --ii 123 --ie 456 input.apk
-     --patch-bundle revanced-patches.jar \
+```
-     -d \
-     input.apk
-    ```
 
-  - #### 👾 Patch an app and mount it on top of the un-patched app with root permissions
+You can combine the option `-i`, `-e`, `--ii`, `--ie` and `--exclusive`. Here is an example:
 
-    > **❗ Caution**  
+```bash
-    > Ensure that the same app you are patching and mounting over is installed on your device:
+java -jar revanced-cli.jar patch -b revanced-patches.rvp --exclusive -i "Patch name" --ii 123 input.apk
-    >
+```
-    > ```bash
-    > adb install app.apk
-    > ```
 
-    ```bash
-    java -jar revanced-cli.jar patch \
-     --patch-bundle revanced-patches.jar \
-     --include "Some patch" \
-     --ii 123 \
-     --exclude "Some other patch" \
-     -d \
-     --mount \
-     app.apk
-    ```
 
-    > **💡 Tip**  
+> [!TIP]
-    > You can use the option `--ii` to include or `--ie` to exclude
+> You can use the option `-d` to automatically install the patched app after patching.
-    > patches by their index in relation to supplied patch bundles,
+> Make sure ADB is working:
-    > similarly to the option `--include` and `--exclude`.
+>
-    >
+> ```bash
-    > This is useful in case two patches have the same name, and you must include or exclude one.  
+>  adb shell exit
-    > The patch index is calculated by the position of the patch in the list of patches
+> ```
-    > from patch bundles supplied using the option `--patch-bundle`.
-    >
-    > You can list all patches with their indices using the command `list-patches`.
-    >
-    > Keep in mind that the indices can change based on the order of the patch bundles supplied,
-    > as well if the patch bundles are updated because patches can be added or removed.
 
-- ### 🗑️ Uninstall an app
 
-  ```bash
+> [!TIP]
-  java -jar revanced-cli.jar utility uninstall \
+> You can use the option `--mount` to mount the patched app on top of the un-patched app.
-   --package-name <package-name> \
+> Make sure you have root permissions and the same app you are patching and mounting over is installed on your device:
-   [<device-serial>]
+>
-  ```
+> ```bash
+> adb shell su -c exit
+> adb install input.apk
+> ```
 
-  > **💡 Tip**  
+Patches can have options you can set using the option `-O` alongside the option to include the patch by name or index.
-  > You can unmount an APK file
+To know the options of a patch, use the option `--with-options` when listing patches:
-  > by adding the option `--unmount`.
 
-- ### ️ 📦 Install an app
+```bash
+java -jar revanced-cli.jar list-patches --with-options revanced-patches.rvp
+```
 
-  ```bash
+Each patch can have multiple options. You can set them using the option `-O`.
-  java -jar revanced-cli.jar utility install \
+For example, to set the options for the patch with the name `Patch name`
-   -a input.apk \
+with the key `key1` and `key2` to `value1` and `value2` respectively, use the following command:
-   [<device-serial>]
-  ```
 
-  > **💡 Tip**  
+```bash
-  > You can mount an APK file
+java -jar revanced-cli.jar patch -b revanced-patches.rvp -i "Patch name" -Okey1=value1 -Okey2=value2 input.apk
-  > by supplying the app's package name to mount the supplied APK file over the option `-mount`.
+```
+
+If you want to set a value to `null`, you can omit the value:
+
+```bash
+java -jar revanced-cli.jar patch -b revanced-patches.rvp -i "Patch name" -Okey1 input.apk
+```
+
+> [!WARNING]
+> Option values are usually typed. If you set a value with the wrong type, the patch can fail.
+> Option value types can be seen when listing patches with the option `--with-options`.
+> 
+> Example option values:
+>
+> - String: `string`
+> - Boolean: `true`, `false`
+> - Integer: `123`
+> - Double: `1.0`
+> - Float: `1.0f`
+> - Long: `1234567890`, `1L`
+> - List: `[item1,item2,item3]`
+> - List of type `Any`: `[item1,123,true,1.0]`
+> - Empty list of type `Any`: `[]`
+> - Typed empty list: `int[]`
+> - Typed and nested empty list: `[int[]]`
+> - List with null value and two empty strings: `[null,\'\',\"\"]`
+>
+> Quotes and commas escaped in strings (`\"`, `\'`, `\,`) are parsed as part of the string.
+> List items are recursively parsed, so you can escape values in lists:
+> 
+> - Escaped integer as a string: `[\'123\']`
+> - Escaped boolean as a string: `[\'true\']`
+> - Escaped list as a string: `[\'[item1,item2]\']`
+> - Escaped null value as a string: `[\'null\']`
+> - List with an integer, an integer as a string and a string with a comma, and an escaped list: [`123,\'123\',str\,ing`,`\'[]\'`]
+> 
+> Example command with an escaped integer as a string:
+> 
+> ```bash
+> java -jar revanced-cli.jar -b revanced-patches.rvp -i "Patch name" -OstringKey=\'1\' input.apk
+> ```
+## 📦 Install an app manually 
+
+```bash
+java -jar revanced-cli.jar utility install -a input.apk
+```
+
+> [!TIP]
+> You can use the option `--mount` to mount the patched app on top of the un-patched app.
+> Make sure you have root permissions and the same app you are patching and mounting over is installed on your device:
+>
+> ```bash
+> adb shell su -c exit
+> adb install input.apk
+> ```
+
+## 🗑️ Uninstall an app manually
+
+Here `<package-name>` is the package name of the app you want to uninstall:
+
+```bash
+java -jar revanced-cli.jar utility uninstall --package-name <package-name>
+```
+
+If the app is mounted, you need to unmount it by using the option `--unmount`:
+
+```bash
+java -jar revanced-cli.jar utility uninstall --package-name <package-name> --unmount
+```
+
+> [!TIP]
+> By default, the app is installed or uninstalled to the first connected device.
+> You can append one or more devices by their serial to install or uninstall an app on your selected choice of devices:
+>
+> ```bash
+> java -jar revanced-cli.jar utility uninstall --package-name <package-name> [<device-serial> ...]
+> ```

docs/2_building.md

@@ -23,4 +23,15 @@ To build ReVanced CLI, follow these steps:
     ./gradlew build
    ```
 
+> [!NOTE]
+> If the build fails due to authentication, you may need to authenticate to GitHub Packages.
+> Create a PAT with the scope `read:packages` [here](https://github.com/settings/tokens/new?scopes=read:packages&description=ReVanced) and add your token to ~/.gradle/gradle.properties.
+>
+> Example `gradle.properties` file:
+>
+> ```properties
+> gpr.user = user
+> gpr.key = key
+> ```
+
 After the build succeeds, the built JAR file will be located at `build/libs/revanced-cli-<version>-all.jar`.

gradle.properties

@@ -1,4 +1,4 @@
 org.gradle.parallel = true
 org.gradle.caching = true
 kotlin.code.style = official
-version = 4.4.1-dev.2
+version = 5.0.0-dev.1

gradle/libs.versions.toml

@@ -1,18 +1,18 @@
 [versions]
 shadow = "8.1.1"
-kotlin = "1.9.22"
+kotlin = "2.0.0"
-kotlinx-coroutines-core = "1.7.3"
+kotlinx = "1.8.1"
-picocli = "4.7.5"
+picocli = "4.7.6"
-revanced-patcher = "19.3.1"
+revanced-patcher = "20.0.0"
-revanced-library = "2.1.0"
+revanced-library = "3.0.0"
 
 [libraries]
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }
-kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines-core" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx" }
 picocli = { module = "info.picocli:picocli", version.ref = "picocli" }
 revanced-patcher = { module = "app.revanced:revanced-patcher", version.ref = "revanced-patcher" }
-revanced-library = { module = "app.revanced:revanced-library", version.ref = "revanced-library" }
+revanced-library = { module = "app.revanced:revanced-library-jvm", version.ref = "revanced-library" }
 
 [plugins]
 shadow = { id = "com.github.johnrengelman.shadow", version.ref = "shadow" }
-kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,8 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
+distributionSha256Sum=d725d707bfabd4dfdc958c624003b3c80accc03f7037b5122c4b1d0ef15cecab
-distributionSha256Sum=9631d53cf3e74bfa726893aee1f8994fee4e060c401335946dba2156f440f24c
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dist
+zipStorePath=wrapper/dists

gradlew

@@ -83,7 +83,8 @@ done
 # This is normally unused
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -144,7 +145,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
         # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
@@ -152,7 +153,7 @@ if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
       '' | soft) :;; #(
       *)
         # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -201,11 +202,11 @@ fi
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
-# Collect all arguments for the java command;
+# Collect all arguments for the java command:
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     shell script including quotes and variable substitutions, so put them in
+#     and any embedded shellness will be escaped.
-#     double quotes to make sure that they get re-expanded; and
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#   * put everything else in single quotes, so that it's not re-expanded.
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \

gradlew.bat

@@ -43,11 +43,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,11 +57,11 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
+echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo.
+echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation.
+echo location of your Java installation. 1>&2
 
 goto fail
 

package.json

@@ -4,6 +4,6 @@
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "gradle-semantic-release-plugin": "^1.9.1",
-    "semantic-release": "^23.0.2"
+    "semantic-release": "^23.0.8"
   }
 }

settings.gradle.kts

@@ -1,7 +1 @@
 rootProject.name = "revanced-cli"
-
-buildCache {
-    local {
-        isEnabled = "CI" !in System.getenv()
-    }
-}

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

@@ -0,0 +1,105 @@
+package app.revanced.cli.command
+
+import picocli.CommandLine
+
+class OptionKeyConverter : CommandLine.ITypeConverter<String> {
+    override fun convert(value: String): String = value
+}
+
+class OptionValueConverter : CommandLine.ITypeConverter<Any?> {
+    override fun convert(value: String?): Any? {
+        value ?: return null
+
+        return when {
+            value.startsWith("[") && value.endsWith("]") -> {
+                val innerValue = value.substring(1, value.length - 1)
+
+                buildList {
+                    var nestLevel = 0
+                    var insideQuote = false
+                    var escaped = false
+
+                    val item = buildString {
+                        for (char in innerValue) {
+                            when (char) {
+                                '\\' -> {
+                                    if (escaped || nestLevel != 0) {
+                                        append(char)
+                                    }
+
+                                    escaped = !escaped
+                                }
+
+                                '"', '\'' -> {
+                                    if (!escaped) {
+                                        insideQuote = !insideQuote
+                                    } else {
+                                        escaped = false
+                                    }
+
+                                    append(char)
+                                }
+
+                                '[' -> {
+                                    if (!insideQuote) {
+                                        nestLevel++
+                                    }
+
+                                    append(char)
+                                }
+
+                                ']' -> {
+                                    if (!insideQuote) {
+                                        nestLevel--
+
+                                        if (nestLevel == -1) {
+                                            return value
+                                        }
+                                    }
+
+                                    append(char)
+                                }
+
+                                ',' -> if (nestLevel == 0) {
+                                    if (insideQuote) {
+                                        append(char)
+                                    } else {
+                                        add(convert(toString()))
+                                        setLength(0)
+                                    }
+                                } else {
+                                    append(char)
+                                }
+
+                                else -> append(char)
+                            }
+                        }
+                    }
+
+                    if (item.isNotEmpty()) {
+                        add(convert(item))
+                    }
+                }
+            }
+
+            value.startsWith("\"") && value.endsWith("\"") -> value.substring(1, value.length - 1)
+            value.startsWith("'") && value.endsWith("'") -> value.substring(1, value.length - 1)
+            value.endsWith("f") -> value.dropLast(1).toFloat()
+            value.endsWith("L") -> value.dropLast(1).toLong()
+            value.equals("true", ignoreCase = true) -> true
+            value.equals("false", ignoreCase = true) -> false
+            value.toIntOrNull() != null -> value.toInt()
+            value.toLongOrNull() != null -> value.toLong()
+            value.toDoubleOrNull() != null -> value.toDouble()
+            value.toFloatOrNull() != null -> value.toFloat()
+            value == "null" -> null
+            value == "int[]" -> emptyList<Int>()
+            value == "long[]" -> emptyList<Long>()
+            value == "double[]" -> emptyList<Double>()
+            value == "float[]" -> emptyList<Float>()
+            value == "boolean[]" -> emptyList<Boolean>()
+            value == "string[]" -> emptyList<String>()
+            else -> value
+        }
+    }
+}

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

@@ -1,9 +1,9 @@
 package app.revanced.cli.command
 
 import app.revanced.library.PackageName
-import app.revanced.library.PatchUtils
 import app.revanced.library.VersionMap
-import app.revanced.patcher.PatchBundleLoader
+import app.revanced.library.mostCommonCompatibleVersions
+import app.revanced.patcher.patch.loadPatchesFromJar
 import picocli.CommandLine
 import java.io.File
 import java.util.logging.Logger
@@ -16,13 +16,13 @@ import java.util.logging.Logger
     ],
 )
 internal class ListCompatibleVersions : Runnable {
-    private val logger = Logger.getLogger(ListCompatibleVersions::class.java.name)
+    private val logger = Logger.getLogger(this::class.java.name)
 
     @CommandLine.Parameters(
         description = ["Paths to patch bundles."],
         arity = "1..*",
     )
-    private lateinit var patchBundles: Array<File>
+    private lateinit var patchBundles: Set<File>
 
     @CommandLine.Option(
         names = ["-f", "--filter-package-names"],
@@ -38,8 +38,6 @@ internal class ListCompatibleVersions : Runnable {
     private var countUnusedPatches: Boolean = false
 
     override fun run() {
-        val patches = PatchBundleLoader.Jar(*patchBundles)
-
         fun VersionMap.buildVersionsString(): String {
             if (isEmpty()) return "Any"
 
@@ -58,8 +56,9 @@ internal class ListCompatibleVersions : Runnable {
                 appendLine(versions.buildVersionsString().prependIndent("\t"))
             }
 
-        PatchUtils.getMostCommonCompatibleVersions(
+        val patches = loadPatchesFromJar(patchBundles)
-            patches,
+
+        patches.mostCommonCompatibleVersions(
             packageNames,
             countUnusedPatches,
         ).entries.joinToString("\n", transform = ::buildString).let(logger::info)

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

@@ -1,25 +1,26 @@
 package app.revanced.cli.command
 
-import app.revanced.patcher.PatchBundleLoader
+import app.revanced.patcher.patch.Package
 import app.revanced.patcher.patch.Patch
-import app.revanced.patcher.patch.options.PatchOption
+import app.revanced.patcher.patch.loadPatchesFromJar
 import picocli.CommandLine.*
 import picocli.CommandLine.Help.Visibility.ALWAYS
 import java.io.File
 import java.util.logging.Logger
+import app.revanced.patcher.patch.Option as PatchOption
 
 @Command(
     name = "list-patches",
     description = ["List patches from supplied patch bundles."],
 )
 internal object ListPatchesCommand : Runnable {
-    private val logger = Logger.getLogger(ListPatchesCommand::class.java.name)
+    private val logger = Logger.getLogger(this::class.java.name)
 
     @Parameters(
         description = ["Paths to patch bundles."],
         arity = "1..*",
     )
-    private lateinit var patchBundles: Array<File>
+    private lateinit var patchBundles: Set<File>
 
     @Option(
         names = ["-d", "--with-descriptions"],
@@ -70,16 +71,19 @@ internal object ListPatchesCommand : Runnable {
     private var packageName: String? = null
 
     override fun run() {
-        fun Patch.CompatiblePackage.buildString() =
+        fun Package.buildString(): String {
-            buildString {
+            val (name, versions) = this
+
+            return buildString {
                 if (withVersions && versions != null) {
                     appendLine("Package name: $name")
                     appendLine("Compatible versions:")
-                    append(versions!!.joinToString("\n") { version -> version }.prependIndent("\t"))
+                    append(versions.joinToString("\n") { version -> version }.prependIndent("\t"))
                 } else {
                     append("Package name: $name")
                 }
             }
+        }
 
         fun PatchOption<*>.buildString() =
             buildString {
@@ -91,9 +95,11 @@ internal object ListPatchesCommand : Runnable {
                 } ?: append("Key: $key")
 
                 values?.let { values ->
-                    appendLine("\nValid values:")
+                    appendLine("\nPossible values:")
                     append(values.map { "${it.value} (${it.key})" }.joinToString("\n").prependIndent("\t"))
                 }
+
+                append("\nType: $type")
             }
 
         fun IndexedValue<Patch<*>>.buildString() =
@@ -126,10 +132,10 @@ internal object ListPatchesCommand : Runnable {
             }
 
         fun Patch<*>.filterCompatiblePackages(name: String) =
-            compatiblePackages?.any { it.name == name }
+            compatiblePackages?.any { (compatiblePackageName, _) -> compatiblePackageName == name }
                 ?: withUniversalPatches
 
-        val patches = PatchBundleLoader.Jar(*patchBundles).withIndex().toList()
+        val patches = loadPatchesFromJar(patchBundles).withIndex().toList()
 
         val filtered =
             packageName?.let { patches.filter { (_, patch) -> patch.filterCompatiblePackages(it) } } ?: patches

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

@@ -34,7 +34,6 @@ private object CLIVersionProvider : IVersionProvider {
     versionProvider = CLIVersionProvider::class,
     subcommands = [
         PatchCommand::class,
-        OptionsCommand::class,
         ListPatchesCommand::class,
         ListCompatibleVersions::class,
         UtilityCommand::class,

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

@@ -1,62 +0,0 @@
-package app.revanced.cli.command
-
-import app.revanced.library.Options
-import app.revanced.library.Options.setOptions
-import app.revanced.patcher.PatchBundleLoader
-import picocli.CommandLine
-import picocli.CommandLine.Help.Visibility.ALWAYS
-import java.io.File
-import java.util.logging.Logger
-
-@CommandLine.Command(
-    name = "options",
-    description = ["Generate options file from patches."],
-)
-internal object OptionsCommand : Runnable {
-    private val logger = Logger.getLogger(OptionsCommand::class.java.name)
-
-    @CommandLine.Parameters(
-        description = ["Paths to patch bundles."],
-        arity = "1..*",
-    )
-    private lateinit var patchBundles: Array<File>
-
-    @CommandLine.Option(
-        names = ["-p", "--path"],
-        description = ["Path to patch options JSON file."],
-        showDefaultValue = ALWAYS,
-    )
-    private var filePath: File = File("options.json")
-
-    @CommandLine.Option(
-        names = ["-o", "--overwrite"],
-        description = ["Overwrite existing options file."],
-        showDefaultValue = ALWAYS,
-    )
-    private var overwrite: Boolean = false
-
-    @CommandLine.Option(
-        names = ["-u", "--update"],
-        description = ["Update existing options by adding missing and removing non-existent options."],
-        showDefaultValue = ALWAYS,
-    )
-    private var update: Boolean = false
-
-    override fun run() =
-        try {
-            PatchBundleLoader.Jar(*patchBundles).let { patches ->
-                val exists = filePath.exists()
-                if (!exists || overwrite) {
-                    if (exists && update) patches.setOptions(filePath)
-
-                    Options.serialize(patches, prettyPrint = true).let(filePath::writeText)
-                } else {
-                    throw OptionsFileAlreadyExistsException()
-                }
-            }
-        } catch (ex: OptionsFileAlreadyExistsException) {
-            logger.severe("Options file already exists, use --overwrite to override it")
-        }
-
-    class OptionsFileAlreadyExistsException : Exception()
-}

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

@@ -2,16 +2,15 @@ package app.revanced.cli.command
 
 import app.revanced.library.ApkUtils
 import app.revanced.library.ApkUtils.applyTo
-import app.revanced.library.ApkUtils.sign
+import app.revanced.library.installation.installer.*
-import app.revanced.library.Options
+import app.revanced.library.setOptions
-import app.revanced.library.Options.setOptions
-import app.revanced.library.adb.AdbManager
-import app.revanced.patcher.PatchBundleLoader
-import app.revanced.patcher.PatchSet
 import app.revanced.patcher.Patcher
 import app.revanced.patcher.PatcherConfig
+import app.revanced.patcher.patch.Patch
+import app.revanced.patcher.patch.loadPatchesFromJar
 import kotlinx.coroutines.runBlocking
 import picocli.CommandLine
+import picocli.CommandLine.ArgGroup
 import picocli.CommandLine.Help.Visibility.ALWAYS
 import picocli.CommandLine.Model.CommandSpec
 import picocli.CommandLine.Spec
@@ -25,46 +24,71 @@ import java.util.logging.Logger
     description = ["Patch an APK file."],
 )
 internal object PatchCommand : Runnable {
-    private val logger = Logger.getLogger(PatchCommand::class.java.name)
+    private val logger = Logger.getLogger(this::class.java.name)
 
     @Spec
-    lateinit var spec: CommandSpec // injected by picocli
+    private lateinit var spec: CommandSpec
 
-    private lateinit var apk: File
+    @ArgGroup(multiplicity = "0..*")
+    private lateinit var selection: Set<Selection>
 
-    private var integrations = setOf<File>()
+    internal class Selection {
+        @ArgGroup(exclusive = false, multiplicity = "1")
+        internal var include: IncludeSelection? = null
 
-    private var patchBundles = emptySet<File>()
+        internal class IncludeSelection {
+            @ArgGroup(multiplicity = "1")
+            internal lateinit var selector: IncludeSelector
 
-    @CommandLine.Option(
+            internal class IncludeSelector {
-        names = ["-i", "--include"],
+                @CommandLine.Option(
-        description = ["List of patches to include."],
+                    names = ["-i", "--include"],
-    )
+                    description = ["The name of the patch."],
-    private var includedPatches = hashSetOf<String>()
+                    required = true,
+                )
+                internal var name: String? = null
 
-    @CommandLine.Option(
+                @CommandLine.Option(
-        names = ["--ii"],
+                    names = ["--ii"],
-        description = ["List of patches to include by their index in relation to the supplied patch bundles."],
+                    description = ["The index of the patch in the combined list of all supplied patch bundles."],
-    )
+                    required = true,
-    private var includedPatchesByIndex = arrayOf<Int>()
+                )
+                internal var index: Int? = null
+            }
 
-    @CommandLine.Option(
+            @CommandLine.Option(
-        names = ["-e", "--exclude"],
+                names = ["-O", "--options"],
-        description = ["List of patches to exclude."],
+                description = ["The option values keyed by the option keys."],
-    )
+                mapFallbackValue = CommandLine.Option.NULL_VALUE,
-    private var excludedPatches = hashSetOf<String>()
+                converter = [OptionKeyConverter::class, OptionValueConverter::class],
+            )
+            internal var options = mutableMapOf<String, Any?>()
+        }
 
-    @CommandLine.Option(
+        @ArgGroup(exclusive = false, multiplicity = "1")
-        names = ["--ei"],
+        internal var exclude: ExcludeSelection? = null
-        description = ["List of patches to exclude by their index in relation to the supplied patch bundles."],
-    )
-    private var excludedPatchesByIndex = arrayOf<Int>()
 
-    @CommandLine.Option(
+        internal class ExcludeSelection {
-        names = ["--options"],
+            @ArgGroup(multiplicity = "1")
-        description = ["Path to patch options JSON file."],
+            internal lateinit var selector: ExcludeSelector
-    )
+
-    private var optionsFile: File? = null
+            internal class ExcludeSelector {
+                @CommandLine.Option(
+                    names = ["-e", "--exclude"],
+                    description = ["The name of the patch."],
+                    required = true,
+                )
+                internal var name: String? = null
+
+                @CommandLine.Option(
+                    names = ["--ie"],
+                    description = ["The index of the patch in the combined list of all supplied patch bundles."],
+                    required = true,
+                )
+                internal var index: Int? = null
+            }
+        }
+    }
 
     @CommandLine.Option(
         names = ["--exclusive"],
@@ -86,6 +110,7 @@ internal object PatchCommand : Runnable {
         names = ["-o", "--out"],
         description = ["Path to save the patched APK file to. Defaults to the same directory as the supplied APK file."],
     )
+    @Suppress("unused")
     private fun setOutputFilePath(outputFilePath: File?) {
         this.outputFilePath = outputFilePath?.absoluteFile
     }
@@ -115,7 +140,6 @@ internal object PatchCommand : Runnable {
     )
     private var keystoreFilePath: File? = null
 
-    // key store password
     @CommandLine.Option(
         names = ["--keystore-password"],
         description = ["The password of the keystore to sign the patched APK file with. Empty password by default."],
@@ -123,17 +147,17 @@ internal object PatchCommand : Runnable {
     private var keyStorePassword: String? = null // Empty password by default
 
     @CommandLine.Option(
-        names = ["--alias"],
+        names = ["--keystore-entry-alias"],
-        description = ["The alias of the key from the keystore to sign the patched APK file with."],
+        description = ["The alias of the keystore entry to sign the patched APK file with."],
         showDefaultValue = ALWAYS,
     )
-    private var alias = "ReVanced Key"
+    private var keyStoreEntryAlias = "ReVanced Key"
 
     @CommandLine.Option(
         names = ["--keystore-entry-password"],
         description = ["The password of the entry from the keystore for the key to sign the patched APK file with."],
     )
-    private var password = "" // Empty password by default
+    private var keyStoreEntryPassword = "" // Empty password by default
 
     @CommandLine.Option(
         names = ["--signer"],
@@ -142,20 +166,9 @@ internal object PatchCommand : Runnable {
     )
     private var signer = "ReVanced"
 
-    @CommandLine.Option(
-        names = ["-r", "--resource-cache"],
-        description = ["Path to temporary resource cache directory."],
-    )
-    private var resourceCachePath: File? = null
-        set(value) {
-            logger.warning("The --resource-cache option is deprecated. Use --temporary-files-patch instead.")
-            field = value
-            temporaryFilesPath = value
-        }
-
     @CommandLine.Option(
         names = ["-t", "--temporary-files-path"],
-        description = ["Path to temporary files directory."],
+        description = ["Path to store temporary files."],
     )
     private var temporaryFilesPath: File? = null
 
@@ -168,13 +181,6 @@ internal object PatchCommand : Runnable {
     )
     private var purge: Boolean = false
 
-    @CommandLine.Option(
-        names = ["-w", "--warn"],
-        description = ["Warn if a patch can not be found in the supplied patch bundles."],
-        showDefaultValue = ALWAYS,
-    )
-    private var warn: Boolean = false
-
     @CommandLine.Parameters(
         description = ["APK file to be patched."],
         arity = "1..1",
@@ -184,23 +190,13 @@ internal object PatchCommand : Runnable {
         if (!apk.exists()) {
             throw CommandLine.ParameterException(
                 spec.commandLine(),
-                "APK file ${apk.name} does not exist",
+                "APK file ${apk.path} does not exist",
             )
         }
         this.apk = apk
     }
 
-    @CommandLine.Option(
+    private lateinit var apk: File
-        names = ["-m", "--merge"],
-        description = ["One or more DEX files or containers to merge into the APK."],
-    )
-    @Suppress("unused")
-    private fun setIntegrations(integrations: Array<File>) {
-        integrations.firstOrNull { !it.exists() }?.let {
-            throw CommandLine.ParameterException(spec.commandLine(), "Integrations file ${it.name} does not exist.")
-        }
-        this.integrations += integrations
-    }
 
     @CommandLine.Option(
         names = ["-b", "--patch-bundle"],
@@ -215,6 +211,8 @@ internal object PatchCommand : Runnable {
         this.patchBundles = patchBundles
     }
 
+    private var patchBundles = emptySet<File>()
+
     @CommandLine.Option(
         names = ["--custom-aapt2-binary"],
         description = ["Path to a custom AAPT binary to compile resources with."],
@@ -243,11 +241,6 @@ internal object PatchCommand : Runnable {
                 "${outputFilePath.nameWithoutExtension}-temporary-files",
             )
 
-        val optionsFile =
-            optionsFile ?: outputFilePath.parentFile.resolve(
-                "${outputFilePath.nameWithoutExtension}-options.json",
-            )
-
         val keystoreFilePath =
             keystoreFilePath ?: outputFilePath.parentFile
                 .resolve("${outputFilePath.nameWithoutExtension}.keystore")
@@ -258,89 +251,100 @@ internal object PatchCommand : Runnable {
 
         logger.info("Loading patches")
 
-        val patches = PatchBundleLoader.Jar(*patchBundles.toTypedArray())
+        val patches = loadPatchesFromJar(patchBundles)
-
-        // Warn if a patch can not be found in the supplied patch bundles.
-        if (warn) {
-            patches.map { it.name }.toHashSet().let { availableNames ->
-                (includedPatches + excludedPatches).filter { name ->
-                    !availableNames.contains(name)
-                }
-            }.let { unknownPatches ->
-                if (unknownPatches.isEmpty()) return@let
-                logger.warning("Unknown input of patches:\n${unknownPatches.joinToString("\n")}")
-            }
-        }
 
         // endregion
+
+        val patcherTemporaryFilesPath = temporaryFilesPath.resolve("patcher")
+
         val (packageName, patcherResult) = Patcher(
             PatcherConfig(
                 apk,
-                temporaryFilesPath,
+                patcherTemporaryFilesPath,
                 aaptBinaryPath?.path,
-                temporaryFilesPath.absolutePath,
+                patcherTemporaryFilesPath.absolutePath,
                 true,
             ),
         ).use { patcher ->
-            val filteredPatches =
+            val packageName = patcher.context.packageMetadata.packageName
-                patcher.filterPatchSelection(patches).also { patches ->
+            val packageVersion = patcher.context.packageMetadata.packageVersion
-                    logger.info("Setting patch options")
 
-                    if (optionsFile.exists()) {
+            val filteredPatches = patches.filterPatchSelection(packageName, packageVersion)
-                        patches.setOptions(optionsFile)
+
-                    } else {
+            logger.info("Setting patch options")
-                        Options.serialize(patches, prettyPrint = true).let(optionsFile::writeText)
+
+            val patchesList = patches.toList()
+            selection.filter { it.include != null }.associate {
+                val includeSelection = it.include!!
+
+                (includeSelection.selector.name ?: patchesList[includeSelection.selector.index!!].name!!) to
+                    includeSelection.options
+            }.let(filteredPatches::setOptions)
+
+            patcher += filteredPatches
+
+            // Execute patches.
+            runBlocking {
+                patcher().collect { patchResult ->
+                    val exception = patchResult.exception
+                        ?: return@collect logger.info("\"${patchResult.patch}\" succeeded")
+
+                    StringWriter().use { writer ->
+                        exception.printStackTrace(PrintWriter(writer))
+
+                        logger.severe("\"${patchResult.patch}\" failed:\n$writer")
                     }
                 }
+            }
 
-            // region Patch
+            patcher.context.packageMetadata.packageName to patcher.get()
-
-            patcher.context.packageMetadata.packageName to patcher.apply {
-                acceptIntegrations(integrations)
-                acceptPatches(filteredPatches)
-
-                // Execute patches.
-                runBlocking {
-                    apply(false).collect { patchResult ->
-                        patchResult.exception?.let {
-                            StringWriter().use { writer ->
-                                it.printStackTrace(PrintWriter(writer))
-                                logger.severe("${patchResult.patch.name} failed:\n$writer")
-                            }
-                        } ?: logger.info("${patchResult.patch.name} succeeded")
-                    }
-                }
-            }.get()
-            // endregion
         }
 
-        // region Save
+        // region Save.
 
-        apk.copyTo(outputFilePath, overwrite = true)
+        apk.copyTo(temporaryFilesPath.resolve(apk.name), overwrite = true).apply {
-
+            patcherResult.applyTo(this)
-        patcherResult.applyTo(outputFilePath)
+        }.let { patchedApkFile ->
-
+            if (!mount) {
-        if (!mount) {
+                ApkUtils.signApk(
-            outputFilePath.sign(
+                    patchedApkFile,
-                ApkUtils.SigningOptions(
+                    outputFilePath,
-                    keystoreFilePath,
-                    keyStorePassword,
-                    alias,
-                    password,
                     signer,
-                ),
+                    ApkUtils.KeyStoreDetails(
-            )
+                        keystoreFilePath,
+                        keyStorePassword,
+                        keyStoreEntryAlias,
+                        keyStoreEntryPassword,
+                    ),
+                )
+            } else {
+                patchedApkFile.copyTo(outputFilePath, overwrite = true)
+            }
         }
 
         logger.info("Saved to $outputFilePath")
 
         // endregion
 
-        // region Install
+        // region Install.
 
-        deviceSerial?.let { serial ->
+        deviceSerial?.let {
-            AdbManager.getAdbManager(deviceSerial = serial.ifEmpty { null }, mount)
+            val deviceSerial = it.ifEmpty { null }
-        }?.install(AdbManager.Apk(outputFilePath, packageName))
+
+            runBlocking {
+                val result = if (mount) {
+                    AdbRootInstaller(deviceSerial)
+                } else {
+                    AdbInstaller(deviceSerial)
+                }.install(Installer.Apk(outputFilePath, packageName))
+
+                when (result) {
+                    RootInstallerResult.FAILURE -> logger.severe("Failed to mount the patched APK file")
+                    is AdbInstallerResult.Failure -> logger.severe(result.exception.toString())
+                    else -> logger.info("Installed the patched APK file")
+                }
+            }
+        }
 
         // endregion
 
@@ -351,61 +355,72 @@ internal object PatchCommand : Runnable {
     }
 
     /**
-     * Filter the patches to be added to the patcher. The filter is based on the following:
+     * Filter the patches based on the selection.
      *
-     * @param patches The patches to filter.
+     * @param packageName The package name of the APK file to be patched.
+     * @param packageVersion The version of the APK file to be patched.
      * @return The filtered patches.
      */
-    private fun Patcher.filterPatchSelection(patches: PatchSet): PatchSet =
+    private fun Set<Patch<*>>.filterPatchSelection(
-        buildSet {
+        packageName: String,
-            val packageName = context.packageMetadata.packageName
+        packageVersion: String,
-            val packageVersion = context.packageMetadata.packageVersion
+    ): Set<Patch<*>> = buildSet {
+        val includedPatchesByName =
+            selection.asSequence().mapNotNull { it.include?.selector?.name }.toSet()
+        val includedPatchesByIndex =
+            selection.asSequence().mapNotNull { it.include?.selector?.index }.toSet()
 
-            patches.withIndex().forEach patch@{ (i, patch) ->
+        val excludedPatches =
-                val patchName = patch.name!!
+            selection.asSequence().mapNotNull { it.exclude?.selector?.name }.toSet()
+        val excludedPatchesByIndex =
+            selection.asSequence().mapNotNull { it.exclude?.selector?.index }.toSet()
 
-                val explicitlyExcluded = excludedPatches.contains(patchName) || excludedPatchesByIndex.contains(i)
+        this@filterPatchSelection.withIndex().forEach patchLoop@{ (i, patch) ->
-                if (explicitlyExcluded) return@patch logger.info("Excluding $patchName")
+            val patchName = patch.name!!
 
-                // Make sure the patch is compatible with the supplied APK files package name and version.
+            val isManuallyExcluded = patchName in excludedPatches || i in excludedPatchesByIndex
-                patch.compatiblePackages?.let { packages ->
+            if (isManuallyExcluded) return@patchLoop logger.info("\"$patchName\" excluded manually")
-                    packages.singleOrNull { it.name == packageName }?.let { `package` ->
-                        val matchesVersion =
-                            force || `package`.versions?.let {
-                                it.any { version -> version == packageVersion }
-                            } ?: true
 
-                        if (!matchesVersion) {
+            // Make sure the patch is compatible with the supplied APK files package name and version.
-                            return@patch logger.warning(
+            patch.compatiblePackages?.let { packages ->
-                                "$patchName is incompatible with version $packageVersion. " +
+                packages.singleOrNull { (name, _) -> name == packageName }?.let { (_, versions) ->
-                                    "This patch is only compatible with version " +
+                    if (versions?.isEmpty() == true) {
-                                    packages.joinToString(";") { pkg ->
+                        return@patchLoop logger.warning("\"$patchName\" incompatible with \"$packageName\"")
-                                        pkg.versions!!.joinToString(", ")
+                    }
-                                    },
-                            )
-                        }
-                    } ?: return@patch logger.fine(
-                        "$patchName is incompatible with $packageName. " +
-                            "This patch is only compatible with " +
-                            packages.joinToString(", ") { `package` -> `package`.name },
-                    )
 
-                    return@let
+                    val matchesVersion =
-                } ?: logger.fine("$patchName has no constraint on packages.")
+                        force || versions?.let { it.any { version -> version == packageVersion } } ?: true
 
-                // If the patch is implicitly used, it will be only included if [exclusive] is false.
+                    if (!matchesVersion) {
-                val implicitlyIncluded = !exclusive && patch.use
+                        return@patchLoop logger.warning(
-                // If the patch is explicitly used, it will be included even if [exclusive] is false.
+                            "\"$patchName\" incompatible with $packageName $packageVersion " +
-                val explicitlyIncluded = includedPatches.contains(patchName) || includedPatchesByIndex.contains(i)
+                                "but compatible with " +
+                                packages.joinToString("; ") { (packageName, versions) ->
+                                    packageName + " " + versions!!.joinToString(", ")
+                                },
+                        )
+                    }
+                } ?: return@patchLoop logger.fine(
+                    "\"$patchName\" incompatible with $packageName. " +
+                        "It is only compatible with " +
+                        packages.joinToString(", ") { (name, _) -> name },
+                )
 
-                val included = implicitlyIncluded || explicitlyIncluded
+                return@let
-                if (!included) return@patch logger.info("$patchName excluded") // Case 1.
+            } ?: logger.fine("\"$patchName\" has no package constraints")
 
-                logger.fine("Adding $patchName")
+            val isIncluded = !exclusive && patch.use
+            val isManuallyIncluded = patchName in includedPatchesByName || i in includedPatchesByIndex
 
-                add(patch)
+            if (!(isIncluded || isManuallyIncluded)) {
+                return@patchLoop logger.info("\"$patchName\" excluded")
             }
+
+            add(patch)
+
+            logger.fine("\"$patchName\" added")
         }
+    }
 
     private fun purge(resourceCachePath: File) {
         val result =

src/main/kotlin/app/revanced/cli/command/utility/InstallCommand.kt

@@ -1,6 +1,9 @@
 package app.revanced.cli.command.utility
 
-import app.revanced.library.adb.AdbManager
+import app.revanced.library.installation.installer.*
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
 import picocli.CommandLine.*
 import java.io.File
 import java.util.logging.Logger
@@ -10,7 +13,7 @@ import java.util.logging.Logger
     description = ["Install an APK file to devices with the supplied ADB device serials"],
 )
 internal object InstallCommand : Runnable {
-    private val logger = Logger.getLogger(InstallCommand::class.java.name)
+    private val logger = Logger.getLogger(this::class.java.name)
 
     @Parameters(
         description = ["ADB device serials. If not supplied, the first connected device will be used."],
@@ -32,13 +35,29 @@ internal object InstallCommand : Runnable {
     private var packageName: String? = null
 
     override fun run() {
-        fun install(deviceSerial: String? = null) =
+        suspend fun install(deviceSerial: String? = null) {
-            try {
+            val result = try {
-                AdbManager.getAdbManager(deviceSerial, packageName != null).install(AdbManager.Apk(apk, packageName))
+                if (packageName != null) {
-            } catch (e: AdbManager.DeviceNotFoundException) {
+                    AdbRootInstaller(deviceSerial)
+                } else {
+                    AdbInstaller(deviceSerial)
+                }.install(Installer.Apk(apk, packageName))
+            } catch (e: Exception) {
                 logger.severe(e.toString())
             }
 
-        deviceSerials?.forEach(::install) ?: install()
+            when (result) {
+                RootInstallerResult.FAILURE ->
+                    logger.severe("Failed to mount the APK file")
+                is AdbInstallerResult.Failure ->
+                    logger.severe(result.exception.toString())
+                else ->
+                    logger.info("Installed the APK file")
+            }
+        }
+
+        runBlocking {
+            deviceSerials?.map { async { install(it) } }?.awaitAll() ?: install()
+        }
     }
 }

src/main/kotlin/app/revanced/cli/command/utility/UninstallCommand.kt

@@ -1,6 +1,12 @@
 package app.revanced.cli.command.utility
 
-import app.revanced.library.adb.AdbManager
+import app.revanced.library.installation.installer.AdbInstaller
+import app.revanced.library.installation.installer.AdbInstallerResult
+import app.revanced.library.installation.installer.AdbRootInstaller
+import app.revanced.library.installation.installer.RootInstallerResult
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
 import picocli.CommandLine.*
 import picocli.CommandLine.Help.Visibility.ALWAYS
 import java.util.logging.Logger
@@ -10,7 +16,7 @@ import java.util.logging.Logger
     description = ["Uninstall a patched app from the devices with the supplied ADB device serials"],
 )
 internal object UninstallCommand : Runnable {
-    private val logger = Logger.getLogger(UninstallCommand::class.java.name)
+    private val logger = Logger.getLogger(this::class.java.name)
 
     @Parameters(
         description = ["ADB device serials. If not supplied, the first connected device will be used."],
@@ -33,13 +39,28 @@ internal object UninstallCommand : Runnable {
     private var unmount: Boolean = false
 
     override fun run() {
-        fun uninstall(deviceSerial: String? = null) =
+        suspend fun uninstall(deviceSerial: String? = null) {
-            try {
+            val result = try {
-                AdbManager.getAdbManager(deviceSerial, unmount).uninstall(packageName)
+                if (unmount) {
-            } catch (e: AdbManager.DeviceNotFoundException) {
+                    AdbRootInstaller(deviceSerial)
+                } else {
+                    AdbInstaller(deviceSerial)
+                }.uninstall(packageName)
+            } catch (e: Exception) {
                 logger.severe(e.toString())
             }
 
-        deviceSerials?.forEach { uninstall(it) } ?: uninstall()
+            when (result) {
+                RootInstallerResult.FAILURE ->
+                    logger.severe("Failed to unmount the patched APK file")
+                is AdbInstallerResult.Failure ->
+                    logger.severe(result.exception.toString())
+                else -> logger.info("Uninstalled the patched APK file")
+            }
+        }
+
+        runBlocking {
+            deviceSerials?.map { async { uninstall(it) } }?.awaitAll() ?: uninstall()
+        }
     }
 }

src/test/kotlin/app/revanced/cli/command/OptionValueConverterTest.kt

@@ -0,0 +1,78 @@
+package app.revanced.cli.command
+
+import kotlin.test.Test
+
+class OptionValueConverterTest {
+    @Test
+    fun `converts to string`() {
+        "string" convertsTo "string" because "Strings should remain the same"
+    }
+
+    @Test
+    fun `converts to null`() {
+        "null" convertsTo null because "null should convert to null"
+        "\"null\"" convertsTo "null" because "Escaped null should convert to a string"
+    }
+
+    @Test
+    fun `converts to boolean`() {
+        "true" convertsTo true because "true should convert to a boolean true"
+        "True" convertsTo true because "Casing should not matter"
+        "\"true\"" convertsTo "true" because "Escaped booleans should be converted to strings"
+        "\'True\'" convertsTo "True" because "Casing in escaped booleans should not matter"
+        "tr ue" convertsTo "tr ue" because "Malformed booleans should be converted to strings"
+    }
+
+    @Test
+    fun `converts to numbers`() {
+        "1" convertsTo 1 because "Integers should convert to integers"
+        "1.0" convertsTo 1.0 because "Doubles should convert to doubles"
+        "1.0f" convertsTo 1.0f because "The suffix f should convert to a float"
+        Long.MAX_VALUE.toString() convertsTo Long.MAX_VALUE because "Values that are too large for an integer should convert to longs"
+        "1L" convertsTo 1L because "The suffix L should convert to a long"
+    }
+
+    @Test
+    fun `converts escaped numbers to string`() {
+        "\"1\"" convertsTo "1" because "Escaped numbers should convert to strings"
+        "\"1.0\"" convertsTo "1.0" because "Escaped doubles should convert to strings"
+        "\"1L\"" convertsTo "1L" because "Escaped longs should convert to strings"
+        "\'1\'" convertsTo "1" because "Single quotes should not be treated as escape symbols"
+        "\'.0\'" convertsTo ".0" because "Single quotes should not be treated as escape symbols"
+        "\'1L\'" convertsTo "1L" because "Single quotes should not be treated as escape symbols"
+    }
+
+    @Test
+    fun `trims escape symbols once`() {
+        "\"\"\"1\"\"\"" convertsTo "\"\"1\"\"" because "The escape symbols should be trimmed once"
+        "\'\'\'1\'\'\'" convertsTo "''1''" because "Single quotes should not be treated as escape symbols"
+    }
+
+    @Test
+    fun `converts lists`() {
+        "1,2" convertsTo "1,2" because "Lists without square brackets should not be converted to lists"
+        "[1,2" convertsTo "[1,2" because "Invalid lists should not be converted to lists"
+        "\"[1,2]\"" convertsTo "[1,2]" because "Lists with escaped square brackets should not be converted to lists"
+
+        "[]" convertsTo emptyList<Any>() because "Empty untyped lists should convert to empty lists of any"
+        "int[]" convertsTo emptyList<Int>() because "Empty typed lists should convert to lists of the specified type"
+        "[[int[]]]" convertsTo listOf(listOf(emptyList<Int>())) because "Nested typed lists should convert to nested lists of the specified type"
+        "[\"int[]\"]" convertsTo listOf("int[]") because "Lists of escaped empty typed lists should not be converted to lists"
+
+        "[1,2,3]" convertsTo listOf(1, 2, 3) because "Lists of integers should convert to lists of integers"
+        "[[1]]" convertsTo listOf(listOf(1)) because "Nested lists with one element should convert to nested lists"
+        "[[1,2],[3,4]]" convertsTo listOf(listOf(1, 2), listOf(3, 4)) because "Nested lists should convert to nested lists"
+
+        "[\"1,2\"]" convertsTo listOf("1,2") because "Values in lists should not be split by commas in strings"
+        "[[\"1,2\"]]" convertsTo listOf(listOf("1,2")) because "Values in nested lists should not be split by commas in strings"
+
+        "[\"\\\"\"]" convertsTo listOf("\"") because "Escaped quotes in strings should be converted to quotes"
+        "[[\"\\\"\"]]" convertsTo listOf(listOf("\"")) because "Escaped quotes in strings nested in lists should be converted to quotes"
+        "[.1,.2f,,true,FALSE]" convertsTo listOf(.1, .2f, "", true, false) because "Values in lists should be converted to the correct type"
+    }
+
+    private val convert = OptionValueConverter()::convert
+
+    private infix fun String.convertsTo(to: Any?) = convert(this) to to
+    private infix fun Pair<Any?, Any?>.because(reason: String) = assert(this.first == this.second) { reason }
+}