diff --git a/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt b/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt index f38f87922e..3ac740ebc2 100644 --- a/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt +++ b/app/src/main/java/com/droiddeck/launcher/DeckyMenu.kt @@ -7,6 +7,7 @@ import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue import com.droiddeck.launcher.runtime.DeckyManager import com.droiddeck.launcher.session.SessionState +import java.io.File /** * Decky Loader's state in the launcher: what is installed, the releases on offer and an install @@ -51,4 +52,21 @@ internal class DeckyMenu(private val activity: android.app.Activity, private val } }, "install-decky").start() } + + fun importPluginZip(archive: File) { + if (deckyStage != null || SessionState.running || deckyInstalled == null) return + deckyStage = "Starting plugin import…"; deckyPercent = -1 + Thread({ + val problem = runCatching { + DeckyManager.installPluginZip(activity, archive) { label, value -> + ui.post { deckyStage = label; deckyPercent = value } + } + }.getOrElse { error -> "Plugin import failed: ${error.message ?: error.javaClass.simpleName}" } + ui.post { + deckyStage = null; deckyPercent = -1 + val message = problem ?: "Plugin installed. Restart Steam to load it." + android.widget.Toast.makeText(activity, message, android.widget.Toast.LENGTH_LONG).show() + } + }, "import-decky-plugin").start() + } } diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index 81a235bb2a..0414ba2b07 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -186,6 +186,9 @@ class MainActivity : ComponentActivity() { private val pickAndroidDriver = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> if (r.resultCode == RESULT_OK) InAppFilePicker.pickedUri(r.data)?.let { drivers.importDriver(it, linux = false) } } + private val pickDeckyPluginZip = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> + if (r.resultCode == RESULT_OK) InAppFilePicker.pickedFile(r.data)?.let { decky.importPluginZip(it) } + } private val pickAnyDriver = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { r -> if (r.resultCode == RESULT_OK) InAppFilePicker.pickedUri(r.data)?.let { drivers.importDriver(it, linux = null) } } @@ -1242,6 +1245,9 @@ class MainActivity : ComponentActivity() { decky.deckyInstalled = null decky.deckySupervisor = false }, + onPickDeckyPluginZip = { + pickDeckyPluginZip.launch(InAppFilePicker.buildIntent(this, ZIP_EXT, "Choose a Decky plugin ZIP")) + }, onDismiss = { settingsMode = null }, ), ) diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt index ebe1b3dd00..7203751e53 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DeckyManager.kt @@ -5,8 +5,15 @@ import android.content.Context import android.util.Log import com.droiddeck.launcher.core.Downloader import com.droiddeck.launcher.session.SessionState +import com.droiddeck.launcher.core.ArchivePaths +import java.io.BufferedInputStream +import java.io.FileOutputStream import java.io.File +import java.io.FileInputStream +import java.util.UUID +import java.util.zip.ZipInputStream import org.json.JSONArray +import org.json.JSONObject /** Optional Decky Loader installation for the ARM64 Linux guest. */ object DeckyManager { @@ -136,6 +143,123 @@ object DeckyManager { return null } + /** Imports a Decky distribution ZIP into homebrew/plugins for the next Steam session. */ + fun installPluginZip(context: Context, archive: File, progress: (String, Int) -> Unit): String? { + if (SessionState.running) return "Stop the active session before installing a plugin" + if (installed(context) == null) return "Install Decky Loader before importing a plugin" + if (!archive.isFile || !archive.canRead()) return "Could not read the selected ZIP file" + + val plugins = File(LinuxRuntime.rootDir(context), "root/homebrew/plugins") + if (!plugins.exists() && !plugins.mkdirs()) return "Could not create the Decky plugins directory" + val staging = File(plugins, ".droiddeck-import-${UUID.randomUUID()}") + val backupSuffix = ".droiddeck-backup-${UUID.randomUUID()}" + try { + staging.mkdirs() + progress("Extracting plugin ZIP", -1) + extractPluginZip(archive, staging) + val roots = staging.listFiles()?.filter { it.isDirectory } ?: emptyList() + if (roots.size != 1 || staging.listFiles()?.size != 1) return "Plugin ZIP must contain one top-level plugin folder" + val plugin = roots.single() + if (!File(plugin, "plugin.json").isFile || !File(plugin, "package.json").isFile || !File(plugin, "dist/index.js").isFile) { + return "Plugin ZIP is missing plugin.json, package.json, or dist/index.js" + } + val name = JSONObject(File(plugin, "plugin.json").readText()).getString("name") + require(name.isNotBlank()) { "Plugin name is missing" } + val metadata = JSONObject(File(plugin, "package.json").readText()) + downloadRemoteBinaries(metadata, plugin, progress) + if (SessionState.running) return "A session started during installation; stop it before installing a plugin" + + DeckyPluginInstall.activate(plugin, plugins, name, + File(plugins.parentFile, "settings/loader.json"), backupSuffix) + progress("Plugin installed · restart Steam to load it", 100) + return null + } catch (e: Exception) { + Log.w(TAG, "plugin ZIP import", e) + return e.message?.takeIf { it.isNotBlank() } ?: "Plugin ZIP installation failed" + } finally { + staging.deleteRecursively() + } + } + + private fun extractPluginZip(archive: File, destination: File) { + var totalBytes = 0L + var entries = 0 + val seen = HashSet() + ZipInputStream(BufferedInputStream(FileInputStream(archive))).use { zip -> + while (true) { + val entry = zip.nextEntry ?: break + entries++ + require(entries <= 10_000) { "Plugin ZIP contains too many entries" } + val relative = entry.name.replace('\\', '/') + require(relative.isNotBlank() && !relative.startsWith('/')) { "Plugin ZIP contains an invalid path" } + require(seen.add(relative)) { "Plugin ZIP contains duplicate paths" } + val output = ArchivePaths.inside(destination, relative) + ?: throw IllegalArgumentException("Plugin ZIP contains an unsafe path") + if (entry.isDirectory) { + require(output.mkdirs() || output.isDirectory) { "Could not create plugin folder" } + } else { + require(output.parentFile?.let { it.mkdirs() || it.isDirectory } == true) { "Could not create plugin folder" } + FileOutputStream(output).use { out -> + val buffer = ByteArray(64 * 1024) + while (true) { + val read = zip.read(buffer) + if (read < 0) break + totalBytes += read + require(totalBytes <= MAX_PLUGIN_ZIP_BYTES) { "Plugin ZIP expands beyond the 1 GiB limit" } + out.write(buffer, 0, read) + } + } + // Decky distributions place plugin executables under bin/. Java's ZIP reader + // does not expose Unix mode bits, so restore execution on those payload files. + if (relative.split('/').dropLast(1).any { it == "bin" } && !output.setExecutable(true, false)) { + throw IllegalStateException("Could not mark bundled plugin binary executable") + } + } + zip.closeEntry() + } + } + } + + private fun downloadRemoteBinaries(metadata: JSONObject, plugin: File, progress: (String, Int) -> Unit) { + val binaries = metadata.optJSONArray("remote_binary") ?: return + val bin = File(plugin, "bin") + for (i in 0 until binaries.length()) { + val binary = binaries.optJSONObject(i) ?: throw IllegalArgumentException("Invalid remote_binary entry") + val name = binary.optString("name") + val url = binary.optString("url") + val hash = binary.optString("sha256hash") + require(name.isNotBlank() && name != "." && name != ".." && !name.contains('/') && !name.contains('\\')) { "Invalid remote binary name" } + require(url.startsWith("https://")) { "Remote binary URL must use HTTPS" } + require(hash.matches(Regex("(?i)[0-9a-f]{64}"))) { "Remote binary $name has an invalid SHA-256 hash" } + require(bin.mkdirs() || bin.isDirectory) { "Could not create plugin bin directory" } + val temp = File(bin, ".$name.download") + progress("Downloading plugin binary · $name", -1) + if (!Downloader.downloadFile(url, temp, false) { fraction -> + progress("Downloading plugin binary · $name", if (fraction < 0) -1 else (fraction * 100).toInt().coerceIn(0, 100)) + }) { + temp.delete() + throw IllegalStateException("Could not download plugin binary $name") + } + if (!hash.equals(Hashes.sha256(temp), ignoreCase = true)) { + temp.delete() + throw IllegalStateException("Plugin binary checksum mismatch · $name") + } + if (!temp.setExecutable(true, false)) { + temp.delete() + throw IllegalStateException("Could not mark plugin binary executable · $name") + } + val target = File(bin, name) + if (target.exists() && !target.delete()) { + temp.delete() + throw IllegalStateException("Could not replace plugin binary · $name") + } + if (!temp.renameTo(target)) { + temp.delete() + throw IllegalStateException("Could not install plugin binary · $name") + } + } + } + fun uninstall(context: Context, wipeData: Boolean) { val root = LinuxRuntime.rootDir(context) setSupervisorEnabled(context, false) @@ -154,4 +278,6 @@ object DeckyManager { h[4] == 2.toByte() && h[5] == 1.toByte() && (h[18].toInt() and 255) + ((h[19].toInt() and 255) shl 8) == machine } }.getOrDefault(false) + + private const val MAX_PLUGIN_ZIP_BYTES = 1024L * 1024L * 1024L } diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/DeckyPluginInstall.kt b/app/src/main/java/com/droiddeck/launcher/runtime/DeckyPluginInstall.kt new file mode 100644 index 0000000000..1affde9dda --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/runtime/DeckyPluginInstall.kt @@ -0,0 +1,52 @@ +package com.droiddeck.launcher.runtime + +import java.io.File +import org.json.JSONArray +import org.json.JSONObject + +/** Offline equivalent of Decky's identity-based replacement and loader settings update. */ +internal object DeckyPluginInstall { + fun activate(staged: File, plugins: File, name: String, settingsFile: File, backupSuffix: String) { + val settings = if (settingsFile.exists()) JSONObject(settingsFile.readText()) else JSONObject() + val existing = plugins.listFiles().orEmpty().filter { folder -> + folder.isDirectory && !folder.name.startsWith(".droiddeck-") && runCatching { + JSONObject(File(folder, "plugin.json").readText()).getString("name") == name + }.getOrDefault(false) + } + val target = File(plugins, staged.name) + require(!target.exists() || target in existing) { "Plugin folder belongs to another plugin" } + val order = settings.optJSONArray("pluginOrder") ?: JSONArray(plugins.listFiles().orEmpty() + .filter { it.isDirectory && !it.name.startsWith(".droiddeck-") } + .mapNotNull { runCatching { JSONObject(File(it, "plugin.json").readText()).getString("name") }.getOrNull() } + .distinct()) + if ((0 until order.length()).none { order.optString(it) == name }) order.put(name) + settings.put("pluginOrder", order) + // Decky's reinstall removes these flags while retaining the plugin's order and data. + for (key in listOf("frozenPlugins", "hiddenPlugins", "disabled_plugins")) { + val values = settings.optJSONArray(key) ?: continue + settings.put(key, JSONArray((0 until values.length()).map { values.get(it) }.filter { it != name })) + } + settingsFile.parentFile?.mkdirs() + val pending = File(settingsFile.parentFile, "loader.json$backupSuffix") + val backups = mutableListOf>() + var activated = false + try { + pending.writeText(settings.toString(4)) + for (old in existing) { + val backup = File(plugins, ".droiddeck-backup-${old.name}$backupSuffix") + check(old.renameTo(backup)) { "Could not preserve the existing plugin" } + backups.add(old to backup) + } + check(staged.renameTo(target)) { "Could not activate the imported plugin" } + activated = true + check(pending.renameTo(settingsFile)) { "Could not update Decky plugin settings" } + } catch (error: Exception) { + if (activated) target.deleteRecursively() + for ((old, backup) in backups.asReversed()) check(backup.renameTo(old)) { "Could not restore the existing plugin" } + throw error + } finally { + pending.delete() + } + backups.forEach { (_, backup) -> backup.deleteRecursively() } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt index 09bcfa0ec8..714b6590ef 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -8,7 +8,6 @@ import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.size import androidx.compose.material3.AlertDialog import androidx.compose.material3.MaterialTheme -import androidx.compose.material3.Switch import androidx.compose.material3.Text import androidx.compose.material3.LinearProgressIndicator import androidx.compose.material3.TextButton @@ -155,6 +154,7 @@ class ModeSettingsActions( val onDeckyCheck: () -> Unit = {}, val onDeckyEnabled: (Boolean) -> Unit = {}, val onDeckyUninstall: () -> Unit = {}, + val onPickDeckyPluginZip: () -> Unit = {}, val onDismiss: () -> Unit, ) @@ -324,15 +324,22 @@ fun ModeSettingsPage(s: ModeSettings, a: ModeSettingsActions) { ) { confirmDeckyRemoval = true } } } - if (s.deckyInstalled != null) SettingsRow( - stringResource(R.string.mode_decky), + if (s.deckyInstalled != null) ToggleRow( + host, "decky-enabled", stringResource(R.string.mode_decky), if (s.deckyEnabled) stringResource(R.string.mode_decky_on) else stringResource(R.string.mode_decky_off), + s.deckyEnabled, + enabled = !s.deckySessionRunning && s.deckyStage == null, + onChange = a.onDeckyEnabled, + ) + SettingsRow( + "Plugins", + "Install a plugin ZIP for the next Steam session.", ) { - Switch( - checked = s.deckyEnabled, - onCheckedChange = a.onDeckyEnabled, - enabled = !s.deckySessionRunning && s.deckyStage == null, + SecondaryButton( + if (s.deckyStage?.startsWith("Downloading plugin binary") == true) "Downloading…" else "Install from ZIP", + enabled = s.deckyInstalled != null && s.deckyStage == null && !s.deckySessionRunning, + onClick = a.onPickDeckyPluginZip, ) } if (s.deckyStage != null && s.deckyPercent >= 0) { diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/DeckyPluginInstallTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/DeckyPluginInstallTest.kt new file mode 100644 index 0000000000..4d65572a90 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/runtime/DeckyPluginInstallTest.kt @@ -0,0 +1,84 @@ +package com.droiddeck.launcher.runtime + +import java.io.File +import org.json.JSONObject +import org.junit.Assert.* +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner + +@RunWith(RobolectricTestRunner::class) +class DeckyPluginInstallTest { + @get:Rule val temporary = TemporaryFolder() + private fun plugin(parent: File, folder: String, name: String): File = File(parent, folder).apply { + mkdirs(); File(this, "plugin.json").writeText(JSONObject().put("name", name).toString()) + } + + @Test fun renamedFolderReplacesByIdentityAndPreservesDataAndOrder() { + val home = temporary.newFolder() + val plugins = File(home, "plugins").apply { mkdirs() } + val old = plugin(plugins, "old-folder", "Unifideck") + val data = File(home, "data/old-folder/save").apply { parentFile.mkdirs(); writeText("keep") } + val settings = File(home, "settings/loader.json").apply { + parentFile.mkdirs() + writeText("""{"pluginOrder":["Other","Unifideck"],"hiddenPlugins":["Unifideck","Other"],"disabled_plugins":["Unifideck"],"store":2}""") + } + val staged = plugin(temporary.newFolder(), "Unifideck", "Unifideck") + DeckyPluginInstall.activate(staged, plugins, "Unifideck", settings, ".test") + assertFalse(old.exists()) + assertTrue(File(plugins, "Unifideck/plugin.json").exists()) + assertEquals("keep", data.readText()) + val state = JSONObject(settings.readText()) + assertEquals("[\"Other\",\"Unifideck\"]", state.getJSONArray("pluginOrder").toString()) + assertEquals("[\"Other\"]", state.getJSONArray("hiddenPlugins").toString()) + assertEquals(0, state.getJSONArray("disabled_plugins").length()) + assertEquals(2, state.getInt("store")) + } + + @Test fun newImportAppendsOnceAndReimportKeepsItsPosition() { + val plugins = temporary.newFolder() + val settings = File(temporary.newFolder(), "loader.json").apply { writeText("""{"pluginOrder":["Other"]}""") } + repeat(2) { + DeckyPluginInstall.activate(plugin(temporary.newFolder(), "Unifideck", "Unifideck"), plugins, "Unifideck", settings, ".test") + } + assertEquals("[\"Other\",\"Unifideck\"]", JSONObject(settings.readText()).getJSONArray("pluginOrder").toString()) + } + + @Test fun conflictingFolderLeavesInstalledPluginAndSettingsUntouched() { + val plugins = temporary.newFolder() + plugin(plugins, "Unifideck", "Other") + val settings = File(temporary.newFolder(), "loader.json").apply { writeText("{}") } + try { + DeckyPluginInstall.activate(plugin(temporary.newFolder(), "Unifideck", "Unifideck"), plugins, "Unifideck", settings, ".test") + fail("Expected conflicting identity to fail") + } catch (_: IllegalArgumentException) {} + assertEquals("{}", settings.readText()) + assertEquals("Other", JSONObject(File(plugins, "Unifideck/plugin.json").readText()).getString("name")) + } + @Test fun firstLoaderSettingsIncludeExistingPlugins() { + val plugins = temporary.newFolder() + plugin(plugins, "Other", "Other") + val settings = File(temporary.newFolder(), "loader.json") + DeckyPluginInstall.activate(plugin(temporary.newFolder(), "Unifideck", "Unifideck"), plugins, "Unifideck", settings, ".test") + assertEquals("[\"Other\",\"Unifideck\"]", JSONObject(settings.readText()).getJSONArray("pluginOrder").toString()) + } + + @Test fun activationFailureRestoresPreviousPlugin() { + val plugins = temporary.newFolder() + val old = plugin(plugins, "Unifideck", "Unifideck") + File(old, "old-version").writeText("keep") + // An empty staged directory makes the plugin activation fail after backing up the old one. + val staged = plugin(temporary.newFolder(), "Unifideck", "Unifideck") + staged.deleteRecursively() + val settings = File(temporary.newFolder(), "loader.json").apply { writeText("{}") } + try { + DeckyPluginInstall.activate(staged, plugins, "Unifideck", settings, ".test") + fail("Expected activation to fail") + } catch (_: IllegalStateException) {} + assertEquals("keep", File(old, "old-version").readText()) + assertEquals("{}", settings.readText()) + } + +}