feat: Magisk module install

library/src/androidMain/assets/root/module.prop

@@ -0,0 +1,6 @@
+id=__PKG_NAME__-ReVanced
+name=__LABEL__ ReVanced
+version=__VERSION__
+versionCode=0
+author=ReVanced
+description=Mounts the patched APK on top of the original one

library/src/androidMain/assets/root/service.sh

@@ -0,0 +1,54 @@
+#!/system/bin/sh
+DIR=${0%/*}
+
+package_name="__PKG_NAME__"
+version="__VERSION__"
+sanitized_package_name=$(echo "$package_name" | sed 's/\./_/g')
+
+rm -f "$DIR/log"
+
+{
+echo "Induction check for $package_name"
+
+until [ "$(getprop sys.boot_completed)" = 1 ]; do sleep 5; done
+# Wait a bit more for package manager to settle
+sleep 10
+
+base_path="$DIR/system/app/$sanitized_package_name/base.apk"
+if [ ! -f "$base_path" ]; then
+    # Fallback to old path for compatibility during transition
+    base_path="$DIR/$package_name.apk"
+fi
+
+stock_path="$(pm path "$package_name" | grep base | sed 's/package://g' | head -n 1)"
+stock_version="$(dumpsys package "$package_name" | grep versionName | cut -d "=" -f2 | head -n 1 | sed 's/ //g')"
+
+echo "base_path: $base_path"
+echo "stock_path: $stock_path"
+echo "base_version: $version"
+echo "stock_version: $stock_version"
+
+if [ -z "$stock_path" ]; then
+  echo "App $package_name is not installed. System app induction might have failed or still being processed."
+  exit 1
+fi
+
+if echo "$stock_path" | grep -q "^/system/"; then
+  echo "App is already running from system partition (likely our Magisk overlay). Skipping bind mount."
+  exit 0
+fi
+
+if mount | grep -q "$stock_path" ; then
+  echo "Not mounting as stock path is already mounted"
+  exit 1
+fi
+
+if [ "$version" != "$stock_version" ]; then
+  echo "Version mismatch: base=$version, stock=$stock_version. Attempting to mount anyway as it might be a minor diff."
+  # Optional: exit 1 if you want to be strict
+fi
+
+echo "Mounting $base_path over $stock_path"
+mount -o bind "$base_path" "$stock_path"
+
+} >> "$DIR/log"

library/src/androidMain/kotlin/app/revanced/library/MagiskUtils.kt

@@ -0,0 +1,233 @@
+package app.revanced.library
+
+import android.content.res.AssetManager
+import com.topjohnwu.superuser.Shell
+import com.topjohnwu.superuser.nio.FileSystemManager
+import java.io.File
+import java.util.zip.ZipFile
+
+object MagiskUtils {
+    const val MODULES_PATH = "/data/adb/modules"
+
+    fun hasRootAccess() = Shell.isAppGrantedRoot() ?: false
+
+    fun isDeviceRooted() =
+        System.getenv("PATH")?.split(":")?.any { path -> File(path, "su").canExecute() } ?: false
+
+    fun isInstalled(packageName: String, remoteFS: FileSystemManager) =
+        remoteFS.getFile("$MODULES_PATH/$packageName-revanced").exists()
+
+    fun isInstalledAsMagiskModule(packageName: String, remoteFS: FileSystemManager) =
+        remoteFS.getFile("$MODULES_PATH/revanced_${packageName.replace('.', '_')}").exists()
+
+    fun mount(packageName: String, sourceDir: String) {
+        val modulePath = "$MODULES_PATH/$packageName-revanced"
+        val patchedApk = "$modulePath/$packageName.apk"
+        Shell.getShell().newJob()
+            .add("mount -o bind \"$patchedApk\" \"$sourceDir\"")
+            .exec()
+            .assertSuccess("Failed to mount APK")
+    }
+
+    fun unmount(sourceDir: String) {
+        Shell.getShell().newJob()
+            .add("umount -l \"$sourceDir\"")
+            .exec()
+            .assertSuccess("Failed to unmount APK")
+    }
+
+    fun uninstall(packageName: String, remoteFS: FileSystemManager) {
+        remoteFS.getFile("$MODULES_PATH/$packageName-revanced").deleteRecursively()
+            .also { if (!it) throw Exception("Failed to delete files") }
+    }
+
+    fun uninstallMagiskModule(packageName: String, remoteFS: FileSystemManager) {
+        val sanitizedPackageName = packageName.replace('.', '_')
+        remoteFS.getFile("$MODULES_PATH/revanced_$sanitizedPackageName").deleteRecursively()
+            .also { if (!it) throw Exception("Failed to delete Magisk module files") }
+    }
+
+    fun extractNativeLibraries(apkFile: File, systemAppPath: String, remoteFS: FileSystemManager) {
+        val libPath = "$systemAppPath/lib"
+        remoteFS.getFile(libPath).apply {
+            if (exists()) deleteRecursively()
+            mkdirs()
+        }
+
+        ZipFile(apkFile).use { zip ->
+            zip.entries().asSequence()
+                .filter { it.name.startsWith("lib/") && it.name.endsWith(".so") }
+                .forEach { entry ->
+                    val parts = entry.name.split("/")
+                    if (parts.size < 3) return@forEach
+
+                    val apkAbi = parts[1]
+                    val libName = parts.last()
+                    val systemAbi = when (apkAbi) {
+                        "arm64-v8a" -> "arm64"
+                        "armeabi-v7a" -> "arm"
+                        "x86_64" -> "x86_64"
+                        "x86" -> "x86"
+                        else -> apkAbi
+                    }
+
+                    val targetDir = "$libPath/$systemAbi"
+                    remoteFS.getFile(targetDir).apply { if (!exists()) mkdirs() }
+
+                    val targetFile = "$targetDir/$libName"
+                    zip.getInputStream(entry).use { inputStream ->
+                        remoteFS.getFile(targetFile).newOutputStream().use { outputStream ->
+                            inputStream.copyTo(outputStream)
+                        }
+                    }
+                }
+        }
+    }
+
+    fun provisionMagiskModule(
+        remoteFS: FileSystemManager,
+        assets: AssetManager,
+        packageName: String,
+        version: String,
+        label: String,
+        patchedApk: File
+    ) {
+        val sanitizedPackageName = packageName.replace('.', '_')
+        val modulePath = "$MODULES_PATH/revanced_$sanitizedPackageName"
+        val systemAppPath = "$modulePath/system/app/$sanitizedPackageName"
+
+        Shell.getShell().newJob()
+            .add("mkdir -p \"$systemAppPath\"")
+            .exec()
+            .assertSuccess("Failed to create system app directory")
+
+        val moduleProp = buildString {
+            appendLine("id=revanced_$sanitizedPackageName")
+            appendLine("name=$label ReVanced")
+            appendLine("version=$version")
+            appendLine("versionCode=1")
+            appendLine("author=ReVanced")
+            append("description=Patched by ReVanced")
+        }
+        remoteFS.getFile("$modulePath/module.prop").newOutputStream().use { it.write(moduleProp.toByteArray()) }
+
+        assets.open("root/service.sh").use { inputStream ->
+            remoteFS.getFile("$modulePath/service.sh").newOutputStream().use { outputStream ->
+                val content = String(inputStream.readBytes())
+                    .replace("__PKG_NAME__", packageName)
+                    .replace("__VERSION__", version)
+                    .replace("__LABEL__", label)
+                    .toByteArray()
+                outputStream.write(content)
+            }
+        }
+
+        val targetApkPath = "$systemAppPath/base.apk"
+        remoteFS.getFile(patchedApk.absolutePath)
+            .also { if (!it.exists()) throw Exception("File doesn't exist") }
+            .newInputStream().use { inputStream ->
+                remoteFS.getFile(targetApkPath).newOutputStream().use { outputStream ->
+                    inputStream.copyTo(outputStream)
+                }
+            }
+
+        extractNativeLibraries(patchedApk, systemAppPath, remoteFS)
+
+        Shell.getShell().newJob()
+            .add("chmod 644 \"$targetApkPath\"")
+            .add("chmod 755 \"$systemAppPath\"")
+            .add("chmod -R 755 \"$systemAppPath/lib\"")
+            .add("find \"$systemAppPath/lib\" -type f -name \"*.so\" -exec chmod 644 {} +")
+            .add("chown -R system:system \"$modulePath/system\"")
+            .add("chcon -R u:object_r:system_file:s0 \"$modulePath/system\"")
+            .add("chmod +x \"$modulePath/service.sh\"")
+            .exec()
+            .assertSuccess("Failed to set file permissions")
+    }
+
+    fun provisionRootFolder(
+        remoteFS: FileSystemManager,
+        assets: AssetManager,
+        packageName: String,
+        version: String,
+        label: String,
+        patchedApk: File
+    ) {
+        val modulePath = "$MODULES_PATH/$packageName-revanced"
+        remoteFS.getFile(modulePath).apply {
+            if (!mkdirs() && !exists()) {
+                throw Exception("Failed to create module directory")
+            }
+        }
+
+        listOf(
+            "service.sh",
+            "module.prop",
+        ).forEach { file ->
+            assets.open("root/$file").use { inputStream ->
+                remoteFS.getFile("$modulePath/$file").newOutputStream().use { outputStream ->
+                    val content = String(inputStream.readBytes())
+                        .replace("__PKG_NAME__", packageName)
+                        .replace("__VERSION__", version)
+                        .replace("__LABEL__", label)
+                        .toByteArray()
+                    outputStream.write(content)
+                }
+            }
+        }
+
+        val apkPath = "$modulePath/$packageName.apk"
+        remoteFS.getFile(patchedApk.absolutePath)
+            .also { if (!it.exists()) throw Exception("File doesn't exist") }
+            .newInputStream().use { inputStream ->
+                remoteFS.getFile(apkPath).newOutputStream().use { outputStream ->
+                    inputStream.copyTo(outputStream)
+                }
+            }
+
+        Shell.getShell().newJob()
+            .add("chmod 644 \"$apkPath\"")
+            .add("chown system:system \"$apkPath\"")
+            .add("chcon u:object_r:apk_data_file:s0 \"$apkPath\"")
+            .add("chmod +x \"$modulePath/service.sh\"")
+            .exec()
+            .assertSuccess("Failed to set file permissions")
+    }
+
+    private fun Shell.Result.assertSuccess(errorMessage: String) {
+        if (!isSuccess) {
+            throw ShellCommandException(errorMessage, code, out, err)
+        }
+    }
+}
+
+class ShellCommandException(
+    val userMessage: String,
+    val exitCode: Int,
+    val stdout: List<String>,
+    val stderr: List<String>
+) : Exception(format(userMessage, exitCode, stdout, stderr)) {
+    companion object {
+        private fun format(
+            message: String,
+            exitCode: Int,
+            stdout: List<String>,
+            stderr: List<String>
+        ): String = buildString {
+            appendLine(message)
+            appendLine("Exit code: $exitCode")
+
+            val output = stdout.filter { it.isNotBlank() }
+            val errors = stderr.filter { it.isNotBlank() }
+
+            if (output.isNotEmpty()) {
+                appendLine("stdout:")
+                output.forEach(::appendLine)
+            }
+            if (errors.isNotEmpty()) {
+                appendLine("stderr:")
+                errors.forEach(::appendLine)
+            }
+        }
+    }
+}

library/src/androidMain/kotlin/app/revanced/library/installation/installer/LocalMagiskInstaller.kt

@@ -0,0 +1,32 @@
+package app.revanced.library.installation.installer
+
+import android.content.Context
+import app.revanced.library.installation.command.LocalShellCommandRunner
+import com.topjohnwu.superuser.ipc.RootService
+import java.io.Closeable
+
+/**
+ * [LocalMagiskInstaller] for installing and uninstalling [Apk] files locally with root permissions via Magisk modules.
+ *
+ * @param context The [Context] to use for binding to the [RootService].
+ * @param onReady A callback to be invoked when [LocalMagiskInstaller] is ready to be used.
+ *
+ * @throws NoRootPermissionException If the device does not have root permission.
+ *
+ * @see Installer
+ * @see LocalShellCommandRunner
+ */
+@Suppress("unused")
+class LocalMagiskInstaller(
+    context: Context,
+    onReady: LocalMagiskInstaller.() -> Unit = {},
+) : MagiskInstaller(
+    { installer ->
+        LocalShellCommandRunner(context) {
+            (installer as LocalMagiskInstaller).onReady()
+        }
+    },
+),
+    Closeable {
+    override fun close() = (shellCommandRunner as LocalShellCommandRunner).close()
+}

library/src/commonMain/kotlin/app/revanced/library/ApkUtils.kt

@@ -53,8 +53,9 @@ object ApkUtils {
     fun PatchesResult.applyTo(apkFile: File) {
         ZFile.openReadWrite(apkFile, zFileOptions).use { targetApkZFile ->
             dexFiles.forEach { dexFile ->
-                targetApkZFile.add(dexFile.name, dexFile.stream)
-                dexFile.stream.close()
+                dexFile.stream.use { stream ->
+                    targetApkZFile.add(dexFile.name, stream)
+                }
             }
 
             resources?.let { resources ->

library/src/commonMain/kotlin/app/revanced/library/installation/installer/AdbMagiskInstaller.kt

@@ -0,0 +1,21 @@
+package app.revanced.library.installation.installer
+
+import app.revanced.library.installation.command.AdbShellCommandRunner
+
+/**
+ * [AdbMagiskInstaller] for installing and uninstalling [Apk] files using ADB root permissions via Magisk modules.
+ *
+ * @param deviceSerial The device serial. If null, the first connected device will be used.
+ *
+ * @throws NoRootPermissionException If the device does not have root permission.
+ *
+ * @see MagiskInstaller
+ * @see AdbShellCommandRunner
+ */
+class AdbMagiskInstaller(
+    deviceSerial: String? = null,
+) : MagiskInstaller({ AdbShellCommandRunner(deviceSerial) }) {
+    init {
+        logger.fine("Connected to $deviceSerial")
+    }
+}

library/src/commonMain/kotlin/app/revanced/library/installation/installer/Constants.kt

@@ -20,6 +20,26 @@ internal object Constants {
     const val CREATE_INSTALLATION_PATH = "$CREATE_DIR $MOUNT_PATH"
     const val GET_SDK_VERSION = "getprop ro.build.version.sdk"
 
+    const val MAGISK_MODULES_PATH = "/data/adb/modules/"
+    const val MAGISK_MODULE_ID = "revanced_$PLACEHOLDER"
+    const val MAGISK_MODULE_PATH = "$MAGISK_MODULES_PATH$MAGISK_MODULE_ID"
+
+    const val COPY_APK_TO_MODULE =
+        "cp $TMP_FILE_PATH $PLACEHOLDER && " +
+                "chmod 644 $PLACEHOLDER && " +
+                "chown system:system $PLACEHOLDER && " +
+                "chcon $SELINUX_CONTEXT $PLACEHOLDER"
+
+    val MAGISK_MODULE_PROP =
+        $$"""
+        id=$$MAGISK_MODULE_ID
+        name=ReVanced $$PLACEHOLDER
+        version=1.0
+        versionCode=1
+        author=ReVanced
+        description=Patched by ReVanced
+        """.trimIndent()
+
     const val MOUNT_APK =
         "base_path=\"$MOUNTED_APK_PATH\" && " +
                 $$"mv $$TMP_FILE_PATH $base_path && " +