xposed-module-builder.kt

/**
 * Xposed Module Builder & Validator - Kotlin Tool
 * Helps create and validate LSPosed/Xposed modules with hooks
 */

import java.io.File
import java.util.*

data class XposedModuleConfig(
    val packageName: String,
    val moduleName: String,
    val description: String,
    val minSdk: Int = 24,
    val targetSdk: Int = 34,
    val version: String = "1.0",
    val hooks: List<String> = emptyList()
)

object XposedModuleValidator {
    
    fun validateModuleStructure(modulePath: String): ValidationResult {
        val dir = File(modulePath)
        val result = ValidationResult()
        
        // Check required files
        val requiredFiles = listOf(
            "module.prop",
            "riru.sh",
            "system.prop",
            "post-fs-data.sh",
            "service.sh"
        )
        
        for (file in requiredFiles) {
            val f = File(dir, file)
            if (!f.exists()) {
                result.addError("Missing required file: $file")
            } else {
                result.addSuccess("Found: $file")
            }
        }
        
        // Validate module.prop format
        val moduleProp = File(dir, "module.prop")
        if (moduleProp.exists()) {
            validateModuleProp(moduleProp, result)
        }
        
        return result
    }
    
    private fun validateModuleProp(file: File, result: ValidationResult) {
        val required = setOf("id", "name", "version", "versionCode", "author", "description")
        val found = mutableSetOf<String>()
        
        file.readLines().forEach { line ->
            if (!line.startsWith("#")) {
                val parts = line.split("=")
                if (parts.size == 2) {
                    found.add(parts[0].trim())
                }
            }
        }
        
        for (field in required) {
            if (field in found) {
                result.addSuccess("module.prop: $field found")
            } else {
                result.addError("module.prop: missing $field")
            }
        }
    }
    
    fun generateModuleTemplate(config: XposedModuleConfig, outputDir: String) {
        val dir = File(outputDir)
        dir.mkdirs()
        
        // Generate module.prop
        val moduleProp = """
            |id=${config.packageName}
            |name=${config.moduleName}
            |version=${config.version}
            |versionCode=1
            |author=OutrageousStorm
            |description=${config.description}
            |minApi=${config.minSdk}
            |targetApi=${config.targetSdk}
        """.trimMargin()
        
        File(dir, "module.prop").writeText(moduleProp)
        
        // Generate post-fs-data.sh
        val postFsData = """
            |#!/system/bin/sh
            |MODPATH=${'$'}{0%/*}
            |MODNAME=`basename ${'$'}MODPATH`
            |
            |# Log function
            |ui_print() {
            |  echo "${'$'}" >> ${'$'}LOGFILE
            |}
            |
            |# Begin setup
            |LOGFILE=${'$'}/data/adb/modules/${'$'}MODNAME/install.log
            |mkdir -p "$(dirname "${'$'}LOGFILE")"
            |
            |echo "Module initialization starting..." >> ${'$'}LOGFILE
            |
            |# Copy module files
            |cp -rf "${'$'}MODPATH/system" /system 2>/dev/null || true
            |
            |echo "Module setup complete" >> ${'$'}LOGFILE
        """.trimMargin()
        
        File(dir, "post-fs-data.sh").writeText(postFsData)
        
        // Generate Hook template
        val hooksFile = """
            |// Xposed Hook Template for ${config.moduleName}
            |
            |import de.robv.android.xposed.IXposedHookLoadPackage
            |import de.robv.android.xposed.XposedBridge
            |import de.robv.android.xposed.callbacks.XC_LoadPackage
            |
            |class XposedHooks : IXposedHookLoadPackage {
            |    override fun handleLoadPackage(lpparam: XC_LoadPackage.LoadPackageParam) {
            |        if (lpparam.packageName != "${config.packageName}") {
            |            return
            |        }
            |        
            |        XposedBridge.log("Loaded into ${config.moduleName}")
            |        
            |        // Add hooks here
            |        ${config.hooks.joinToString("\n        ")}
            |    }
            |}
        """.trimMargin()
        
        File(dir, "Hooks.kt").writeText(hooksFile)
        
        println("✓ Module template generated at $outputDir")
    }
}

class ValidationResult {
    private val successes = mutableListOf<String>()
    private val errors = mutableListOf<String>()
    
    fun addSuccess(msg: String) = successes.add(msg)
    fun addError(msg: String) = errors.add(msg)
    
    fun isValid() = errors.isEmpty()
    
    fun printReport() {
        println("\n=== Module Validation Report ===")
        println("Status: ${if (isValid()) "✅ VALID" else "❌ INVALID"}")
        
        if (successes.isNotEmpty()) {
            println("\nChecks Passed:")
            successes.forEach { println("  ✓ $it") }
        }
        
        if (errors.isNotEmpty()) {
            println("\nErrors:")
            errors.forEach { println("  ✗ $it") }
        }
        
        println("================================\n")
    }
}

fun main(args: Array<String>) {
    if (args.isEmpty()) {
        println("Usage: xposed-module-builder <command> [args]")
        println("\nCommands:")
        println("  validate <path>              Validate module structure")
        println("  generate <package> <name>    Generate new module template")
        return
    }
    
    when (args[0]) {
        "validate" -> {
            if (args.size < 2) {
                println("Usage: validate <path>")
                return
            }
            val result = XposedModuleValidator.validateModuleStructure(args[1])
            result.printReport()
        }
        "generate" -> {
            if (args.size < 3) {
                println("Usage: generate <package.name> <Module Name>")
                return
            }
            val config = XposedModuleConfig(
                packageName = args[1],
                moduleName = args[2],
                description = if (args.size > 3) args[3] else "Custom Xposed Module"
            )
            val outputDir = "./modules/${config.packageName}"
            XposedModuleValidator.generateModuleTemplate(config, outputDir)
        }
        else -> println("Unknown command: ${args[0]}")
    }
}