Bulk Actions — Implementation Deep Dive

{
  "output-file": "~/BulkActions/output.txt",
  "timeout": 300,
  "outputAsCsv": false,
  "url-proxypac": "http://proxy.example.com/proxy.pac",
  "log-proxy": true,
  "run": {
    "ping-google": "ping -c 4 google.com",
    "dig-ns": "dig @1.1.1.1 google.com",
    "ntp-sync": "ntp pool.ntp.org",
    "port-scan": "port-scan -p 22,80,443 google.com",
    "checkcert": "checkcert -p 443 google.com",
    "lan-scan": "lan-scan",
    "sleep-wait": "sleep 5",
    "device-info": "device-info"
  }
}

object BulkConfigParser {
 
    /** Application context, set once by BulkActionsViewModel factory. */
    @Volatile
    internal var appContext: Context? = null
 
    /** When true, skip file existence checks during parse (for unit tests). */
    @Volatile
    internal var skipFileValidation: Boolean = false
 
    @Throws(IllegalArgumentException::class)
    fun parse(json: String): BulkConfig {
        val root = JSONObject(json)
 
        val outputFile = runCatching {
            val path = root.optString("output-file", "")
            if (path.isNullOrBlank()) null
            else expandTilde(path)
        }.getOrNull()
 
        val timeoutMs = runCatching {
            val seconds = root.optLong("timeout", 0L)
            if (seconds == null || seconds <= 0) null
            else seconds * 1000L
        }.getOrNull()
 
        val outputAsCsv = runCatching {
            root.optBoolean("outputAsCsv", false)
        }.getOrDefault(false)
 
        val urlProxyPac = runCatching {
            val url = root.optString("url-proxypac", "")
            if (url.isNullOrBlank()) null else url.trim()
        }.getOrNull()
 
        val fileProxyPac = runCatching {
            val path = root.optString("file-proxypac", "")
            if (path.isNullOrBlank()) null else expandTilde(path.trim())
        }.getOrNull()
 
        // Mutual exclusion validation — throw if both are present
        if (!urlProxyPac.isNullOrBlank() && !fileProxyPac.isNullOrBlank()) {
            throw IllegalArgumentException(
                "Cannot specify both 'url-proxypac' and 'file-proxypac'. They are mutually exclusive."
            )
        }
 
        // Validate file-proxypac exists and is readable
        if (!fileProxyPac.isNullOrBlank() && !skipFileValidation) {
            val file = java.io.File(fileProxyPac)
            if (!file.exists()) {
                throw IllegalArgumentException("file-proxypac file not found: $fileProxyPac")
            }
            if (!file.canRead()) {
                throw IllegalArgumentException("file-proxypac is not readable: $fileProxyPac")
            }
        }
 
        val logProxy: Boolean? = if (root.has("log-proxy")) {
            runCatching { root.optBoolean("log-proxy", false) }.getOrNull()
        } else {
            null
        }
 
        val runObj = root.optJSONObject("run")
            ?: throw IllegalArgumentException("Missing required 'run' object in configuration")
 
        val commands = mutableMapOf<String, String>()
        val keys = runObj.keys()
        while (keys.hasNext()) {
            val key = keys.next()
            val value = runObj.getString(key).trim()
            if (value.isNotBlank()) {
                commands[key] = value
            }
        }
 
        return BulkConfig(outputFile, commands, timeoutMs, outputAsCsv, urlProxyPac, fileProxyPac, logProxy)
    }
}

private fun expandTilde(path: String): String {
    if (!path.startsWith("~/")) return path
    val privateDir = appContext?.applicationContext?.filesDir?.absolutePath
        ?: Environment.getExternalStorageDirectory().absolutePath
    return "$privateDir${path.substring(1)}"
}

fun validateOutputFile(rawPath: String): OutputFileValidationResult {
    val expanded = expandTilde(rawPath)
 
    val parent = File(expanded).parentFile
    val canCreateDirs = parent?.mkdirs() == true || parent?.exists() == true
    if (!canCreateDirs) {
        val suggested = suggestFallbackPath(rawPath)
        return OutputFileValidationResult.Invalid(rawPath, suggested)
    }
 
    val testFile = File(expanded)
    val canWrite = try {
        testFile.createNewFile() && testFile.canWrite()
    } catch (_: Exception) {
        false
    }
 
    return if (canWrite) {
        runCatching { testFile.delete() }
        OutputFileValidationResult.Valid(expanded)
    } else {
        val suggested = suggestFallbackPath(rawPath)
        OutputFileValidationResult.Invalid(rawPath, suggested)
    }
}

fun extractCommandTimeout(cmd: String): Long? {
    val parts = cmd.trim().split(Regex("\\s+"))
    val tIdx = parts.indexOf("-t")
    if (tIdx >= 0 && tIdx < parts.size - 1) {
        return parts[tIdx + 1].toLongOrNull()?.takeIf { it > 0 }?.let { it * 1000L }
    }
    return null
}

class BulkActionsRepository(
    private val context: Context,
    private val digRepo: DigRepository = DigRepository(),
    private val ntpRepo: NtpRepository = NtpRepository(),
    private val certRepo: HttpsCertRepository = HttpsCertRepository(),
) {

@Volatile
private var bulkProxyResolver: ProxyResolver? = null
 
fun setupProxyResolver(pacUrl: String?, forceLogging: Boolean = false) {
    bulkProxyResolver = pacUrl?.let { buildProxyResolver(it, forceLogging) }
}
 
fun clearProxyResolver() {
    bulkProxyResolver = null
}

suspend fun executeSingleCommand(name: String, cmd: String, timeoutMs: Long? = null): BulkCommandResult {
    val trimmed = cmd.trim()
    val parts = trimmed.split(Regex("\\s+"))
    val prefix = parts.firstOrNull()?.lowercase() ?: ""
 
    return when {
        prefix == "ping"              -> executePing(name, trimmed, parts, timeoutMs)
        prefix == "dig"               -> executeDig(name, trimmed, timeoutMs)
        prefix == "ntp"               -> executeNtp(name, trimmed, timeoutMs)
        prefix == "port-scan"         -> executePortScan(name, trimmed, timeoutMs)
        prefix == "checkcert"         -> executeCheckcert(name, trimmed, timeoutMs)
        prefix == "device-info"       -> executeDeviceInfo(name, trimmed)
        prefix == "tracert"           -> executeTracert(name, trimmed, timeoutMs)
        prefix == "google-timesync"   -> executeGoogleTimeSync(name, trimmed, timeoutMs)
        prefix == "lan-scan"          -> executeLanScan(name, trimmed, timeoutMs)
        prefix == "sleep"             -> executeSleep(name, trimmed, timeoutMs)
        else                          -> executeRaw(name, trimmed, timeoutMs)
    }
}

suspend fun executeCommands(
    config: BulkConfig,
    cancellationToken: AtomicBoolean = AtomicBoolean(false),
    onProgress: ((BulkProgress) -> Unit)? = null,
): List<BulkCommandResult> {
    val pacSource = config.urlProxyPac ?: config.fileProxyPac
    bulkProxyResolver = pacSource?.let {
        buildProxyResolver(it, forceLogging = config.logProxy == true)
    }
 
    val results = mutableListOf<BulkCommandResult>()
    val commands = config.commands.toList()
    val total = commands.size
    val defaultTimeoutMs = config.timeoutMs ?: 30_000L
 
    try {
        commands.forEachIndexed { index, (name, cmd) ->
            if (cancellationToken.get()) {
                results.add(BulkCommandTimeout(name, cmd))
                return@forEachIndexed
            }
 
            onProgress?.invoke(BulkProgress(index, total, name, cmd))
 
            val commandTimeoutMs = extractCommandTimeout(cmd) ?: defaultTimeoutMs
 
            val result = withTimeoutOrNull(commandTimeoutMs) {
                executeSingleCommand(name, cmd, commandTimeoutMs)
            }
 
            val finalResult = result ?: BulkCommandTimeout(name, cmd)
            results.add(finalResult)
        }
    } finally {
        bulkProxyResolver = null
    }
 
    return results
}

private suspend fun executePing(name: String, cmd: String, parts: List<String>, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val t0 = System.currentTimeMillis()
        val countIdx = parts.indexOf("-c")
        val count = if (countIdx >= 0 && countIdx < parts.size - 1) {
            parts[countIdx + 1].toIntOrNull() ?: 4
        } else { 4 }
 
        val timeoutIdx = parts.indexOf("-t")
        val timeout = if (timeoutIdx >= 0 && timeoutIdx < parts.size - 1) {
            parts[timeoutIdx + 1].toIntOrNull() ?: 0
        } else { 0 }
 
        // Host = first non-flag argument
        val host = run {
            var i = 1
            val flags = setOf("-c", "-t", "-W", "-i", "-I", "-D", "-S", "-p", "-f", "-q", "-C", "-N", "-R", "-r", "-l", "-L", "-M", "-n", "-O", "-s", "-T", "-v")
            while (i < parts.size) {
                if (parts[i] in flags && i + 1 < parts.size) i += 2
                else if (parts[i].startsWith("-")) i++
                else break
            }
            parts.getOrNull(i) ?: parts.last()
        }
 
        val pingArgs = mutableListOf("ping", "-c", count.toString())
        if (timeout > 0) { pingArgs.add("-W"); pingArgs.add(timeout.toString()) }
        pingArgs.add(host)
 
        val process = Runtime.getRuntime().exec(pingArgs.toTypedArray())
        val output = process.inputStream.bufferedReader().readLines()
        val exitCode = process.waitFor()
        val duration = System.currentTimeMillis() - t0
 
        when (exitCode) {
            0 -> BulkCommandSuccess(name, cmd, lines, duration)
            else -> BulkCommandError(name, cmd, lines.lastOrNull() ?: "Unknown error")
        }
    }
}

private suspend fun executeDig(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val parts = cmd.split(Regex("\\s+"))
        val serverIdx = parts.indexOfFirst { it.startsWith("@") }
        val (server, fqdn) = if (serverIdx >= 0 && serverIdx < parts.size && (serverIdx > 1 || serverIdx + 1 < parts.size)) {
            val serverHost = parts[serverIdx].substring(1)
            val fqdnIdx = if (serverIdx == 1) {
                // dig @server [-t N] fqdn
                var i = serverIdx + 1
                while (i < parts.size && parts[i] == "-t" && i + 1 < parts.size) i += 2
                i
            } else {
                // dig fqdn @server -> FQDN is right before @server
                serverIdx - 1
            }
            serverHost to parts[fqdnIdx]
        } else {
            "8.8.8.8" to parts.last()
        }
 
        val result = digRepo.resolve(server, fqdn)
        // ... build output lines based on result type ...
        when (result) {
            is DigResult.Success -> BulkCommandSuccess(name, cmd, lines, duration)
            else -> BulkCommandError(name, cmd, lines.lastOrNull() ?: "Unknown error")
        }
    }
}

private suspend fun executeNtp(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val parts = cmd.split(Regex("\\s+"))
        val pool = parts.getOrNull(1) ?: "pool.ntp.org"
        val result = ntpRepo.query(pool)
        // ... build output lines ...
        when (result) {
            is NtpResult.Success -> BulkCommandSuccess(name, cmd, lines, duration)
            else -> BulkCommandError(name, cmd, lines.lastOrNull() ?: "Unknown error")
        }
    }
}

private suspend fun executePortScan(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val parts = cmd.split(Regex("\\s+"))
        val portIdx = parts.indexOfFirst { it == "-p" }
        val (portStr, hasFlag) = if (portIdx >= 0) {
            parts.getOrNull(portIdx + 1) to true
        } else {
            // Positional: port-scan <ports> [-t timeout] <host>
            parts.getOrNull(1) to false
        } ?: ("22" to false)
 
        val host = run {
            val hostStart = if (hasFlag) portIdx + 2 else 2
            var i = hostStart
            val skipFlags = setOf("-t")
            while (i < parts.size) {
                if (parts[i] in skipFlags && i + 1 < parts.size) i += 2
                else if (parts[i].startsWith("-")) i++
                else break
            }
            parts.getOrNull(i)
        } ?: parts.last()
 
        val tIdx = parts.indexOf("-t")
        val connectTimeout = if (tIdx >= 0 && tIdx < parts.size - 1) {
            parts[tIdx + 1].toIntOrNull()?.times(1000) ?: 2000
        } else { 2000 }
 
        val ports = parsePortRange(portStr ?: "22")
 
        // Validate host resolves before scanning
        try {
            java.net.InetAddress.getByName(host)
        } catch (e: java.net.UnknownHostException) {
            return@withContext BulkCommandError(name, cmd, e.message ?: "Unknown host")
        }
 
        val openPorts = mutableListOf<Int>()
        val mutex = Mutex()
        val concurrencyLimit = 50
        val chunks = ports.chunked(concurrencyLimit)
 
        for (chunk in chunks) {
            val deferreds = chunk.map { port ->
                async {
                    val isOpen = try {
                        val socket = Socket()
                        socket.connect(InetSocketAddress(host, port), connectTimeout)
                        socket.close()
                        true
                    } catch (_: Exception) { false }
                    mutex.withLock { if (isOpen) openPorts.add(port) }
                }
            }
            deferreds.awaitAll()
        }
        openPorts.sort()
 
        if (openPorts.isEmpty()) BulkCommandClosed(name, cmd, lines, duration)
        else BulkCommandSuccess(name, cmd, lines, duration)
    }
}

private suspend fun executeCheckcert(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val parts = cmd.split(Regex("\\s+"))
        val portIdx = parts.indexOfFirst { it == "-p" }
        val port = parts.getOrNull(portIdx + 1)?.toIntOrNull() ?: 443
        val tIdx = parts.indexOf("-t")
        val host = if (tIdx > portIdx && tIdx < parts.size - 1) {
            parts.getOrNull(tIdx + 2) ?: parts.last()
        } else {
            parts.getOrNull(portIdx + 2) ?: parts.last()
        }
 
        // Use proxy-aware repo if bulk config provides a PAC URL
        val repo = bulkProxyResolver?.let { HttpsCertRepository(proxyResolver = it) } ?: certRepo
        val result = repo.fetchCertificate(host, port)
 
        val lines = mutableListOf<String>()
        var warningResult: BulkCommandWarning? = null
        when (result) {
            is HttpsCertResult.Success -> {
                lines.add("  Subject: CN=${result.info.subject.cn}")
                lines.add("  Issuer: CN=${result.info.issuer.cn}")
                // ...
                BulkCommandSuccess(name, cmd, lines, duration)
            }
            is HttpsCertResult.CertExpired -> {
                lines.add("  Subject: CN=${result.chain.firstOrNull()?.subject.cn}")
                lines.add("  Expired: ${result.chain.firstOrNull()?.notAfter}")
                warningResult = BulkCommandWarning(name, cmd, lines, duration)
            }
            is HttpsCertResult.UntrustedChain -> {
                result.chain.forEachIndexed { index, ci ->
                    val tag = when {
                        index == 0 -> "[Leaf]"
                        index == result.chain.size - 1 -> "[Root]"
                        else -> "[Intermediate $index]"
                    }
                    lines.add("      $tag Subject: CN=${ci.subject.cn ?: "(none)"}")
                    lines.add("      Issuer:  CN=${ci.issuer.cn ?: "(none)"}")
                    // ...
                    if (index < result.chain.size - 1) lines.add("          ---")
                }
                warningResult = BulkCommandWarning(name, cmd, lines, duration)
            }
            // ...
        }
 
        when {
            warningResult != null -> warningResult
            result is HttpsCertResult.Success -> BulkCommandSuccess(name, cmd, lines, duration)
            else -> BulkCommandError(name, cmd, lines.lastOrNull() ?: "Unknown error")
        }
    }
}

private suspend fun executeDeviceInfo(name: String, cmd: String): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val repo = SystemInfoRepository(context)
        val di = repo.getDeviceInfo()
        // ... outputs 20+ device properties ...
        BulkCommandSuccess(name, cmd, lines, duration)
    }
}

private suspend fun executeTracert(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val parts = cmd.split(Regex("\\s+"))
        val host = parts.getOrNull(1)
            ?: return@withContext BulkCommandError(name, cmd, "Usage: tracert <host>")
 
        val tIdx = parts.indexOf("-t")
        val maxHops = if (tIdx >= 0 && tIdx < parts.size - 1) {
            parts[tIdx + 1].toIntOrNull()?.takeIf { it > 0 } ?: 30
        } else {
            timeoutMs?.toInt()?.takeIf { it > 0 } ?: 30
        }
 
        // TTL probing loop (same as Traceroute screen)
        for (ttl in 1..maxHops) {
            val proc = Runtime.getRuntime().exec(
                arrayOf("ping", "-c", "1", "-t", ttl.toString(), "-W", "2", host)
            )
            // ... parse ICMP responses ...
        }
 
        BulkCommandSuccess(name, cmd, out, dur)
    }
}

private suspend fun executeGoogleTimeSync(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val repo = GoogleTimeSyncRepository(proxyResolver = bulkProxyResolver)
        val result = repo.fetchGoogleTime()
        // ... format output ...
        when (result) {
            is GoogleTimeSyncResult.Success -> BulkCommandSuccess(name, cmd, lines, dur)
            else -> BulkCommandError(name, cmd, lines.lastOrNull() ?: "Unknown error")
        }
    }
}

private suspend fun executeLanScan(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val repo = LanScannerRepository(context)
        val subnet = repo.getLocalSubnetInfo()
            ?: return@withContext BulkCommandError(name, cmd, "No active WiFi network found")
 
        val devices = mutableListOf<String>()
        val limit = minOf(subnet.numHosts, 256L).toInt()
        for (i in 0 until limit) {
            val ip = repo.longToIp(subnet.baseIp + i.toLong() + 1)
            val rtt = repo.ping(ip)
            if (rtt == null) continue
            val mac = repo.getMacFromArpTable(ip)
            val host = repo.resolveHostname(ip)
            val isRouter = (i == 0)
            // ... build device info string ...
        }
 
        BulkCommandSuccess(name, cmd, out, dur)
    }
}

private suspend fun executeSleep(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val parts = cmd.trim().split(Regex("\\s+"))
        if (parts.size < 2 || parts[1].toIntOrNull() == null) {
            return@withContext BulkCommandError(name, cmd, "Invalid sleep argument. Expected: sleep N (integer)")
        }
 
        var n = parts[1].toInt()
        val actualSeconds = if (n > 3600) 3600 else if (n < 1) {
            return@withContext BulkCommandError(name, cmd, "Sleep duration must be between 1 and 3600 seconds")
        } else n
 
        var remaining = actualSeconds.toLong()
        while (remaining > 0) {
            ensureActive()
            delay(minOf(remaining, 1L))
            remaining--
        }
 
        BulkCommandSuccess(name, cmd, listOf("Slept for $actualSeconds seconds (${durationMs}ms)"), durationMs)
    } catch (e: TimeoutCancellationException) {
        BulkCommandTimeout(name, cmd)
    } catch (e: CancellationException) {
        BulkCommandClosed(name, cmd, emptyList(), System.currentTimeMillis() - t0)
    } catch (e: Exception) {
        BulkCommandError(name, cmd, e.message ?: "Unknown error")
    }
}

private suspend fun executeRaw(name: String, cmd: String, timeoutMs: Long?): BulkCommandResult {
    return withContext(Dispatchers.IO) {
        val t0 = System.currentTimeMillis()
        val parts = cmd.split(Regex("\\s+"))
        val process = Runtime.getRuntime().exec(parts.toTypedArray())
        val output = process.inputStream.bufferedReader().readLines()
        val error = process.errorStream.bufferedReader().readLines()
        val exitCode = process.waitFor()
        val duration = System.currentTimeMillis() - t0
 
        val lines = buildList {
            add("[${timestampFmt.format(LocalDateTime.now())}] $cmd")
            add("[${timestampFmt.format(LocalDateTime.now())}] Exit code: $exitCode (${duration}ms)")
            addAll(output)
            if (error.isNotEmpty()) {
                add("--- stderr ---")
                addAll(error)
            }
        }
        BulkCommandSuccess(name, cmd, lines, duration)
    }
}

private fun parsePortRange(range: String): List<Int> {
    val ports = mutableListOf<Int>()
    range.split(",").forEach { segment ->
        if (segment.contains("-")) {
            val (start, end) = segment.split("-").map { it.trim().toInt() }
            ports.addAll(start..end)
        } else {
            segment.toIntOrNull()?.let { ports.add(it) }
        }
    }
    return ports
}

data class BulkUiState(
    val configLoaded: Boolean = false,
    val configFileName: String? = null,
    val configUri: String? = null,
    val commandCount: Int = 0,
    val configTimeoutMs: Long? = null,
    val csvOutputEnabled: Boolean = false,
    val isExecuting: Boolean = false,
    val currentCommand: String? = null,
    val progress: Float = 0f,
    val results: List<BulkCommandResult> = emptyList(),
    val isFileWriting: Boolean = false,
    val outputFileWritten: Boolean? = null,
    val autoSaved: Boolean = false,
    val autoSavedPath: String? = null,
    val validatedOutputFile: String? = null,
    val validationMessage: ValidationMessage? = null,
    val outputFilePath: String? = null,
)

fun onFileSelected(uri: Uri, fileName: String) {
    viewModelScope.launch {
        var json: String? = null
        var readError: String? = null
        withContext(Dispatchers.IO) {
            try {
                json = context.contentResolver.openInputStream(uri)?.readBytes()?.decodeToString()
            } catch (e: java.io.IOException) {
                readError = e.message ?: "Permission denied or file not found"
                json = ""
            }
        }
        if (json.isNullOrBlank()) {
            _uiState.value = _uiState.value.copy(
                configLoaded = false,
                validationMessage = ValidationMessage.Error(readError ?: "Failed to read config file: $fileName")
            )
            return@launch
        }
 
        try {
            val config = BulkConfigParser.parse(json)
            val csvFromStore = csvOutputEnabled.value
            val (validatedOutputFile, validationMsg) = config.outputFile?.let { rawPath ->
                val validation = BulkConfigParser.validateOutputFile(rawPath)
                // ...
            } ?: (null to null)
 
            _uiState.value = _uiState.value.copy(
                configLoaded = true,
                configFileName = fileName,
                configUri = uri.toString(),
                commandCount = config.commands.size,
                configTimeoutMs = config.timeoutMs,
                csvOutputEnabled = config.outputAsCsv || csvFromStore,
                validatedOutputFile = validatedOutputFile,
                outputFilePath = config.outputFile,
                validationMessage = validationMsg,
                results = emptyList(),
                progress = 0f,
                outputFileWritten = null,
            )
        } catch (e: IllegalArgumentException) {
            _uiState.value = _uiState.value.copy(
                configLoaded = false,
                validationMessage = ValidationMessage.Error("Failed to parse config: ${e.message}"),
            )
        }
    }
}

fun onLoadAndRun(uri: Uri, fileName: String): Job {
    return viewModelScope.launch {
        // 1. Read JSON (same as onFileSelected)
        var json: String? = null
        var readError: String? = null
        withContext(Dispatchers.IO) {
            try {
                json = context.contentResolver.openInputStream(uri)?.readBytes()?.decodeToString()
            } catch (e: java.io.IOException) {
                readError = e.message ?: "Permission denied or file not found"
                json = ""
            }
        }
        if (json.isNullOrBlank()) { /* error state */ return@launch }
 
        // 2. Parse config
        val config = try { BulkConfigParser.parse(json) } catch (e: IllegalArgumentException) { /* error state */ return@launch }
 
        // 3. Update UI state
        _uiState.value = _uiState.value.copy(
            configLoaded = true, configFileName = fileName, configUri = uri.toString(),
            commandCount = config.commands.size, configTimeoutMs = config.timeoutMs,
            csvOutputEnabled = config.outputAsCsv || csvFromStore,
            validatedOutputFile = validatedOutputFile, outputFilePath = config.outputFile,
            validationMessage = validationMsg, results = emptyList(), progress = 0f,
        )
 
        // 4. Execute immediately (same as onRunClicked body)
        cancellationToken.set(false)
        createRunningFile()
        _uiState.value = _uiState.value.copy(isExecuting = true, results = emptyList(), progress = 0f, currentCommand = null)
 
        val commands = config.commands.toList()
        val defaultTimeoutMs = config.timeoutMs ?: 30_000L
        val allResults = mutableListOf<BulkCommandResult>()
 
        val pacSource = config.fileProxyPac ?: config.urlProxyPac
        repository.setupProxyResolver(pacSource, forceLogging = config.logProxy == true)
 
        try {
            commands.forEachIndexed { index, (name, cmd) ->
                if (cancellationToken.get()) { allResults.add(BulkCommandError(name, cmd, "Cancelled")); return@forEachIndexed }
                _uiState.value = _uiState.value.copy(currentCommand = "$name: $cmd", progress = index.toFloat() / total)
                val commandTimeoutMs = BulkConfigParser.extractCommandTimeout(cmd) ?: defaultTimeoutMs
                val result = try {
                    withTimeout(commandTimeoutMs) { repository.executeSingleCommand(name, cmd, commandTimeoutMs) }
                } catch (e: Exception) { null }
                allResults.add(result ?: BulkCommandTimeout(name, cmd))
            }
 
            // Auto-save if output-file is defined
            var autoSavedPath: String? = null
            if (config.outputFile != null) {
                val outputPath = _uiState.value.validatedOutputFile ?: config.outputFile
                val saved = autoSaveResults(outputPath, allResults)
                if (saved) autoSavedPath = outputPath
            }
 
            _uiState.value = _uiState.value.copy(
                isExecuting = false, results = allResults, progress = 1f, currentCommand = null,
                autoSaved = autoSavedPath != null, autoSavedPath = autoSavedPath,
            )
        } finally {
            repository.clearProxyResolver()
            deleteRunningFile()
        }
    }
}

fun onRunClicked() {
    if (_uiState.value.isExecuting) return
 
    cancellationToken.set(false)
    createRunningFile()
    _uiState.value = _uiState.value.copy(isExecuting = true, results = emptyList(), progress = 0f, currentCommand = null)
 
    executionJob = viewModelScope.launch {
        try {
            val configUriStr = _uiState.value.configUri
            if (configUriStr == null) { _uiState.value = _uiState.value.copy(isExecuting = false); return@launch }
 
            // Re-read config from stored URI
            val config = withContext(Dispatchers.IO) {
                val json = context.contentResolver.openInputStream(android.net.Uri.parse(configUriStr))?.readBytes()?.decodeToString() ?: ""
                BulkConfigParser.parse(json)
            }
 
            val commands = config.commands.toList()
            val total = commands.size
            val defaultTimeoutMs = config.timeoutMs ?: 30_000L
            val allResults = mutableListOf<BulkCommandResult>()
 
            val pacSource = config.fileProxyPac ?: config.urlProxyPac
            repository.setupProxyResolver(pacSource, forceLogging = config.logProxy == true)
 
            commands.forEachIndexed { index, (name, cmd) ->
                if (cancellationToken.get()) { allResults.add(BulkCommandError(name, cmd, "Cancelled")); return@forEachIndexed }
                _uiState.value = _uiState.value.copy(currentCommand = "$name: $cmd", progress = index.toFloat() / total)
                val commandTimeoutMs = BulkConfigParser.extractCommandTimeout(cmd) ?: defaultTimeoutMs
                val result = try {
                    withTimeout(commandTimeoutMs) { repository.executeSingleCommand(name, cmd, commandTimeoutMs) }
                } catch (e: Exception) { null }
                allResults.add(result ?: BulkCommandTimeout(name, cmd))
            }
 
            // Auto-save if output-file is defined
            var autoSavedPath: String? = null
            if (config.outputFile != null) {
                val outputPath = _uiState.value.validatedOutputFile ?: config.outputFile
                val saved = autoSaveResults(outputPath, allResults)
                if (saved) autoSavedPath = outputPath
            }
 
            _uiState.value = _uiState.value.copy(
                isExecuting = false, results = allResults, progress = 1f, currentCommand = null,
                autoSaved = autoSavedPath != null, autoSavedPath = autoSavedPath,
            )
        } finally {
            repository.clearProxyResolver()
            deleteRunningFile()
        }
    }
}

private fun generateOutputContent(results: List<BulkCommandResult>): String {
    val total = results.size
    val successCount = results.count { it is BulkCommandSuccess }
    val errorCount = results.count { it is BulkCommandError }
    val timeoutCount = results.count { it is BulkCommandTimeout }
    val closedCount = results.count { it is BulkCommandClosed }
    val warningCount = results.count { it is BulkCommandWarning }
    val totalDurationMs = results
        .filterIsInstance<BulkCommandSuccess>().sumOf { it.durationMs }
        .plus(results.filterIsInstance<BulkCommandClosed>().sumOf { it.durationMs })
 
    val lines = mutableListOf<String>()
 
    // Header
    lines.add("══════════════════════════════════════════════════════")
    lines.add("  BULK ACTIONS — OUTPUT REPORT")
    lines.add("══════════════════════════════════════════════════════")
    lines.add("  Generated: ${SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US).format(Date())}")
    lines.add("══════════════════════════════════════════════════════")
    lines.add("")
 
    // Individual results
    lines.add("── COMMAND RESULTS ──────────────────────────────────")
    lines.add("")
    results.forEachIndexed { index, result ->
        when (result) {
            is BulkCommandSuccess -> {
                lines.add("[${index + 1}] ${result.commandName}: ${result.command}")
                lines.add("    Status: SUCCESS (${result.durationMs}ms)")
                result.outputLines.forEach { line -> lines.add("  $line") }
            }
            is BulkCommandError -> {
                lines.add("[${index + 1}] ${result.commandName}: ${result.command}")
                lines.add("    Status: ERROR")
                lines.add("      ${result.errorMessage}")
            }
            is BulkCommandTimeout -> {
                lines.add("[${index + 1}] ${result.commandName}: ${result.command}")
                lines.add("    Status: TIMEOUT")
            }
            is BulkCommandClosed -> {
                lines.add("[${index + 1}] ${result.commandName}: ${result.command}")
                lines.add("    Status: CLOSED (${result.durationMs}ms)")
                result.outputLines.forEach { line -> lines.add("     $line") }
            }
            is BulkCommandWarning -> {
                lines.add("[${index + 1}] ${result.commandName}: ${result.command}")
                lines.add("    Status: WARNING (${result.durationMs}ms)")
                result.outputLines.forEach { line -> lines.add("      $line") }
            }
        }
        lines.add("")
    }
 
    // Summary table
    val successPct = if (total > 0) String.format("%5.1f%%", successCount.toFloat() / total * 100) else "     0.0%"
    // ... similar for error, timeout, closed, warning ...
 
    lines.add("── SUMMARY ──────────────────────────────────────────")
    lines.add("")
    lines.add("     ┌───────────────────────┬──────────┬─────────────┐")
    lines.add("     │ Metric                   │ Count       │ Percentage     │")
    lines.add("     ├───────────────────────┼──────────┼─────────────┤")
    lines.add("     │ Total commands           │ ${total.toString().padStart(6)} │ ${"100.0%".padStart(7)} │")
    // ... rows for SUCCESS, ERROR, TIMEOUT, CLOSED, WARNING ...
    lines.add("     └───────────────────────┴──────────┴─────────────┘")
    lines.add("")
    lines.add("  Progress: [$successBar] $successCount/$total")
    lines.add("")
    lines.add("══════════════════════════════════════════════════════")
 
    return lines.joinToString("\n")
}

private fun generateCsvContent(results: List<BulkCommandResult>): String {
    val lines = mutableListOf<String>()
    lines.add("cmdname,command,time,result")
    results.forEach { result ->
        when (result) {
            is BulkCommandSuccess -> {
                val time = SimpleDateFormat("HH:mm:ss", Locale.US).format(Date())
                val resultText = result.outputLines.joinToString("; ")
                lines.add("${result.commandName},${result.command},${time},${resultText}")
            }
            is BulkCommandError -> {
                val time = SimpleDateFormat("HH:mm:ss", Locale.US).format(Date())
                lines.add("${result.commandName},${result.command},${time},${result.errorMessage}")
            }
            is BulkCommandTimeout -> {
                val time = SimpleDateFormat("HH:mm:ss", Locale.US).format(Date())
                lines.add("${result.commandName},${result.command},${time},TIMEOUT")
            }
            is BulkCommandClosed -> {
                val time = SimpleDateFormat("HH:mm:ss", Locale.US).format(Date())
                val resultText = result.outputLines.joinToString("; ")
                lines.add("${result.commandName},${result.command},${time},${resultText}")
            }
            is BulkCommandWarning -> {
                val time = SimpleDateFormat("HH:mm:ss", Locale.US).format(Date())
                val resultText = result.outputLines.joinToString("; ")
                lines.add("${result.commandName},${result.command},${time},WARNING")
            }
        }
    }
    return lines.joinToString("\n")
}

private suspend fun autoSaveResults(outputPath: String, results: List<BulkCommandResult>): Boolean {
    return try {
        val success = writeViaSAF(outputPath, results)
        if (!success) writeDirect(outputPath, results)
        else true
    } catch (_: Exception) {
        false
    }
}
 
private suspend fun writeViaSAF(path: String, results: List<BulkCommandResult>): Boolean {
    val uri = android.net.Uri.parse(path)
    // Plain file paths (not file:// URIs) skip SAF and fall through to writeDirect
    if (uri == null) return false
    val csvEnabled = csvOutputEnabled.value
    return try {
        context.contentResolver.openOutputStream(uri)?.use { outputStream ->
            val content = if (csvEnabled) generateCsvContent(results) else generateOutputContent(results)
            outputStream.write(content.toByteArray())
            true
        } ?: false
    } catch (_: Exception) { false }
}
 
private suspend fun writeDirect(path: String, results: List<BulkCommandResult>): Boolean {
    return try {
        withContext(Dispatchers.IO) {
            val file = File(path)
            file.parentFile?.mkdirs()
            val csvEnabled = csvOutputEnabled.value
            val content = if (csvEnabled) generateCsvContent(results) else generateOutputContent(results)
            file.writeText(content)
        }
        true
    } catch (e: Exception) { false }
}

private val runningFile: File by lazy {
    File(context.filesDir, ".running-tasks")
}
 
private fun createRunningFile() {
    viewModelScope.launch(Dispatchers.IO) {
        try {
            if (runningFile.parentFile?.exists() != true) runningFile.parentFile?.mkdirs()
            runningFile.createNewFile()
        } catch (_: Exception) { /* Silently ignore */ }
    }
}
 
private fun deleteRunningFile() {
    viewModelScope.launch(Dispatchers.IO) {
        try { runningFile.delete() } catch (_: Exception) { /* Silently ignore */ }
    }
}

private val csvDataStore: DataStore<Preferences> by lazy {
    context.bulkActionsCsvDataStore
}
val csvOutputEnabled: StateFlow<Boolean> = csvDataStore.data.map { prefs ->
    prefs[booleanPreferencesKey("csv_output_enabled")] ?: false
}.stateIn(viewModelScope, kotlinx.coroutines.flow.SharingStarted.WhileSubscribed(5000), false)
 
fun toggleCsvOutput() {
    viewModelScope.launch {
        val current = csvDataStore.data.first()[booleanPreferencesKey("csv_output_enabled")] ?: false
        csvDataStore.edit { it[booleanPreferencesKey("csv_output_enabled")] = !current }
    }
}

companion object {
    fun factory(context: Context): ViewModelProvider.Factory =
        object : ViewModelProvider.Factory {
               @Suppress("UNCHECKED_CAST")
            override fun <T : ViewModel> create(modelClass: Class<T>): T {
                // Set app context for BulkConfigParser to use private dir path expansion
                BulkConfigParser.appContext = context.applicationContext
                return BulkActionsViewModel(
                    context = context.applicationContext,
                    repository = BulkActionsRepository(context.applicationContext),
                ) as T
            }
        }
}

┌─────────────────────────────────────────────────────────┐
│ ADB Intent (configUri + autoRun)                        │
│                                                         │
│ configUri != null && autoRun == true                    │
│   → LaunchedEffect(configUri, autoRun)                  │
│     → viewModel.onLoadAndRun(uri, fileName)             │
│       → parse + execute in one coroutine                │
│                                                         │
│ configUri != null && autoRun == false                   │
│   → LaunchedEffect(configUri, autoRun)                  │
│     → manual parse + update UI state only               │
│                                                         │
│ configUri == null (manual UI)                           │
│   → User taps "Load JSON Config"                        │
│     → filePickerLauncher.launch("application/json")     │
│       → viewModel.onFileSelected(uri, fileName)         │
│         → parse + update UI state only                  │
│                                                         │
│   → User taps "Run All Commands"                        │
│     → viewModel.onRunClicked()                          │
│       → re-read config from URI + execute               │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────┐
│ [🖥 Terminal] Bulk Actions                │
├─────────────────────────────────────────┤
│ [📂 Load JSON Config                   ]  │
├─────────────────────────────────────────┤
│ ☑ CSV output                              │
├─────────────────────────────────────────┤
│ ┌─ Config loaded ───────────────────┐     │
│ │ 5 command(s)                        │     │
│ │ ✓ output-file: /data/.../output.txt │     │
│ │ timeout: 300s                       │     │
│ └───────────────────────────────────┘     │
├─────────────────────────────────────────┤
│ [▶ Run All Commands] / [⏹ Stop]           │
├─────────────────────────────────────────┤
│ ████████████████████░░░░░░░░ 60%          │ ← progress bar
│ dig-ns: dig @1.1.1.1 google.com            │ ← current command
├─────────────────────────────────────────┤
│ Results (3/5)          [Clear]             │
│ ┌─ Result items ───────────────────┐       │
│ │ ✓ ping-google (SUCCESS)            │       │
│ │ ✓ dig-ns (SUCCESS)                 │       │
│ │ ✗ checkcert (ERROR)                │       │
│ └──────────────────────────────────┘       │
├─────────────────────────────────────────┤
│ [📄 Write to File]                        │
├─────────────────────────────────────────┤
│ ┌─ File saved to: /data/... ──────┐       │
│ │ ✓ File saved to: /data/...       │       │
│ └────────────────────────────────┘       │
└─────────────────────────────────────────┘

@Composable
private fun ResultItem(result: BulkCommandResult, configTimeoutMs: Long? = null) {
    val (icon, statusText, statusColor) = when (result) {
        is BulkCommandSuccess ->
            Triple(Icons.Filled.CheckCircle, "SUCCESS", MaterialTheme.colorScheme.secondary)
        is BulkCommandError ->
            Triple(Icons.Filled.Error, "ERROR", MaterialTheme.colorScheme.error)
        is BulkCommandTimeout ->
            Triple(Icons.Filled.Close, "TIMEOUT", MaterialTheme.colorScheme.tertiary)
        is BulkCommandClosed ->
            Triple(Icons.Filled.Warning, "CLOSED", MaterialTheme.colorScheme.error)
        is BulkCommandWarning ->
            Triple(Icons.Filled.Warning, "WARNING", MaterialTheme.colorScheme.tertiary)
    }
    // ... display result ...
}

1715340600000|file:///data/user/0/.../config.json|blkacts_single_ping_success.json

private fun deserialise(raw: String): List<BulkHistoryEntry> =
    raw.split(ENTRY_SEP)
        .filter { it.isNotBlank() }
        .mapNotNull { line ->
            val parts = line.split(FIELD_SEP)
            if (parts.size >= 3) {
                parts.getOrNull(0)?.toLongOrNull()?.let { ts ->
                    BulkHistoryEntry(timestamp = ts, uri = parts[1], fileName = parts[2])
                }
            } else null
        }
        .take(MAX_ENTRIES)

User selects JSON config (or ADB intent triggers onLoadAndRun)
         │
         ├─ Read file: contentResolver.openInputStream(uri)?.readBytes()
         ├─ Decode: decodeToString()
         ├─ Parse: BulkConfigParser.parse(json)
         │      │
         │      ├─ Extract: output-file, timeout, outputAsCsv
         │      ├─ Extract: url-proxypac / file-proxypac (mutually exclusive)
         │      ├─ Expand tilde: ~/ → filesDir
         │      ├─ Validate output-file: create dirs, test write
         │      ├─ Validate file-proxypac: exists + canRead
         │      └─ Extract run object → Map<commandName, commandString>
         │
         ├─ Update UI state: configLoaded, commandCount, configTimeoutMs
         │
         └─ User taps "Run All Commands" (or auto-run)
                │
                ├─ cancellationToken.set(false)
                ├─ createRunningFile()
                ├─ repository.setupProxyResolver(pacSource, forceLogging)
                │
                └─ forEachIndexed { index, (name, cmd) ->
                         if (cancellationToken.get()) → BulkCommandError("Cancelled")
                         │
                         ├─ commandTimeoutMs = extractCommandTimeout(cmd) ?: defaultTimeoutMs
                         ├─ withTimeout(commandTimeoutMs) {
                         │       repository.executeSingleCommand(name, cmd, commandTimeoutMs)
                         │              │
                         │              └─ when (prefix) {
                         │                      "ping" → Runtime.exec("ping -c N -W T host")
                         │                      "dig" → digRepo.resolve(server, fqdn)
                         │                      "ntp" → ntpRepo.query(pool)
                         │                      "port-scan" → Socket.connect(port, timeout) x N
                         │                      "checkcert" → certRepo.fetchCertificate(host, port)
                         │                      "device-info" → SystemInfoRepository.getDeviceInfo()
                         │                      "tracert" → TTL probing loop
                         │                      "google-timesync" → GoogleTimeSyncRepository.fetchGoogleTime()
                         │                      "lan-scan" → LanScannerRepository subnet scan
                         │                      "sleep" → delay(seconds)
                         │                      else → Runtime.exec(parts)
                         │                  }
                         │              }
                         │              → BulkCommandSuccess / Error / Timeout / Warning / Closed
                         │
                         └─ allResults.add(finalResult)
                         └─ _uiState.value.copy(currentCommand, progress)
                        }
                │
                ├─ if (config.outputFile != null) → autoSaveResults(outputPath, allResults)
                │      │
                │      └─ writeViaSAF(path) → contentResolver.openOutputStream(uri)
                │             OR
                │      writeDirect(path) → File(path).writeText(content)
                │
                ├─ repository.clearProxyResolver()
                └─ deleteRunningFile()