From 2f30dbb4c6c3279fecdbc94f7999a07e8e23ea8d Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 19:38:04 -0500 Subject: [PATCH 01/60] feat: add Nexus Mods OAuth authentication --- app/src/main/AndroidManifest.xml | 24 + .../main/java/app/gamenative/MainActivity.kt | 69 +- app/src/main/java/app/gamenative/PluviaApp.kt | 2 + .../app/gamenative/mods/NexusApiClient.kt | 178 ++++-- .../app/gamenative/mods/NexusAuthManager.kt | 593 ++++++++++++++++++ .../gamenative/mods/NexusDownloadLinkInbox.kt | 178 +++++- .../gamenative/mods/NexusIntegrationStatus.kt | 7 +- .../gamenative/mods/NexusOAuthAccessToken.kt | 115 ++++ .../app/gamenative/mods/NexusOAuthModels.kt | 84 +++ .../app/gamenative/mods/NexusOAuthService.kt | 191 ++++++ .../app/gamenative/mods/NexusOAuthStorage.kt | 240 +++++++ .../mods/NexusPendingDownloadStore.kt | 7 + .../app/gamenative/mods/NexusUrlParser.kt | 150 ++++- .../service/NexusModImportService.kt | 134 +++- .../ui/component/dialog/NexusModsDialog.kt | 293 ++++++++- .../dialog/NexusOAuthAccountSection.kt | 170 +++++ .../screen/auth/NexusOAuthBrowserLauncher.kt | 29 + .../screen/auth/NexusOAuthCallbackActivity.kt | 84 +++ .../screen/auth/NexusOAuthCallbackContract.kt | 38 ++ app/src/main/res/values-da/strings.xml | 23 + app/src/main/res/values-de/strings.xml | 23 + app/src/main/res/values-es/strings.xml | 23 + app/src/main/res/values-fr/strings.xml | 23 + app/src/main/res/values-it/strings.xml | 23 + app/src/main/res/values-ja/strings.xml | 23 + app/src/main/res/values-ko/strings.xml | 23 + app/src/main/res/values-pl/strings.xml | 23 + app/src/main/res/values-pt-rBR/strings.xml | 23 + app/src/main/res/values-ro/strings.xml | 23 + app/src/main/res/values-ru/strings.xml | 23 + app/src/main/res/values-uk/strings.xml | 23 + app/src/main/res/values-zh-rCN/strings.xml | 23 + app/src/main/res/values-zh-rTW/strings.xml | 23 + app/src/main/res/values/strings.xml | 23 + app/src/main/res/values/themes.xml | 8 + .../app/gamenative/mods/NexusApiClientTest.kt | 110 +++- .../mods/NexusDownloadLinkInboxTest.kt | 187 +++++- .../mods/NexusOAuthAccessTokenTest.kt | 75 +++ .../mods/NexusOAuthControllerTest.kt | 517 +++++++++++++++ .../gamenative/mods/NexusOAuthServiceTest.kt | 196 ++++++ .../gamenative/mods/NexusOAuthTestTokens.kt | 32 + .../app/gamenative/mods/NexusUrlParserTest.kt | 56 ++ .../NexusModImportServiceRobolectricTest.kt | 38 ++ .../dialog/NexusModsDialogBrowserFirstTest.kt | 189 ++++++ .../auth/NexusOAuthBrowserLauncherTest.kt | 31 + .../auth/NexusOAuthCallbackContractTest.kt | 65 ++ 46 files changed, 4253 insertions(+), 182 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/NexusAuthManager.kt create mode 100644 app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt create mode 100644 app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt create mode 100644 app/src/main/java/app/gamenative/mods/NexusOAuthService.kt create mode 100644 app/src/main/java/app/gamenative/mods/NexusOAuthStorage.kt create mode 100644 app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncher.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt create mode 100644 app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContract.kt create mode 100644 app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt create mode 100644 app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt create mode 100644 app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt create mode 100644 app/src/test/java/app/gamenative/mods/NexusOAuthTestTokens.kt create mode 100644 app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogBrowserFirstTest.kt create mode 100644 app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncherTest.kt create mode 100644 app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 62ff02d129..d0037a5630 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -89,6 +89,30 @@ + + + + + + + + + + + + - pending.reference.gameDomain.equals(reference.gameDomain, ignoreCase = true) && - pending.reference.modId == reference.modId && - pending.file.fileId == reference.fileId - }?.let { pending -> BaseAppScreen.requestManageMods(pending.appId) } - NexusPendingDownloadStore.removeMatching(this, reference) - Timber.i( - "[NexusDownload]: Received authorized NXM callback for %s/%d/%s", - reference.gameDomain, - reference.modId, - reference.fileId, - ) - SnackbarManager.show(getString(R.string.nexus_nxm_callback_received)) - } else { - Timber.w("[NexusDownload]: Ignoring malformed or unsigned NXM callback") - SnackbarManager.show(getString(R.string.nexus_invalid_nxm_callback)) + when (val submission = NexusDownloadLinkInbox.submitIntent(intent.dataString.orEmpty())) { + is NexusNxmSubmission.Expected -> { + BaseAppScreen.requestManageMods(submission.appId) + NexusPendingDownloadStore.removeMatching(this, submission.reference) + Timber.i( + "[NexusDownload]: Received expected NXM callback for %s/%d/%s", + submission.reference.gameDomain, + submission.reference.modId, + submission.reference.fileId, + ) + SnackbarManager.show(getString(R.string.nexus_nxm_callback_received)) + } + is NexusNxmSubmission.BrowserFirst -> { + Timber.i( + "[NexusDownload]: Routed browser-first NXM callback for %s/%d/%s", + submission.reference.gameDomain, + submission.reference.modId, + submission.reference.fileId, + ) + } + NexusNxmSubmission.Expired -> { + Timber.i("[NexusDownload]: Ignoring expired NXM callback") + SnackbarManager.show(getString(R.string.nexus_authorization_expired)) + } + NexusNxmSubmission.NoActiveTarget -> { + Timber.i("[NexusDownload]: Browser-first NXM callback has no active target") + SnackbarManager.show(getString(R.string.nexus_nxm_no_active_target)) + } + NexusNxmSubmission.AmbiguousTarget -> { + Timber.w("[NexusDownload]: Browser-first NXM callback has multiple active targets") + SnackbarManager.show(getString(R.string.nexus_nxm_ambiguous_target)) + } + NexusNxmSubmission.DeliveryFailed -> { + Timber.w("[NexusDownload]: Could not deliver NXM callback to the active target") + SnackbarManager.show(getString(R.string.nexus_oauth_session_unavailable)) + } + NexusNxmSubmission.Replayed, + NexusNxmSubmission.Malformed, + -> { + Timber.w("[NexusDownload]: Ignoring malformed, unsigned, or replayed NXM callback") + SnackbarManager.show(getString(R.string.nexus_invalid_nxm_callback)) + } } return } diff --git a/app/src/main/java/app/gamenative/PluviaApp.kt b/app/src/main/java/app/gamenative/PluviaApp.kt index 42fd4ff662..6bc60c5985 100644 --- a/app/src/main/java/app/gamenative/PluviaApp.kt +++ b/app/src/main/java/app/gamenative/PluviaApp.kt @@ -12,6 +12,7 @@ import androidx.navigation.NavController import app.gamenative.db.dao.AmazonGameDao import app.gamenative.db.dao.GOGGameDao import app.gamenative.events.EventDispatcher +import app.gamenative.mods.NexusAuthManager import app.gamenative.powercontrol.PowerManager import app.gamenative.service.ActiveGameRegistry import app.gamenative.service.DownloadService @@ -82,6 +83,7 @@ class PluviaApp : SplitCompatApplication() { // Init our datastore preferences. PrefManager.init(this) + NexusAuthManager.initialize(this) FrontendSyncManager.init(this) // Initialize GOGConstants diff --git a/app/src/main/java/app/gamenative/mods/NexusApiClient.kt b/app/src/main/java/app/gamenative/mods/NexusApiClient.kt index 36115bbe4f..ca44dadfe6 100644 --- a/app/src/main/java/app/gamenative/mods/NexusApiClient.kt +++ b/app/src/main/java/app/gamenative/mods/NexusApiClient.kt @@ -10,6 +10,7 @@ import okhttp3.MediaType.Companion.toMediaType import okhttp3.OkHttpClient import okhttp3.Request import okhttp3.RequestBody.Companion.toRequestBody +import okhttp3.Response import org.json.JSONArray import org.json.JSONObject import java.io.ByteArrayInputStream @@ -106,7 +107,15 @@ class NexusApiClient( "https://api.nexusmods.com/v2/graphql", "https://api-router.nexusmods.com/graphql", ), - private val accessTokenProvider: () -> String? = { null }, + private val accessTokenProvider: suspend ( + forceRefresh: Boolean, + rejectedAccessToken: String?, + ) -> String? = { forceRefresh, rejectedAccessToken -> + NexusAuthManager.getValidAccessToken(forceRefresh, rejectedAccessToken) + }, + private val accountProvider: () -> NexusOAuthAccount? = { + NexusAuthManager.state.value.account + }, ) { private companion object { private const val ADULT_CONTENT_BLOCKED_CODE = "ADULT_CONTENT_BLOCKED" @@ -127,11 +136,30 @@ class NexusApiClient( suspend fun getCurrentUser(): NexusUserInfo = withContext(Dispatchers.IO) { - val json = getObject("/users/validate.json") + val account = try { + accountProvider() + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { + throw NexusApiException( + message = "Nexus account details are temporarily unavailable", + reason = NexusApiErrorReason.AUTHENTICATION, + cause = error, + ) + } ?: throw NexusApiException( + message = "Nexus account details are temporarily unavailable", + reason = NexusApiErrorReason.AUTHENTICATION, + ) + val userId = account.id.toLongOrNull() + ?.takeIf { it > 0L } + ?: throw NexusApiException( + message = "Nexus account details are invalid", + reason = NexusApiErrorReason.AUTHENTICATION, + ) NexusUserInfo( - name = json.optString("name"), - userId = json.optLong("user_id", 0L), - isPremium = json.optBoolean("is_premium", false), + name = account.name, + userId = userId, + isPremium = account.isPremium, ) } @@ -258,7 +286,7 @@ class NexusApiClient( throw lastError ?: NexusApiException("Nexus collection was not found", 404) } - private fun getCollectionRevisionGraph(reference: NexusCollectionReference): NexusCollectionInfo { + private suspend fun getCollectionRevisionGraph(reference: NexusCollectionReference): NexusCollectionInfo { val payload = collectionRevisionGraphPayload(reference) var lastError: NexusApiException? = null for (url in graphUrls.distinct()) { @@ -360,17 +388,17 @@ class NexusApiClient( ) } - private fun getObject(path: String): JSONObject = + private suspend fun getObject(path: String): JSONObject = JSONObject(execute(path)) - private fun postObject(url: String, payload: JSONObject): JSONObject { + private suspend fun postObject(url: String, payload: JSONObject): JSONObject { val request = authenticatedRequest(url) .post(payload.toString().toRequestBody(jsonMediaType)) .build() return JSONObject(execute(request, url)) } - private fun getCollectionManifest( + private suspend fun getCollectionManifest( downloadLink: String, graphInfo: NexusCollectionInfo, ): NexusCollectionInfo? { @@ -391,7 +419,7 @@ class NexusApiClient( return parseCollectionManifest(JSONObject(jsonText), graphInfo) } - private fun fetchCollectionPayload(url: String): ByteArray { + private suspend fun fetchCollectionPayload(url: String): ByteArray { val parsed = url.toHttpUrlOrNull() ?: throw NexusApiException("Invalid Nexus collection download URL") if (!parsed.isAllowedCollectionScheme()) { @@ -436,15 +464,20 @@ class NexusApiClient( } } - private fun execute(path: String): String { + private suspend fun execute(path: String): String { return execute( request = authenticatedRequest(baseUrl.trimEnd('/') + path).build(), displayPath = path, ) } - private fun authenticatedRequest(url: String): Request.Builder { - val accessToken = accessTokenProvider()?.trim().orEmpty() + private suspend fun authenticatedRequest(url: String): Request.Builder { + val parsed = url.toHttpUrlOrNull() + ?: throw NexusApiException("Invalid Nexus API URL") + if (!parsed.requiresAuthentication()) { + throw NexusApiException("Refusing to send Nexus credentials to an untrusted host") + } + val accessToken = providedAccessToken(forceRefresh = false)?.trim().orEmpty() if (accessToken.isBlank()) { throw NexusApiException( message = "Nexus Mods account connection is temporarily unavailable", @@ -465,57 +498,88 @@ class NexusApiClient( .addHeader("Application-Version", BuildConfig.VERSION_NAME) .addHeader("User-Agent", "GameNative/${BuildConfig.VERSION_NAME}") - private fun execute(request: Request, displayPath: String): String { - client.newCall(request).execute().use { response -> - val hourly = response.header("x-rl-hourly-remaining")?.toIntOrNull() - val daily = response.header("x-rl-daily-remaining")?.toIntOrNull() - val body = response.body.string() - if (!response.isSuccessful) { - val message = when (response.code) { - 401 -> "Nexus account authorization was rejected" - 403 -> "Nexus denied access to this resource" - 404 -> if (displayPath.contains("download_link", ignoreCase = true)) { - "This Nexus file is no longer downloadable" - } else { - "Nexus API request failed (404)" + private suspend fun execute(request: Request, displayPath: String): String = + executeWithRefresh(request, displayPath) { response -> response.body.string() } + + private suspend fun executeBytes(request: Request, maxBytes: Long = Long.MAX_VALUE): ByteArray = + executeWithRefresh(request) { response -> + response.body.byteStream().use { it.readLimitedBytes(maxBytes) } + } + + private suspend fun executeWithRefresh( + request: Request, + displayPath: String? = null, + readSuccessfulBody: (Response) -> T, + ): T { + var currentRequest = request + var retriedAfterUnauthorized = false + while (true) { + client.newCall(currentRequest).execute().use { response -> + if (response.code == 401 && !retriedAfterUnauthorized && currentRequest.hasBearerAuthentication()) { + val refreshedToken = providedAccessToken( + forceRefresh = true, + rejectedAccessToken = currentRequest.bearerToken(), + )?.trim().orEmpty() + if (refreshedToken.isNotBlank()) { + currentRequest = currentRequest.newBuilder() + .header("Authorization", "Bearer $refreshedToken") + .build() + retriedAfterUnauthorized = true + return@use } - 429 -> "Nexus API rate limit reached" - else -> "Nexus API request failed (${response.code})" } - throw NexusApiException( - message = message, - statusCode = response.code, - hourlyRemaining = hourly, - dailyRemaining = daily, - reason = response.code.toApiErrorReason(), - ) + val hourly = response.header("x-rl-hourly-remaining")?.toIntOrNull() + val daily = response.header("x-rl-daily-remaining")?.toIntOrNull() + if (!response.isSuccessful) { + val message = when (response.code) { + 401 -> "Nexus account authorization was rejected" + 403 -> "Nexus denied access to this resource" + 404 -> if (displayPath?.contains("download_link", ignoreCase = true) == true) { + "This Nexus file is no longer downloadable" + } else { + "Nexus API request failed (404)" + } + 429 -> "Nexus API rate limit reached" + else -> "Nexus API request failed (${response.code})" + } + throw NexusApiException( + message = message, + statusCode = response.code, + hourlyRemaining = hourly, + dailyRemaining = daily, + reason = response.code.toApiErrorReason(), + ) + } + return readSuccessfulBody(response) } - return body } } - private fun executeBytes(request: Request, maxBytes: Long = Long.MAX_VALUE): ByteArray { - client.newCall(request).execute().use { response -> - val hourly = response.header("x-rl-hourly-remaining")?.toIntOrNull() - val daily = response.header("x-rl-daily-remaining")?.toIntOrNull() - if (!response.isSuccessful) { - val message = when (response.code) { - 401 -> "Nexus account authorization was rejected" - 403 -> "Nexus denied access to this resource" - 429 -> "Nexus API rate limit reached" - else -> "Nexus API request failed (${response.code})" - } - throw NexusApiException( - message = message, - statusCode = response.code, - hourlyRemaining = hourly, - dailyRemaining = daily, - reason = response.code.toApiErrorReason(), - ) - } - return response.body.byteStream().use { it.readLimitedBytes(maxBytes) } + private suspend fun providedAccessToken( + forceRefresh: Boolean, + rejectedAccessToken: String? = null, + ): String? = + try { + accessTokenProvider(forceRefresh, rejectedAccessToken) + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { + throw NexusApiException( + message = "Nexus account authorization could not be refreshed", + reason = NexusApiErrorReason.AUTHENTICATION, + cause = error, + ) } - } + + private fun Request.hasBearerAuthentication(): Boolean = + url.requiresAuthentication() && bearerToken() != null + + private fun Request.bearerToken(): String? = + header("Authorization") + ?.takeIf { it.startsWith("Bearer ", ignoreCase = true) } + ?.substringAfter(' ') + ?.trim() + ?.takeIf(String::isNotBlank) private fun NexusApiException.asDownloadLinkError( hasAuthorization: Boolean, diff --git a/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt new file mode 100644 index 0000000000..666eac778e --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt @@ -0,0 +1,593 @@ +package app.gamenative.mods + +import android.content.Context +import android.net.Uri +import java.net.URI +import java.net.URLDecoder +import java.security.SecureRandom +import java.util.concurrent.TimeUnit +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import okhttp3.HttpUrl.Companion.toHttpUrl +import timber.log.Timber + +internal fun interface NexusOAuthClock { + fun currentTimeMillis(): Long +} + +private object SystemNexusOAuthClock : NexusOAuthClock { + override fun currentTimeMillis(): Long = System.currentTimeMillis() +} + +private data class NexusAuthorizationExchange( + val state: String, + val code: String, + val codeVerifier: String, +) + +internal class NexusOAuthController( + private val store: NexusOAuthStore, + private val remote: NexusOAuthRemote, + private val clock: NexusOAuthClock = SystemNexusOAuthClock, + private val secureRandom: SecureRandom = SecureRandom(), + private val onSessionInvalidated: () -> Unit = {}, +) { + private val sessionMutex = Mutex() + private val authorizationLock = Any() + private var activeAuthorizationState: String? = store.readTransaction()?.state + private val mutableState = MutableStateFlow(stateFromStoredTokens()) + + val state: StateFlow = mutableState.asStateFlow() + + init { + if (!mutableState.value.isConnected) { + invalidateSessionSideData() + } + } + + fun beginAuthorization(): Uri { + val pkce = NexusPkce.generate(secureRandom) + val oauthState = NexusPkce.generateState(secureRandom) + synchronized(authorizationLock) { + store.writeTransaction( + NexusAuthorizationTransaction( + state = oauthState, + codeVerifier = pkce.verifier, + createdAtEpochMillis = clock.currentTimeMillis(), + ), + ) + activeAuthorizationState = oauthState + if (store.readTokens() == null) { + mutableState.value = NexusAuthState(connection = NexusConnectionState.CONNECTING) + } + } + return Uri.parse(buildNexusAuthorizationUrl(pkce.challenge, oauthState)) + } + + fun cancelAuthorization() { + synchronized(authorizationLock) { + // Clear the in-memory attempt first. This is the cancellation linearization point: + // an exchange response that arrives later cannot install its token pair. + activeAuthorizationState = null + try { + store.clearTransaction() + } finally { + mutableState.value = stateFromStoredTokens() + } + } + } + + suspend fun handleAuthorizationCallback(callbackUri: Uri): Result = + handleAuthorizationCallback(callbackUri.toString()) + + internal suspend fun handleAuthorizationCallback(callbackUri: String): Result = + sessionMutex.withLock { + var attemptState: String? = null + try { + val callback = parseAndValidateCallback(callbackUri) + val exchange = synchronized(authorizationLock) { + val transaction = validateTransaction(callback) + if (activeAuthorizationState != transaction.state) { + throw NexusOAuthException("This Nexus sign-in request is no longer active") + } + attemptState = transaction.state + + // Authorization codes and PKCE transactions are one-time credentials. Consume + // the durable transaction before the network exchange so duplicate intents + // cannot replay it. The in-memory attempt remains active until install/cancel. + store.clearTransaction() + + callback.error?.let { errorCode -> + throw NexusOAuthException( + message = callback.errorDescription ?: "Nexus sign-in was not approved", + errorCode = errorCode, + ) + } + val code = callback.code + ?: throw NexusOAuthException("Nexus sign-in did not return an authorization code") + + // Keep an existing account visible while the user switches accounts. With no + // prior session, CONNECTING remains the useful UI state. + if (store.readTokens() == null) { + mutableState.value = NexusAuthState(connection = NexusConnectionState.CONNECTING) + } + NexusAuthorizationExchange( + state = transaction.state, + code = code, + codeVerifier = transaction.codeVerifier, + ) + } + + val response = remote.exchangeAuthorizationCode(exchange.code, exchange.codeVerifier) + val refreshToken = response.refreshToken + ?.takeIf(String::isNotBlank) + ?: throw NexusOAuthException("Nexus did not return a refresh token") + val tokenAccount = nexusAccountFromAccessToken(response.accessToken) + val storedTokens = response.toStoredTokens( + refreshToken = refreshToken, + account = tokenAccount, + ) + val tokensInstalled = synchronized(authorizationLock) { + if (activeAuthorizationState != exchange.state) { + false + } else { + store.writeTokens(storedTokens) + activeAuthorizationState = null + invalidateSessionSideData() + mutableState.value = NexusAuthState( + connection = NexusConnectionState.CONNECTED, + account = tokenAccount, + ) + true + } + } + if (!tokensInstalled) { + return@withLock Result.failure( + NexusOAuthException("This Nexus sign-in request was canceled or replaced"), + ) + } + + val enrichedAccount = try { + remote.getUserInfo(response.accessToken) + } catch (error: CancellationException) { + // The durable token pair is already installed. Preserve the connected state; + // account details can be loaded on the next screen/app start. + throw error + } catch (error: Exception) { + Timber.w("Nexus sign-in succeeded but account lookup failed (%s)", error.javaClass.simpleName) + null + } + val account = enrichedAccount ?: tokenAccount + if (enrichedAccount != null) { + synchronized(authorizationLock) { + val current = store.readTokens() + if (current?.accessToken == response.accessToken) { + store.writeTokens(current.copy(account = enrichedAccount)) + mutableState.value = NexusAuthState( + connection = NexusConnectionState.CONNECTED, + account = enrichedAccount, + ) + } + } + } + Result.success(account) + } catch (error: CancellationException) { + restoreStateAfterAuthorizationFailure(attemptState) + throw error + } catch (error: Exception) { + restoreStateAfterAuthorizationFailure(attemptState, error.safeMessage()) + Result.failure(error) + } + } + + suspend fun getValidAccessToken( + forceRefresh: Boolean = false, + rejectedAccessToken: String? = null, + ): String? { + val initial = store.readTokens() ?: return null + if (forceRefresh && rejectedAccessToken != null && initial.accessToken != rejectedAccessToken) { + return initial.accessToken + } + val nowSeconds = clock.currentTimeMillis().toEpochSeconds() + if (!forceRefresh && initial.isFreshAt(nowSeconds)) return initial.accessToken + + return sessionMutex.withLock { + val current = store.readTokens() ?: return@withLock null + val lockedNowSeconds = clock.currentTimeMillis().toEpochSeconds() + val rejectedTokenWasAlreadyReplaced = + forceRefresh && rejectedAccessToken != null && current.accessToken != rejectedAccessToken + val anotherRefreshCompleted = + current.accessToken != initial.accessToken || current.refreshToken != initial.refreshToken + if ( + rejectedTokenWasAlreadyReplaced || + anotherRefreshCompleted || + (!forceRefresh && current.isFreshAt(lockedNowSeconds)) + ) { + return@withLock current.accessToken + } + + val refreshed = try { + val response = remote.refresh(current.refreshToken) + val rotatedRefreshToken = response.refreshToken + ?.takeIf(String::isNotBlank) + ?: current.refreshToken + response.toStoredTokens( + refreshToken = rotatedRefreshToken, + account = nexusAccountFromAccessToken(response.accessToken) ?: current.account, + ) + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { + if (error is NexusOAuthException && error.isInvalidGrant) { + runCatching { store.clearTokens() } + invalidateSessionSideData() + mutableState.value = NexusAuthState( + connection = NexusConnectionState.DISCONNECTED, + errorMessage = "Your Nexus connection expired. Please connect it again.", + ) + return@withLock null + } + + // During the refresh skew window, a transient refresh outage should not discard an + // access token that the server may still accept until its actual expiry. + if (!forceRefresh && current.accessTokenExpiresAtEpochSeconds > lockedNowSeconds) { + mutableState.value = NexusAuthState( + connection = NexusConnectionState.CONNECTED, + account = current.account, + errorMessage = "Nexus token refresh will be retried", + ) + return@withLock current.accessToken + } + throw error + } + + try { + store.writeTokens(refreshed) + } catch (storageError: Exception) { + // A rotating refresh-token server may already have invalidated the old token. + // Never continue using a session whose new pair could not be saved atomically. + runCatching { store.clearTokens() } + invalidateSessionSideData() + mutableState.value = NexusAuthState( + connection = NexusConnectionState.DISCONNECTED, + errorMessage = "Nexus credentials could not be saved; reconnect your account", + ) + throw storageError + } + mutableState.value = NexusAuthState( + connection = NexusConnectionState.CONNECTED, + account = refreshed.account, + ) + refreshed.accessToken + } + } + + suspend fun disconnect(): Result { + val outcome = try { + sessionMutex.withLock { + var cleanupFailure: Throwable? = null + fun recordFailure(error: Throwable) { + cleanupFailure?.addSuppressed(error) ?: run { cleanupFailure = error } + } + + val current = try { + store.readTokens() + } catch (error: Exception) { + recordFailure(error) + null + } + + var credentialsCleared = false + try { + store.clearTokens() + credentialsCleared = true + } catch (error: Exception) { + recordFailure(error) + } + try { + store.clearTransaction() + } catch (error: Exception) { + recordFailure(error) + } + try { + invalidateSessionSideData() + } catch (error: Exception) { + recordFailure(error) + } + if (credentialsCleared) { + mutableState.value = NexusAuthState(connection = NexusConnectionState.DISCONNECTED) + } + LocalDisconnectOutcome(current, cleanupFailure) + } + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { + return Result.failure(error) + } + + var revocationFailures = 0 + outcome.tokens?.let { tokens -> + val revocations = listOf( + tokens.refreshToken to "refresh_token", + tokens.accessToken to "access_token", + ).distinctBy { it.first } + for ((token, hint) in revocations) { + try { + remote.revoke(token, hint) + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { + revocationFailures += 1 + } + } + } + if (revocationFailures > 0) { + Timber.w("Nexus account disconnected locally; %d revocation request(s) failed", revocationFailures) + } + return outcome.cleanupFailure?.let { Result.failure(it) } ?: Result.success(Unit) + } + + fun hasStoredSession(): Boolean = state.value.isConnected + + private fun restoreStateAfterAuthorizationFailure( + attemptState: String?, + errorMessage: String? = null, + ) { + synchronized(authorizationLock) { + if (attemptState == null) { + mutableState.value = stateFromStoredTokens(errorMessage) + } else if (activeAuthorizationState == attemptState) { + activeAuthorizationState = null + mutableState.value = stateFromStoredTokens(errorMessage) + } + } + } + + private fun validateTransaction(callback: NexusAuthorizationCallback): NexusAuthorizationTransaction { + val transaction = store.readTransaction() + ?: throw NexusOAuthException("This Nexus sign-in request is no longer active") + val ageMillis = clock.currentTimeMillis() - transaction.createdAtEpochMillis + if (ageMillis < -MAX_CLOCK_SKEW_MILLIS || ageMillis > NexusOAuthConfig.AUTH_TRANSACTION_TTL_MILLIS) { + store.clearTransaction() + throw NexusOAuthException("This Nexus sign-in request expired. Please try again.") + } + val returnedState = callback.state + ?: throw NexusOAuthException("Nexus sign-in returned without its security state") + if (!statesMatch(transaction.state, returnedState)) { + // Do not let an unrelated/malicious callback cancel the legitimate browser flow. + throw NexusOAuthException("Nexus sign-in security validation failed") + } + return transaction + } + + private fun stateFromStoredTokens(errorMessage: String? = null): NexusAuthState { + val tokens = store.readTokens() + return if (tokens == null) { + NexusAuthState( + connection = NexusConnectionState.DISCONNECTED, + errorMessage = errorMessage, + ) + } else { + val account = tokens.account ?: nexusAccountFromAccessToken(tokens.accessToken) + if (tokens.account == null && account != null) { + try { + store.writeTokens(tokens.copy(account = account)) + } catch (storageError: Exception) { + // The existing token pair is still usable. Keep the derived account in memory + // and retry persistence on a later token rotation instead of forcing re-login. + Timber.w( + "Unable to persist Nexus account metadata recovered from access token (%s)", + storageError.javaClass.simpleName, + ) + } + } + NexusAuthState( + connection = NexusConnectionState.CONNECTED, + account = account, + errorMessage = errorMessage, + ) + } + } + + private fun invalidateSessionSideData() { + try { + onSessionInvalidated() + } catch (error: Exception) { + Timber.w("Unable to clear stale Nexus download authorization state (%s)", error.javaClass.simpleName) + } + } + + private fun NexusTokenResponse.toStoredTokens( + refreshToken: String, + account: NexusOAuthAccount? = null, + ): NexusStoredTokens { + if ( + accessToken.isBlank() || + refreshToken.isBlank() || + expiresInSeconds <= 0L || + !tokenType.equals("Bearer", ignoreCase = true) + ) { + throw NexusOAuthException("Nexus returned an invalid Bearer token response") + } + val nowSeconds = clock.currentTimeMillis().toEpochSeconds() + val issuedAt = createdAtEpochSeconds + ?.takeIf { it in (nowSeconds - MAX_SERVER_CLOCK_DIFFERENCE_SECONDS)..(nowSeconds + MAX_SERVER_CLOCK_DIFFERENCE_SECONDS) } + ?: nowSeconds + val expiresAt = if (expiresInSeconds > Long.MAX_VALUE - issuedAt) { + Long.MAX_VALUE + } else { + issuedAt + expiresInSeconds + } + return NexusStoredTokens( + accessToken = accessToken, + refreshToken = refreshToken, + accessTokenExpiresAtEpochSeconds = expiresAt, + account = account, + ) + } + + private fun NexusStoredTokens.isFreshAt(nowEpochSeconds: Long): Boolean = + accessTokenExpiresAtEpochSeconds - NexusOAuthConfig.ACCESS_TOKEN_EXPIRY_SKEW_SECONDS > nowEpochSeconds + + private companion object { + private const val MAX_CLOCK_SKEW_MILLIS = 30_000L + private val MAX_SERVER_CLOCK_DIFFERENCE_SECONDS = TimeUnit.MINUTES.toSeconds(10) + } +} + +/** Process-wide entry point used by UI and by the default authenticated [NexusApiClient]. */ +object NexusAuthManager { + private val initializationLock = Any() + private val initializationScope = CoroutineScope(SupervisorJob() + Dispatchers.IO) + private val mutableState = MutableStateFlow(NexusAuthState()) + + @Volatile + private var controller: NexusOAuthController? = null + + @Volatile + private var applicationContext: Context? = null + + val state: StateFlow = mutableState.asStateFlow() + + fun initialize(context: Context) { + synchronized(initializationLock) { + if (applicationContext == null) { + applicationContext = context.applicationContext + } + } + initializationScope.launch { requireController() } + } + + fun beginAuthorization(): Uri = requireController().beginAuthorization() + + fun cancelAuthorization() { + controller?.cancelAuthorization() + } + + suspend fun handleAuthorizationCallback(callbackUri: Uri): Result = + requireController().handleAuthorizationCallback(callbackUri) + + suspend fun getValidAccessToken( + forceRefresh: Boolean = false, + rejectedAccessToken: String? = null, + ): String? = requireController().getValidAccessToken(forceRefresh, rejectedAccessToken) + + fun hasStoredSession(): Boolean = requireController().hasStoredSession() + + suspend fun disconnect(): Result = + requireController().disconnect() + + private fun requireController(): NexusOAuthController { + controller?.let { return it } + return synchronized(initializationLock) { + controller ?: createController( + checkNotNull(applicationContext) { "NexusAuthManager has not been initialized" }, + ).also { created -> + controller = created + mutableState.value = created.state.value + initializationScope.launch { + created.state.collect { state -> mutableState.value = state } + } + } + } + } + + private fun createController(context: Context): NexusOAuthController = NexusOAuthController( + store = AndroidNexusOAuthStore(context), + remote = NexusOAuthService(), + onSessionInvalidated = { + NexusDownloadLinkInbox.clearAll() + NexusPendingDownloadStore.clear(context) + }, + ) +} + +private data class NexusAuthorizationCallback( + val state: String?, + val code: String?, + val error: String?, + val errorDescription: String?, +) + +private data class LocalDisconnectOutcome( + val tokens: NexusStoredTokens?, + val cleanupFailure: Throwable?, +) + +internal fun buildNexusAuthorizationUrl(codeChallenge: String, state: String): String = + NexusOAuthConfig.AUTHORIZATION_ENDPOINT.toHttpUrl().newBuilder() + .addQueryParameter("response_type", "code") + .addQueryParameter("scope", NexusOAuthConfig.SCOPE) + .addQueryParameter("code_challenge_method", "S256") + .addQueryParameter("client_id", NexusOAuthConfig.CLIENT_ID) + .addQueryParameter("redirect_uri", NexusOAuthConfig.REDIRECT_URI) + .addQueryParameter("code_challenge", codeChallenge) + .addQueryParameter("state", state) + .build() + .toString() + +private fun parseAndValidateCallback(callbackUri: String): NexusAuthorizationCallback { + val uri = try { + URI(callbackUri) + } catch (error: Exception) { + throw NexusOAuthException("Nexus returned an invalid callback", cause = error) + } + if ( + !uri.scheme.equals("app.gamenative", ignoreCase = true) || + !uri.host.equals("oauth", ignoreCase = true) || + uri.rawPath != "/callback" || + uri.userInfo != null || + uri.port != -1 || + uri.rawFragment != null + ) { + throw NexusOAuthException("Nexus returned an unexpected callback address") + } + val parameters = parseQuery(uri.rawQuery) + val callback = NexusAuthorizationCallback( + state = parameters.singleValue("state"), + code = parameters.singleValue("code")?.takeIf(String::isNotBlank), + error = parameters.singleValue("error")?.takeIf(String::isNotBlank), + errorDescription = parameters.singleValue("error_description")?.takeIf(String::isNotBlank), + ) + if ((callback.code == null) == (callback.error == null)) { + throw NexusOAuthException("Nexus returned an ambiguous sign-in callback") + } + return callback +} + +private fun parseQuery(rawQuery: String?): Map> { + if (rawQuery.isNullOrBlank()) return emptyMap() + val values = linkedMapOf>() + for (part in rawQuery.split('&')) { + if (part.isBlank()) continue + val rawName = part.substringBefore('=') + val rawValue = part.substringAfter('=', "") + val name = URLDecoder.decode(rawName, Charsets.UTF_8.name()) + val value = URLDecoder.decode(rawValue, Charsets.UTF_8.name()) + values.getOrPut(name) { mutableListOf() }.add(value) + } + return values +} + +private fun Map>.singleValue(name: String): String? { + val values = get(name) ?: return null + if (values.size != 1) { + throw NexusOAuthException("Nexus returned a duplicated $name parameter") + } + return values.single() +} + +private fun Long.toEpochSeconds(): Long = this / 1000L + +private fun Exception.safeMessage(): String = when (this) { + is NexusOAuthException -> message ?: "Nexus authorization failed" + else -> "Nexus authorization failed" +} diff --git a/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt b/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt index 4122f24665..1866a27c70 100644 --- a/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt +++ b/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt @@ -1,5 +1,7 @@ package app.gamenative.mods +import java.security.MessageDigest +import java.util.Base64 import kotlinx.coroutines.channels.Channel import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.receiveAsFlow @@ -20,6 +22,37 @@ data class AuthorizedNexusWebsiteDownload( val reference: NexusModReference, ) +data class BrowserFirstNexusWebsiteDownload( + val appId: String, + val reference: NexusModReference, +) + +sealed interface NexusNxmSubmission { + data class Expected( + val appId: String, + val reference: NexusModReference, + ) : NexusNxmSubmission + + data class BrowserFirst( + val reference: NexusModReference, + ) : NexusNxmSubmission + + data object Expired : NexusNxmSubmission + data object NoActiveTarget : NexusNxmSubmission + data object AmbiguousTarget : NexusNxmSubmission + data object Replayed : NexusNxmSubmission + data object Malformed : NexusNxmSubmission + data object DeliveryFailed : NexusNxmSubmission +} + +internal class NexusNxmReceiverRegistration internal constructor( + internal val token: Any, +) { + fun unregister() { + NexusDownloadLinkInbox.unregisterReceiver(this) + } +} + internal fun PendingNexusWebsiteDownload.isPastPendingTtl( nowEpochSeconds: Long = System.currentTimeMillis() / 1000L, ): Boolean = nowEpochSeconds - createdAtEpochSeconds >= NexusDownloadLinkInbox.PENDING_DOWNLOAD_TTL_SECONDS @@ -33,6 +66,7 @@ internal fun PendingNexusWebsiteDownload.isPastPendingTtl( */ object NexusDownloadLinkInbox { private const val MAX_PENDING_DOWNLOADS = 16 + private const val MAX_CONSUMED_GRANT_FINGERPRINTS = 64 internal const val PENDING_DOWNLOAD_TTL_SECONDS = 20L * 60L private data class FileKey( @@ -43,7 +77,10 @@ object NexusDownloadLinkInbox { private val pendingLock = Any() private val callbackChannels = mutableMapOf>() + private val browserFirstChannels = mutableMapOf>() private val pendingWebsiteDownloads = linkedMapOf() + private val activeReceivers = mutableMapOf() + private val consumedGrantFingerprints = linkedMapOf() /** * Returns callbacks routed to one GameNative library item. A callback is only @@ -53,6 +90,25 @@ object NexusDownloadLinkInbox { fun callbacksFor(appId: String): Flow = synchronized(pendingLock) { callbackChannelFor(appId) }.receiveAsFlow() + fun browserFirstCallbacksFor(appId: String): Flow = + synchronized(pendingLock) { browserFirstChannelFor(appId) }.receiveAsFlow() + + /** Marks a Manage Nexus Mods dialog as an eligible browser-first destination. */ + internal fun registerReceiver(appId: String): NexusNxmReceiverRegistration { + require(appId.isNotBlank()) + return synchronized(pendingLock) { + val registration = NexusNxmReceiverRegistration(Any()) + activeReceivers[registration.token] = appId + registration + } + } + + internal fun unregisterReceiver(registration: NexusNxmReceiverRegistration) { + synchronized(pendingLock) { + activeReceivers.remove(registration.token) + } + } + fun expect( download: PendingNexusWebsiteDownload, onAccepted: () -> Unit = {}, @@ -74,27 +130,61 @@ object NexusDownloadLinkInbox { true } - fun submit(rawUrl: String): NexusModReference? { - if (rawUrl.length > 8192) return null - val reference = NexusUrlParser.parse(rawUrl) - ?.takeIf { - it.modId > 0L && - (it.fileId ?: 0L) > 0L && - it.downloadAuthorization != null - } - ?: return null - val key = reference.fileKey() - val (callbackChannel, pending) = synchronized(pendingLock) { - removeExpiredPendingDownloads() - val pending = pendingWebsiteDownloads.remove(key) ?: return null - callbackChannelFor(pending.appId) to pending + /** Legacy expected-only entry point retained for tests and app-initiated hand-offs. */ + fun submit(rawUrl: String): NexusModReference? = + (submitInternal(rawUrl, allowBrowserFirst = false) as? NexusNxmSubmission.Expected)?.reference + + /** Handles an Android NXM intent, including a safely targeted browser-first hand-off. */ + fun submitIntent(rawUrl: String): NexusNxmSubmission = + submitInternal(rawUrl, allowBrowserFirst = true) + + private fun submitInternal(rawUrl: String, allowBrowserFirst: Boolean): NexusNxmSubmission { + val reference = when ( + val parsed = NexusUrlParser.parseNxmDownloadGrant(rawUrl, requireUserId = false) + ) { + is NexusUrlParser.NxmDownloadGrantResult.Valid -> parsed.reference + NexusUrlParser.NxmDownloadGrantResult.Expired -> return NexusNxmSubmission.Expired + NexusUrlParser.NxmDownloadGrantResult.Malformed -> return NexusNxmSubmission.Malformed } - val delivery = callbackChannel.trySend(AuthorizedNexusWebsiteDownload(pending, reference)) - if (delivery.isFailure) { - synchronized(pendingLock) { pendingWebsiteDownloads.putIfAbsent(key, pending) } - return null + val authorization = reference.downloadAuthorization ?: return NexusNxmSubmission.Malformed + val key = reference.fileKey() + return synchronized(pendingLock) { + val nowEpochSeconds = System.currentTimeMillis() / 1000L + removeExpiredPendingDownloads(nowEpochSeconds) + removeExpiredConsumedGrants(nowEpochSeconds) + val fingerprint = reference.grantFingerprint(authorization) + if (consumedGrantFingerprints.containsKey(fingerprint)) { + return@synchronized NexusNxmSubmission.Replayed + } + + val pending = pendingWebsiteDownloads.remove(key) + if (pending != null) { + val delivery = callbackChannelFor(pending.appId).trySend( + AuthorizedNexusWebsiteDownload(pending, reference), + ) + if (delivery.isFailure) { + pendingWebsiteDownloads.putIfAbsent(key, pending) + return@synchronized NexusNxmSubmission.DeliveryFailed + } + rememberConsumedGrant(fingerprint, authorization) + return@synchronized NexusNxmSubmission.Expected(pending.appId, reference) + } + + if (!allowBrowserFirst) return@synchronized NexusNxmSubmission.NoActiveTarget + if (authorization.userId?.takeIf { it > 0L } == null) { + return@synchronized NexusNxmSubmission.Malformed + } + val activeAppIds = activeReceivers.values.toList() + if (activeAppIds.isEmpty()) return@synchronized NexusNxmSubmission.NoActiveTarget + if (activeAppIds.size != 1) return@synchronized NexusNxmSubmission.AmbiguousTarget + val appId = activeAppIds.single() + val delivery = browserFirstChannelFor(appId).trySend( + BrowserFirstNexusWebsiteDownload(appId, reference), + ) + if (delivery.isFailure) return@synchronized NexusNxmSubmission.DeliveryFailed + rememberConsumedGrant(fingerprint, authorization) + NexusNxmSubmission.BrowserFirst(reference) } - return reference } fun cancelExpected( @@ -114,9 +204,29 @@ object NexusDownloadLinkInbox { } } + /** Clears account-bound website expectations and any already buffered one-use grants. */ + fun clearAll() { + synchronized(pendingLock) { + pendingWebsiteDownloads.clear() + callbackChannels.values.forEach { channel -> + while (channel.tryReceive().isSuccess) { + // Drain without closing: active dialog collectors remain usable after reconnect. + } + } + browserFirstChannels.values.forEach { channel -> + while (channel.tryReceive().isSuccess) { + // Browser-first grants are memory-only and account-bound. + } + } + } + } + private fun callbackChannelFor(appId: String): Channel = callbackChannels.getOrPut(appId) { Channel(MAX_PENDING_DOWNLOADS) } + private fun browserFirstChannelFor(appId: String): Channel = + browserFirstChannels.getOrPut(appId) { Channel(MAX_PENDING_DOWNLOADS) } + private fun removeExpiredPendingDownloads(nowEpochSeconds: Long = System.currentTimeMillis() / 1000L) { pendingWebsiteDownloads.entries.removeAll { (_, pending) -> pending.isPastPendingTtl(nowEpochSeconds) @@ -129,6 +239,36 @@ object NexusDownloadLinkInbox { private fun NexusModReference.fileKey(): FileKey = FileKey(gameDomain.lowercase(), modId, requireNotNull(fileId)) + private fun removeExpiredConsumedGrants(nowEpochSeconds: Long) { + consumedGrantFingerprints.entries.removeAll { (_, expiresAt) -> expiresAt <= nowEpochSeconds } + } + + private fun rememberConsumedGrant(fingerprint: String, authorization: NexusDownloadAuthorization) { + while (consumedGrantFingerprints.size >= MAX_CONSUMED_GRANT_FINGERPRINTS) { + consumedGrantFingerprints.entries.firstOrNull()?.key?.let(consumedGrantFingerprints::remove) + ?: break + } + consumedGrantFingerprints[fingerprint] = authorization.expires + } + + private fun NexusModReference.grantFingerprint(authorization: NexusDownloadAuthorization): String { + val input = buildString { + append(gameDomain.lowercase()) + append('\u0000') + append(modId) + append('\u0000') + append(requireNotNull(fileId)) + append('\u0000') + append(authorization.expires) + append('\u0000') + append(authorization.userId) + append('\u0000') + append(authorization.key) + } + val digest = MessageDigest.getInstance("SHA-256").digest(input.toByteArray(Charsets.UTF_8)) + return Base64.getEncoder().encodeToString(digest) + } + fun websiteDownloadUrl(reference: NexusModReference, fileId: Long): String = "https://www.nexusmods.com".toHttpUrl().newBuilder() .addPathSegment(reference.gameDomain) diff --git a/app/src/main/java/app/gamenative/mods/NexusIntegrationStatus.kt b/app/src/main/java/app/gamenative/mods/NexusIntegrationStatus.kt index 052809e108..b1b4c86242 100644 --- a/app/src/main/java/app/gamenative/mods/NexusIntegrationStatus.kt +++ b/app/src/main/java/app/gamenative/mods/NexusIntegrationStatus.kt @@ -1,9 +1,6 @@ package app.gamenative.mods -/** - * Online Nexus access remains disabled until GameNative receives its registered - * OAuth client credentials. Local management of previously imported mods stays available. - */ +/** GameNative's registered public/native Nexus OAuth client is available in this build. */ object NexusIntegrationStatus { - const val ONLINE_ACCESS_AVAILABLE = false + const val ONLINE_ACCESS_AVAILABLE = true } diff --git a/app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt b/app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt new file mode 100644 index 0000000000..add2bb0165 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt @@ -0,0 +1,115 @@ +package app.gamenative.mods + +import java.nio.ByteBuffer +import java.nio.charset.CodingErrorAction +import java.util.Base64 +import org.json.JSONArray +import org.json.JSONObject + +/** + * Reads the non-secret account metadata Nexus places in its access-token JWT. + * + * This is not token authentication: Nexus's API servers still validate the signature and authorize + * every Bearer request. The claims only let the client display the connected account and choose the + * free/premium download flow without calling the API-key-only validation endpoint. + */ +internal fun nexusAccountFromAccessToken(accessToken: String): NexusOAuthAccount? { + if (accessToken.isEmpty() || accessToken.length > MAX_JWT_CHARS) return null + + val firstSeparator = accessToken.indexOf('.') + val secondSeparator = accessToken.indexOf('.', firstSeparator + 1) + if ( + firstSeparator !in 1..MAX_JWT_HEADER_CHARS || + secondSeparator <= firstSeparator + 1 || + secondSeparator >= accessToken.lastIndex || + accessToken.indexOf('.', secondSeparator + 1) != -1 + ) { + return null + } + + val header = accessToken.substring(0, firstSeparator) + val payload = accessToken.substring(firstSeparator + 1, secondSeparator) + val signature = accessToken.substring(secondSeparator + 1) + if ( + payload.length > MAX_JWT_PAYLOAD_CHARS || + signature.length > MAX_JWT_SIGNATURE_CHARS || + !header.isStrictBase64Url() || + !payload.isStrictBase64Url() || + !signature.isStrictBase64Url() + ) { + return null + } + + val payloadBytes = try { + Base64.getUrlDecoder().decode(payload) + } catch (_: IllegalArgumentException) { + return null + } + if (payloadBytes.isEmpty() || payloadBytes.size > MAX_JWT_PAYLOAD_BYTES) return null + + val payloadText = try { + Charsets.UTF_8.newDecoder() + .onMalformedInput(CodingErrorAction.REPORT) + .onUnmappableCharacter(CodingErrorAction.REPORT) + .decode(ByteBuffer.wrap(payloadBytes)) + .toString() + } catch (_: Exception) { + return null + } + + val user = try { + JSONObject(payloadText).optJSONObject("user") + } catch (_: Exception) { + null + } ?: return null + + val userId = (user.opt("id") as? Number) + ?.toString() + ?.toLongOrNull() + ?.takeIf { it > 0L } + ?: return null + val username = (user.opt("username") as? String) + ?.trim() + ?.takeIf { it.isNotEmpty() && it.length <= MAX_USERNAME_CHARS } + ?: return null + val roles = user.optJSONArray("membership_roles") + ?.strictStringValues() + ?: return null + + return NexusOAuthAccount( + id = userId.toString(), + name = username, + membershipRoles = roles, + ) +} + +private fun String.isStrictBase64Url(): Boolean = + isNotEmpty() && all { character -> + character in 'A'..'Z' || + character in 'a'..'z' || + character in '0'..'9' || + character == '-' || + character == '_' + } + +private fun JSONArray.strictStringValues(): List? { + if (length() > MAX_MEMBERSHIP_ROLES) return null + val result = ArrayList(length()) + for (index in 0 until length()) { + val role = (opt(index) as? String) + ?.trim() + ?.takeIf { it.isNotEmpty() && it.length <= MAX_MEMBERSHIP_ROLE_CHARS } + ?: return null + result += role + } + return result.distinct() +} + +private const val MAX_JWT_CHARS = 512 * 1024 +private const val MAX_JWT_HEADER_CHARS = 8 * 1024 +private const val MAX_JWT_PAYLOAD_CHARS = 384 * 1024 +private const val MAX_JWT_SIGNATURE_CHARS = 16 * 1024 +private const val MAX_JWT_PAYLOAD_BYTES = 288 * 1024 +private const val MAX_USERNAME_CHARS = 256 +private const val MAX_MEMBERSHIP_ROLES = 64 +private const val MAX_MEMBERSHIP_ROLE_CHARS = 128 diff --git a/app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt b/app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt new file mode 100644 index 0000000000..6d1f9f18a5 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt @@ -0,0 +1,84 @@ +package app.gamenative.mods + +import java.security.MessageDigest +import java.security.SecureRandom +import java.util.Base64 + +/** Public/native Nexus OAuth configuration. A client secret must never be shipped in the app. */ +object NexusOAuthConfig { + const val CLIENT_ID = "gamenative" + const val REDIRECT_URI = "app.gamenative://oauth/callback" + const val AUTHORIZATION_ENDPOINT = "https://users.nexusmods.com/oauth/authorize" + const val TOKEN_ENDPOINT = "https://users.nexusmods.com/oauth/token" + const val REVOCATION_ENDPOINT = "https://users.nexusmods.com/oauth/revoke" + const val USER_INFO_ENDPOINT = "https://users.nexusmods.com/oauth/userinfo" + const val SCOPE = "openid" + + internal const val AUTH_TRANSACTION_TTL_MILLIS = 10L * 60L * 1000L + internal const val ACCESS_TOKEN_EXPIRY_SKEW_SECONDS = 60L +} + +enum class NexusConnectionState { + DISCONNECTED, + CONNECTING, + CONNECTED, +} + +data class NexusOAuthAccount( + val id: String, + val name: String, + val membershipRoles: List = emptyList(), +) { + val isPremium: Boolean + get() = membershipRoles.any { + it.equals("premium", ignoreCase = true) || + it.equals("lifetime", ignoreCase = true) || + it.equals("lifetimepremium", ignoreCase = true) + } +} + +data class NexusAuthState( + val connection: NexusConnectionState = NexusConnectionState.DISCONNECTED, + val account: NexusOAuthAccount? = null, + val errorMessage: String? = null, +) { + val isConnected: Boolean + get() = connection == NexusConnectionState.CONNECTED +} + +internal data class NexusPkcePair( + val verifier: String, + val challenge: String, +) + +internal object NexusPkce { + private const val RANDOM_BYTE_COUNT = 32 + + fun generate(random: SecureRandom = SecureRandom()): NexusPkcePair { + val verifier = randomUrlSafeString(random) + val digest = MessageDigest.getInstance("SHA-256") + .digest(verifier.toByteArray(Charsets.US_ASCII)) + return NexusPkcePair( + verifier = verifier, + challenge = digest.base64Url(), + ) + } + + fun generateState(random: SecureRandom = SecureRandom()): String = + randomUrlSafeString(random) + + private fun randomUrlSafeString(random: SecureRandom): String { + val bytes = ByteArray(RANDOM_BYTE_COUNT) + random.nextBytes(bytes) + return bytes.base64Url() + } + + private fun ByteArray.base64Url(): String = + Base64.getUrlEncoder().withoutPadding().encodeToString(this) +} + +internal fun statesMatch(expected: String, actual: String): Boolean = + MessageDigest.isEqual( + expected.toByteArray(Charsets.UTF_8), + actual.toByteArray(Charsets.UTF_8), + ) diff --git a/app/src/main/java/app/gamenative/mods/NexusOAuthService.kt b/app/src/main/java/app/gamenative/mods/NexusOAuthService.kt new file mode 100644 index 0000000000..1ce129853b --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/NexusOAuthService.kt @@ -0,0 +1,191 @@ +package app.gamenative.mods + +import app.gamenative.BuildConfig +import java.io.IOException +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.withContext +import okhttp3.FormBody +import okhttp3.OkHttpClient +import okhttp3.Request +import org.json.JSONArray +import org.json.JSONObject + +internal data class NexusOAuthEndpoints( + val token: String = NexusOAuthConfig.TOKEN_ENDPOINT, + val revocation: String = NexusOAuthConfig.REVOCATION_ENDPOINT, + val userInfo: String = NexusOAuthConfig.USER_INFO_ENDPOINT, +) + +internal data class NexusTokenResponse( + val accessToken: String, + val refreshToken: String?, + val tokenType: String, + val expiresInSeconds: Long, + val createdAtEpochSeconds: Long?, +) { + override fun toString(): String = + "NexusTokenResponse(accessToken=[REDACTED], refreshToken=[REDACTED], " + + "tokenType=$tokenType, expiresIn=$expiresInSeconds, createdAt=$createdAtEpochSeconds)" +} + +internal class NexusOAuthException( + message: String, + val errorCode: String? = null, + cause: Throwable? = null, +) : IOException(message, cause) { + val isInvalidGrant: Boolean + get() = errorCode.equals("invalid_grant", ignoreCase = true) +} + +internal interface NexusOAuthRemote { + suspend fun exchangeAuthorizationCode( + code: String, + codeVerifier: String, + ): NexusTokenResponse + + suspend fun refresh(refreshToken: String): NexusTokenResponse + + suspend fun getUserInfo(accessToken: String): NexusOAuthAccount + + suspend fun revoke(token: String, tokenTypeHint: String) +} + +internal class NexusOAuthService( + private val client: OkHttpClient = OkHttpClient.Builder() + .followRedirects(false) + .followSslRedirects(false) + .build(), + private val endpoints: NexusOAuthEndpoints = NexusOAuthEndpoints(), +) : NexusOAuthRemote { + + override suspend fun exchangeAuthorizationCode( + code: String, + codeVerifier: String, + ): NexusTokenResponse = requestToken( + FormBody.Builder() + .add("grant_type", "authorization_code") + .add("client_id", NexusOAuthConfig.CLIENT_ID) + .add("redirect_uri", NexusOAuthConfig.REDIRECT_URI) + .add("code", code) + .add("code_verifier", codeVerifier) + .build(), + ) + + override suspend fun refresh(refreshToken: String): NexusTokenResponse = requestToken( + FormBody.Builder() + .add("grant_type", "refresh_token") + .add("client_id", NexusOAuthConfig.CLIENT_ID) + .add("refresh_token", refreshToken) + .build(), + ) + + override suspend fun getUserInfo(accessToken: String): NexusOAuthAccount = withContext(Dispatchers.IO) { + val request = baseRequest(endpoints.userInfo) + .header("Authorization", "Bearer $accessToken") + .get() + .build() + client.newCall(request).execute().use { response -> + val body = response.body.string() + if (!response.isSuccessful) { + throw oauthError(response.code, body, "Nexus account lookup failed") + } + val json = parseJson(body, "Nexus returned an invalid account response") + val id = json.optString("sub") + .toLongOrNull() + ?.takeIf { it > 0L } + ?.toString() + val name = json.optString("name") + if (id == null || name.isBlank()) { + throw NexusOAuthException("Nexus returned an incomplete account response") + } + val rolesJson = json.optJSONArray("membership_roles") ?: JSONArray() + val roles = buildList { + for (index in 0 until rolesJson.length()) { + rolesJson.optString(index).takeIf(String::isNotBlank)?.let(::add) + } + } + NexusOAuthAccount( + id = id, + name = name, + membershipRoles = roles, + ) + } + } + + override suspend fun revoke(token: String, tokenTypeHint: String): Unit = withContext(Dispatchers.IO) { + val body = FormBody.Builder() + .add("client_id", NexusOAuthConfig.CLIENT_ID) + .add("token", token) + .add("token_type_hint", tokenTypeHint) + .build() + val request = baseRequest(endpoints.revocation) + .post(body) + .build() + client.newCall(request).execute().use { response -> + val responseBody = response.body.string() + if (!response.isSuccessful) { + throw oauthError(response.code, responseBody, "Nexus token revocation failed") + } + } + } + + private suspend fun requestToken(body: FormBody): NexusTokenResponse = withContext(Dispatchers.IO) { + val request = baseRequest(endpoints.token) + .post(body) + .build() + client.newCall(request).execute().use { response -> + val responseBody = response.body.string() + if (!response.isSuccessful) { + throw oauthError(response.code, responseBody, "Nexus authorization failed") + } + val json = parseJson(responseBody, "Nexus returned an invalid token response") + val accessToken = json.optString("access_token") + val expiresIn = json.optLong("expires_in", 0L) + val tokenType = json.optString("token_type", "Bearer") + if ( + accessToken.isBlank() || + expiresIn <= 0L || + !tokenType.equals("Bearer", ignoreCase = true) + ) { + throw NexusOAuthException("Nexus returned an incomplete token response") + } + NexusTokenResponse( + accessToken = accessToken, + refreshToken = json.optString("refresh_token").takeIf(String::isNotBlank), + tokenType = "Bearer", + expiresInSeconds = expiresIn, + createdAtEpochSeconds = json.optLong("created_at", 0L).takeIf { it > 0L }, + ) + } + } + + private fun baseRequest(url: String): Request.Builder = Request.Builder() + .url(url) + .header("Accept", "application/json") + .header("Application-Name", "GameNative") + .header("Application-Version", BuildConfig.VERSION_NAME) + .header("User-Agent", "GameNative/${BuildConfig.VERSION_NAME}") + + private fun oauthError(statusCode: Int, body: String, fallback: String): NexusOAuthException { + val json = runCatching { JSONObject(body) }.getOrNull() + val errorCode = json?.optString("error")?.takeIf(String::isNotBlank) + val description = json?.optString("error_description") + ?.takeIf(String::isNotBlank) + ?.take(MAX_ERROR_DESCRIPTION_LENGTH) + return NexusOAuthException( + message = description ?: errorCode ?: "$fallback (HTTP $statusCode)", + errorCode = errorCode, + ) + } + + private fun parseJson(body: String, message: String): JSONObject = + try { + JSONObject(body) + } catch (error: Exception) { + throw NexusOAuthException(message, cause = error) + } + + private companion object { + private const val MAX_ERROR_DESCRIPTION_LENGTH = 300 + } +} diff --git a/app/src/main/java/app/gamenative/mods/NexusOAuthStorage.kt b/app/src/main/java/app/gamenative/mods/NexusOAuthStorage.kt new file mode 100644 index 0000000000..33b276a2e7 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/NexusOAuthStorage.kt @@ -0,0 +1,240 @@ +package app.gamenative.mods + +import android.content.Context +import android.content.SharedPreferences +import android.security.keystore.KeyGenParameterSpec +import android.security.keystore.KeyProperties +import java.security.KeyStore +import java.util.Base64 +import javax.crypto.Cipher +import javax.crypto.KeyGenerator +import javax.crypto.SecretKey +import javax.crypto.spec.GCMParameterSpec +import org.json.JSONArray +import org.json.JSONObject +import timber.log.Timber + +internal data class NexusStoredTokens( + val accessToken: String, + val refreshToken: String, + val accessTokenExpiresAtEpochSeconds: Long, + val account: NexusOAuthAccount? = null, +) { + override fun toString(): String = + "NexusStoredTokens(accessToken=[REDACTED], refreshToken=[REDACTED], " + + "expiresAt=$accessTokenExpiresAtEpochSeconds, account=$account)" +} + +internal data class NexusAuthorizationTransaction( + val state: String, + val codeVerifier: String, + val createdAtEpochMillis: Long, +) { + override fun toString(): String = + "NexusAuthorizationTransaction(state=[REDACTED], codeVerifier=[REDACTED], createdAt=$createdAtEpochMillis)" +} + +internal interface NexusOAuthStore { + fun readTokens(): NexusStoredTokens? + + fun writeTokens(tokens: NexusStoredTokens) + + fun clearTokens() + + fun readTransaction(): NexusAuthorizationTransaction? + + fun writeTransaction(transaction: NexusAuthorizationTransaction) + + fun clearTransaction() +} + +/** + * Stores each OAuth record as one authenticated ciphertext, so access/refresh token rotation is + * committed atomically. The Android Keystore key is non-exportable and dedicated to Nexus OAuth. + */ +internal class AndroidNexusOAuthStore(context: Context) : NexusOAuthStore { + private val preferences: SharedPreferences = context.applicationContext.getSharedPreferences( + PREFERENCES_NAME, + Context.MODE_PRIVATE, + ) + private val crypto = NexusOAuthAesGcm() + private val lock = Any() + + override fun readTokens(): NexusStoredTokens? = synchronized(lock) { + readEncrypted(TOKENS_KEY)?.let(::tokensFromJson) + } + + override fun writeTokens(tokens: NexusStoredTokens) = synchronized(lock) { + writeEncrypted(TOKENS_KEY, tokensToJson(tokens)) + } + + override fun clearTokens() = synchronized(lock) { + if (!preferences.edit().remove(TOKENS_KEY).commit()) { + throw IllegalStateException("Unable to clear Nexus credentials") + } + } + + override fun readTransaction(): NexusAuthorizationTransaction? = synchronized(lock) { + readEncrypted(TRANSACTION_KEY)?.let(::transactionFromJson) + } + + override fun writeTransaction(transaction: NexusAuthorizationTransaction) = synchronized(lock) { + writeEncrypted(TRANSACTION_KEY, transactionToJson(transaction)) + } + + override fun clearTransaction() = synchronized(lock) { + if (!preferences.edit().remove(TRANSACTION_KEY).commit()) { + throw IllegalStateException("Unable to clear Nexus sign-in transaction") + } + } + + private fun readEncrypted(key: String): JSONObject? { + val encoded = preferences.getString(key, null) ?: return null + return try { + val ciphertext = Base64.getDecoder().decode(encoded) + JSONObject(crypto.decrypt(ciphertext).toString(Charsets.UTF_8)) + } catch (error: Exception) { + // Keystore keys are intentionally not backed up. A restored or corrupted ciphertext + // cannot be recovered and must not leave the app believing it is authenticated. + Timber.w("Discarding unreadable Nexus OAuth storage (%s)", error.javaClass.simpleName) + if (!preferences.edit().remove(key).commit()) { + Timber.w("Unable to remove unreadable Nexus OAuth storage") + } + null + } + } + + private fun writeEncrypted(key: String, json: JSONObject) { + val ciphertext = crypto.encrypt(json.toString().toByteArray(Charsets.UTF_8)) + val encoded = Base64.getEncoder().encodeToString(ciphertext) + if (!preferences.edit().putString(key, encoded).commit()) { + throw IllegalStateException("Unable to persist Nexus OAuth state") + } + } + + private fun tokensToJson(tokens: NexusStoredTokens): JSONObject = JSONObject() + .put("version", STORAGE_VERSION) + .put("access_token", tokens.accessToken) + .put("refresh_token", tokens.refreshToken) + .put("access_expires_at", tokens.accessTokenExpiresAtEpochSeconds) + .apply { + tokens.account?.let { account -> + put( + "account", + JSONObject() + .put("id", account.id) + .put("name", account.name) + .put("membership_roles", JSONArray(account.membershipRoles)), + ) + } + } + + private fun tokensFromJson(json: JSONObject): NexusStoredTokens? { + if (json.optInt("version") != STORAGE_VERSION) return null + val accessToken = json.optString("access_token") + val refreshToken = json.optString("refresh_token") + val expiresAt = json.optLong("access_expires_at", 0L) + if (accessToken.isBlank() || refreshToken.isBlank() || expiresAt <= 0L) return null + val account = json.optJSONObject("account")?.let { accountJson -> + val rolesJson = accountJson.optJSONArray("membership_roles") ?: JSONArray() + val roles = buildList { + for (index in 0 until rolesJson.length()) { + rolesJson.optString(index).takeIf(String::isNotBlank)?.let(::add) + } + } + NexusOAuthAccount( + id = accountJson.optString("id"), + name = accountJson.optString("name"), + membershipRoles = roles, + ) + } + return NexusStoredTokens( + accessToken = accessToken, + refreshToken = refreshToken, + accessTokenExpiresAtEpochSeconds = expiresAt, + account = account, + ) + } + + private fun transactionToJson(transaction: NexusAuthorizationTransaction): JSONObject = JSONObject() + .put("version", STORAGE_VERSION) + .put("state", transaction.state) + .put("code_verifier", transaction.codeVerifier) + .put("created_at", transaction.createdAtEpochMillis) + + private fun transactionFromJson(json: JSONObject): NexusAuthorizationTransaction? { + if (json.optInt("version") != STORAGE_VERSION) return null + val state = json.optString("state") + val verifier = json.optString("code_verifier") + val createdAt = json.optLong("created_at", 0L) + if (state.isBlank() || verifier.isBlank() || createdAt <= 0L) return null + return NexusAuthorizationTransaction(state, verifier, createdAt) + } + + private companion object { + private const val PREFERENCES_NAME = "nexus_oauth_secure" + private const val TOKENS_KEY = "token_pair" + private const val TRANSACTION_KEY = "authorization_transaction" + private const val STORAGE_VERSION = 1 + } +} + +private class NexusOAuthAesGcm { + private val keyStore: KeyStore by lazy { + KeyStore.getInstance(ANDROID_KEY_STORE).apply { load(null) } + } + private val keyLock = Any() + + fun encrypt(plaintext: ByteArray): ByteArray { + require(plaintext.isNotEmpty()) + val cipher = Cipher.getInstance(TRANSFORMATION) + cipher.init(Cipher.ENCRYPT_MODE, getOrCreateKey()) + cipher.updateAAD(ASSOCIATED_DATA) + return cipher.iv + cipher.doFinal(plaintext) + } + + fun decrypt(payload: ByteArray): ByteArray { + require(payload.size > IV_LENGTH_BYTES + TAG_LENGTH_BYTES) + val iv = payload.copyOfRange(0, IV_LENGTH_BYTES) + val ciphertext = payload.copyOfRange(IV_LENGTH_BYTES, payload.size) + val cipher = Cipher.getInstance(TRANSFORMATION) + cipher.init( + Cipher.DECRYPT_MODE, + getOrCreateKey(), + GCMParameterSpec(TAG_LENGTH_BITS, iv), + ) + cipher.updateAAD(ASSOCIATED_DATA) + return cipher.doFinal(ciphertext) + } + + private fun getOrCreateKey(): SecretKey = synchronized(keyLock) { + val existing = keyStore.getEntry(KEY_ALIAS, null) as? KeyStore.SecretKeyEntry + existing?.secretKey ?: KeyGenerator.getInstance( + KeyProperties.KEY_ALGORITHM_AES, + ANDROID_KEY_STORE, + ).apply { + init( + KeyGenParameterSpec.Builder( + KEY_ALIAS, + KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT, + ) + .setBlockModes(KeyProperties.BLOCK_MODE_GCM) + .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE) + .setRandomizedEncryptionRequired(true) + .setUserAuthenticationRequired(false) + .setKeySize(256) + .build(), + ) + }.generateKey() + } + + private companion object { + private const val ANDROID_KEY_STORE = "AndroidKeyStore" + private const val KEY_ALIAS = "gamenative_nexus_oauth_aes_gcm_v1" + private const val TRANSFORMATION = "AES/GCM/NoPadding" + private const val IV_LENGTH_BYTES = 12 + private const val TAG_LENGTH_BYTES = 16 + private const val TAG_LENGTH_BITS = TAG_LENGTH_BYTES * 8 + private val ASSOCIATED_DATA = "GameNative:NexusOAuth:v1".toByteArray(Charsets.UTF_8) + } +} diff --git a/app/src/main/java/app/gamenative/mods/NexusPendingDownloadStore.kt b/app/src/main/java/app/gamenative/mods/NexusPendingDownloadStore.kt index bb6bf3e376..4ecee7c8e5 100644 --- a/app/src/main/java/app/gamenative/mods/NexusPendingDownloadStore.kt +++ b/app/src/main/java/app/gamenative/mods/NexusPendingDownloadStore.kt @@ -55,6 +55,13 @@ object NexusPendingDownloadStore { } } + /** Clears only pending Nexus website hand-offs; installed mods/import records are untouched. */ + fun clear(context: Context) { + synchronized(lock) { + preferences(context).edit().remove(PENDING_DOWNLOADS_KEY).commit() + } + } + private fun read(context: Context): List { val raw = preferences(context).getString(PENDING_DOWNLOADS_KEY, null) ?: return emptyList() val now = System.currentTimeMillis() / 1000L diff --git a/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt b/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt index 45e10693f6..d0eb877de1 100644 --- a/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt +++ b/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt @@ -3,6 +3,7 @@ package app.gamenative.mods import java.net.URI import java.net.URLDecoder import java.nio.charset.StandardCharsets +import java.util.Locale data class NexusModReference( val gameDomain: String, @@ -43,6 +44,18 @@ data class NexusCollectionReference( ) object NexusUrlParser { + internal sealed interface NxmDownloadGrantResult { + data class Valid(val reference: NexusModReference) : NxmDownloadGrantResult + data object Expired : NxmDownloadGrantResult + data object Malformed : NxmDownloadGrantResult + } + + private val nxmPathPattern = Regex( + pattern = "^/mods/([1-9][0-9]*)/files/([1-9][0-9]*)$", + option = RegexOption.IGNORE_CASE, + ) + private val nexusGameDomainPattern = Regex("^[a-z0-9][a-z0-9-]{0,127}$") + fun parse(input: String): NexusModReference? { val trimmed = input.trim() if (trimmed.isEmpty()) return null @@ -80,31 +93,128 @@ object NexusUrlParser { } private fun parseNxmUrl(uri: URI): NexusModReference? { - val gameDomain = uri.host?.lowercase() ?: return null - val segments = uri.path - ?.split('/') - ?.filter { it.isNotBlank() } - ?: return null - val modsIndex = segments.indexOfFirst { it.equals("mods", ignoreCase = true) } - if (modsIndex < 0 || modsIndex + 1 >= segments.size) return null - val modId = segments[modsIndex + 1].toLongOrNull()?.takeIf { it > 0L } ?: return null - val fileId = if (modsIndex + 3 < segments.size && segments[modsIndex + 2].equals("files", true)) { - segments[modsIndex + 3].toLongOrNull()?.takeIf { it > 0L } - } else { - parseQuery(uri.rawQuery)["file_id"]?.toLongOrNull()?.takeIf { it > 0L } - } - val query = parseQuery(uri.rawQuery) - val downloadAuthorization = query["key"] + val structure = parseNxmStructure(uri) ?: return null + val query = parseNxmQuery(uri.rawQuery) ?: return null + val downloadAuthorization = query.singleValue("key") ?.takeIf { it.isNotBlank() && it.length <= 2048 } ?.let { key -> - val expires = query["expires"]?.toLongOrNull()?.takeIf { it > 0L } ?: return@let null + val expires = query.singleValue("expires")?.toLongOrNull()?.takeIf { it > 0L } + ?: return@let null NexusDownloadAuthorization( key = key, expires = expires, - userId = query["user_id"]?.toLongOrNull()?.takeIf { it > 0L }, + userId = query.singleValue("user_id")?.toLongOrNull()?.takeIf { it > 0L }, ) } - return NexusModReference(gameDomain, modId, fileId, downloadAuthorization) + return NexusModReference( + gameDomain = structure.gameDomain, + modId = structure.modId, + fileId = structure.fileId, + downloadAuthorization = downloadAuthorization, + ) + } + + /** + * Strictly parses the signed, account-bound NXM capability delivered by Android. + * Unlike [parse], this requires every field needed for a free-account download. + */ + internal fun parseNxmDownloadGrant( + input: String, + nowEpochSeconds: Long = System.currentTimeMillis() / 1000L, + requireUserId: Boolean = true, + ): NxmDownloadGrantResult { + if (input.length > MAX_NXM_URL_LENGTH) return NxmDownloadGrantResult.Malformed + val uri = runCatching { URI(input) }.getOrNull() ?: return NxmDownloadGrantResult.Malformed + if (!uri.scheme.equals("nxm", ignoreCase = true)) return NxmDownloadGrantResult.Malformed + val structure = parseNxmStructure(uri) ?: return NxmDownloadGrantResult.Malformed + val query = parseNxmQuery(uri.rawQuery) ?: return NxmDownloadGrantResult.Malformed + if (query.hasInvalidReservedNxmParameters(requireUserId)) return NxmDownloadGrantResult.Malformed + + val key = query.singleValue("key") + ?.takeIf { value -> + value.isNotBlank() && + value.length <= MAX_NXM_KEY_LENGTH && + value.none(Char::isWhitespace) && + value.none(Char::isISOControl) + } + ?: return NxmDownloadGrantResult.Malformed + val expires = query.singleValue("expires") + ?.toLongOrNull() + ?.takeIf { it > 0L } + ?: return NxmDownloadGrantResult.Malformed + val rawUserId = query.singleValue("user_id") + val userId = rawUserId?.toLongOrNull()?.takeIf { it > 0L } + if ((requireUserId || rawUserId != null) && userId == null) { + return NxmDownloadGrantResult.Malformed + } + if (expires <= nowEpochSeconds) return NxmDownloadGrantResult.Expired + + return NxmDownloadGrantResult.Valid( + NexusModReference( + gameDomain = structure.gameDomain, + modId = structure.modId, + fileId = structure.fileId, + downloadAuthorization = NexusDownloadAuthorization( + key = key, + expires = expires, + userId = userId, + ), + ), + ) + } + + private data class NxmStructure( + val gameDomain: String, + val modId: Long, + val fileId: Long, + ) + + private fun parseNxmStructure(uri: URI): NxmStructure? { + if (uri.isOpaque || uri.userInfo != null || uri.port != -1 || uri.fragment != null) return null + val gameDomain = uri.host + ?.lowercase(Locale.US) + ?.takeIf(nexusGameDomainPattern::matches) + ?: return null + val match = uri.rawPath?.let(nxmPathPattern::matchEntire) ?: return null + val modId = match.groupValues[1].toLongOrNull()?.takeIf { it > 0L } ?: return null + val fileId = match.groupValues[2].toLongOrNull()?.takeIf { it > 0L } ?: return null + return NxmStructure(gameDomain, modId, fileId) + } + + private fun parseNxmQuery(rawQuery: String?): Map>? { + if (rawQuery.isNullOrBlank()) return emptyMap() + return runCatching { + val values = linkedMapOf>() + rawQuery.split('&').forEach { part -> + val separator = part.indexOf('=') + require(separator > 0) + val name = decodeNxmQueryComponent(part.substring(0, separator)) + val value = decodeNxmQueryComponent(part.substring(separator + 1)) + values.getOrPut(name) { mutableListOf() }.add(value) + } + values.mapValues { (_, entries) -> entries.toList() } + }.getOrNull() + } + + /** URLDecoder implements form encoding, so protect literal '+' before percent decoding. */ + private fun decodeNxmQueryComponent(value: String): String = + URLDecoder.decode(value.replace("+", "%2B"), StandardCharsets.UTF_8.name()) + + private fun Map>.singleValue(name: String): String? = + entries.firstOrNull { it.key.equals(name, ignoreCase = true) } + ?.value + ?.singleOrNull() + + private fun Map>.hasInvalidReservedNxmParameters(requireUserId: Boolean): Boolean { + val counts = RESERVED_NXM_QUERY_PARAMETERS.associateWith { reserved -> + entries + .filter { it.key.equals(reserved, ignoreCase = true) } + .sumOf { it.value.size } + } + return counts.getValue("key") != 1 || + counts.getValue("expires") != 1 || + counts.getValue("user_id") > 1 || + (requireUserId && counts.getValue("user_id") != 1) } internal fun parseQuery(rawQuery: String?): Map { @@ -122,6 +232,10 @@ object NexusUrlParser { private fun decode(value: String): String = URLDecoder.decode(value, StandardCharsets.UTF_8.name()) + + private const val MAX_NXM_URL_LENGTH = 8192 + private const val MAX_NXM_KEY_LENGTH = 2048 + private val RESERVED_NXM_QUERY_PARAMETERS = setOf("key", "expires", "user_id") } object NexusCollectionUrlParser { diff --git a/app/src/main/java/app/gamenative/service/NexusModImportService.kt b/app/src/main/java/app/gamenative/service/NexusModImportService.kt index 34f856ade9..0bf9eaa86e 100644 --- a/app/src/main/java/app/gamenative/service/NexusModImportService.kt +++ b/app/src/main/java/app/gamenative/service/NexusModImportService.kt @@ -28,6 +28,7 @@ import app.gamenative.mods.LocalModSourceType import app.gamenative.mods.ModDownloadRegistry import app.gamenative.mods.ModImportProgress import app.gamenative.mods.NexusApiClient +import app.gamenative.mods.NexusAuthManager import app.gamenative.mods.NexusDownloadAuthorization import app.gamenative.mods.NexusImportState import app.gamenative.mods.NexusIntegrationStatus @@ -76,16 +77,23 @@ class NexusModImportService : Service() { override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { mainHandler.removeCallbacks(delayedStop) startForeground(NOTIFICATION_ID, createNotification(getString(R.string.mod_import_preparing))) - if ( - !NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE && - intent?.action == ACTION_RUN_IMPORT - ) { + val nexusOnlineBlockMessage = nexusOnlineBlockMessage(applicationContext) + if (nexusOnlineBlockMessage != null && intent?.action == ACTION_RUN_IMPORT) { + failQueuedIntent(intent, IllegalStateException(nexusOnlineBlockMessage)) scope.launch { try { - pauseInterruptedImports(applicationContext) + pauseInterruptedImports(applicationContext, nexusOnlineBlockMessage) } finally { - stopForeground(STOP_FOREGROUND_REMOVE) - stopSelf(startId) + mainHandler.post { + if (isIdle()) { + stopForeground(STOP_FOREGROUND_REMOVE) + stopSelf(startId) + } else { + // A local import (or cached-archive completion) may already be active. + // Rejecting a Nexus network task must not cancel that offline-safe work. + resumeOrStopIfIdle() + } + } } } return START_NOT_STICKY @@ -99,7 +107,7 @@ class NexusModImportService : Service() { } return if ( intent?.action == ACTION_RUN_LOCAL_IMPORT || - NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE + nexusOnlineBlockMessage == null ) { START_STICKY } else { @@ -122,6 +130,11 @@ class NexusModImportService : Service() { private fun startQueuedTask(taskId: String?, intent: Intent) { val task = taskId?.let { pendingTasks.remove(it) } + nexusOnlineBlockMessage(applicationContext)?.let { message -> + task?.deferred?.completeExceptionally(IllegalStateException(message)) + resumeOrStopIfIdle() + return + } val request = task?.request ?: decodeImportRequest(intent) if (request == null) { resumeOrStopIfIdle() @@ -129,15 +142,34 @@ class NexusModImportService : Service() { } val displayName = task?.displayName ?: request.modInfo.name launchImport(displayName, task?.deferred, task?.progressSink, "Nexus mod import failed") { progress -> - NexusModManager.importNexusFile( - context = applicationContext, - appId = request.appId, - reference = request.reference, - modInfo = request.modInfo, - file = request.file, - isPremiumAccount = request.isPremiumAccount, - onDetailedProgress = progress, - ) + try { + NexusModManager.importNexusFile( + context = applicationContext, + appId = request.appId, + reference = request.reference, + modInfo = request.modInfo, + file = request.file, + isPremiumAccount = request.isPremiumAccount, + onDetailedProgress = progress, + ) + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { + nexusOnlineBlockMessage(applicationContext)?.let { message -> + val installId = NexusModManager.installIdFor( + request.appId, + request.reference.gameDomain, + request.reference.modId, + request.file.fileId, + ) + pauseImportAfterAuthenticationLoss( + NexusModManager.dao(applicationContext), + installId, + message, + ) + } + throw error + } } } @@ -217,7 +249,7 @@ class NexusModImportService : Service() { } } - private fun failQueuedIntent(intent: Intent, error: CancellationException) { + private fun failQueuedIntent(intent: Intent, error: Throwable) { val taskId = intent.getStringExtra(EXTRA_TASK_ID) ?: return when (intent.action) { ACTION_RUN_IMPORT -> pendingTasks.remove(taskId)?.deferred?.completeExceptionally(error) @@ -281,7 +313,8 @@ class NexusModImportService : Service() { activeTasks.incrementAndGet() scope.launch { val dao = NexusModManager.dao(applicationContext) - val onlineAccessAvailable = NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE + val onlineBlockMessage = nexusOnlineBlockMessage(applicationContext) + val onlineAccessAvailable = onlineBlockMessage == null val interrupted = queryResumableImports(dao) if (interrupted.isEmpty()) return@launch val (localInterrupted, nexusCandidates) = interrupted.partition { @@ -347,6 +380,7 @@ class NexusModImportService : Service() { applicationContext, dao, nexusInterrupted, + requireNotNull(onlineBlockMessage), ) to emptyList() } else { partitionByCompleteArchive(applicationContext, nexusInterrupted) @@ -358,8 +392,17 @@ class NexusModImportService : Service() { throw e } catch (e: Exception) { Timber.w(e, "Could not validate Nexus account before resuming imports") - downloadsNeedingLinks.forEach { install -> - dao.updateInstallStatus(install.installId, ModInstallStatus.PAUSED.name) + val disconnectedMessage = nexusOnlineBlockMessage(applicationContext) + if (disconnectedMessage != null) { + pauseImportsWhileOnlineAccessUnavailable( + dao, + downloadsNeedingLinks, + disconnectedMessage, + ) + } else { + downloadsNeedingLinks.forEach { install -> + dao.updateInstallStatus(install.installId, ModInstallStatus.PAUSED.name) + } } null } @@ -433,6 +476,9 @@ class NexusModImportService : Service() { throw e } catch (error: Exception) { Timber.w(error, "Failed to resume Nexus import ${install.installId}") + nexusOnlineBlockMessage(applicationContext)?.let { message -> + pauseImportAfterAuthenticationLoss(dao, install.installId, message) + } } } }.invokeOnCompletion { @@ -475,6 +521,21 @@ class NexusModImportService : Service() { ) } + private suspend fun pauseImportAfterAuthenticationLoss( + dao: ModDao, + installId: String, + message: String, + ) { + val current = dao.getInstall(installId) ?: return + if ( + current.source != ModInstallSource.NEXUS.name || + current.status in NexusImportState.reusableStatuses + ) { + return + } + dao.upsertInstall(NexusImportState.pauseWhileOnlineAccessUnavailable(current, message)) + } + private suspend fun currentResumableLocalInstall( dao: ModDao, installId: String, @@ -575,11 +636,9 @@ class NexusModImportService : Service() { isPremiumAccount: Boolean? = null, onProgress: (ModImportProgress) -> Unit = {}, ): Deferred { - if (!NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE) { + nexusOnlineBlockMessage(context)?.let { message -> return failedImport( - IllegalStateException( - context.getString(R.string.nexus_integration_temporarily_unavailable), - ), + IllegalStateException(message), ) } if (reference.fileId != null && reference.fileId != file.fileId) { @@ -722,11 +781,13 @@ class NexusModImportService : Service() { val (localInterrupted, nexusInterrupted) = interrupted.partition { ModInstallSource.isLocal(it.source) } - if (!NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE) { + val onlineBlockMessage = nexusOnlineBlockMessage(appContext) + if (onlineBlockMessage != null) { val completeNexusArchives = pauseDownloadsNeedingOnlineAccess( appContext, dao, nexusInterrupted, + onlineBlockMessage, ) localInterrupted.isNotEmpty() || completeNexusArchives.isNotEmpty() } else { @@ -749,12 +810,17 @@ class NexusModImportService : Service() { } } - private suspend fun pauseInterruptedImports(context: Context) = withContext(Dispatchers.IO) { + private suspend fun pauseInterruptedImports( + context: Context, + message: String = nexusOnlineBlockMessage(context) + ?: context.getString(R.string.nexus_integration_temporarily_unavailable), + ) = withContext(Dispatchers.IO) { val dao = NexusModManager.dao(context) pauseDownloadsNeedingOnlineAccess( context, dao, queryResumableImports(dao).filter { it.source == ModInstallSource.NEXUS.name }, + message, ) } @@ -774,26 +840,34 @@ class NexusModImportService : Service() { context: Context, dao: ModDao, installs: List, + message: String, ): List { val nexusInstalls = installs.filter { it.source == ModInstallSource.NEXUS.name } val (completeArchives, downloadsNeedingLinks) = partitionByCompleteArchive(context, nexusInstalls) - pauseImportsWhileOnlineAccessUnavailable(context, dao, downloadsNeedingLinks) + pauseImportsWhileOnlineAccessUnavailable(dao, downloadsNeedingLinks, message) return completeArchives } private suspend fun pauseImportsWhileOnlineAccessUnavailable( - context: Context, dao: ModDao, installs: List, + message: String, ) { - val message = context.getString(R.string.nexus_integration_temporarily_unavailable) installs.forEach { install -> val paused = NexusImportState.pauseWhileOnlineAccessUnavailable(install, message) if (paused != install) dao.upsertInstall(paused) } } + private fun nexusOnlineBlockMessage(context: Context): String? = when { + !NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE -> + context.getString(R.string.nexus_integration_temporarily_unavailable) + !NexusAuthManager.hasStoredSession() -> + context.getString(R.string.nexus_oauth_sign_in_required) + else -> null + } + internal fun putImportRequest(intent: Intent, request: NexusImportRequest) { intent.putExtra(EXTRA_APP_ID, request.appId) intent.putExtra(EXTRA_GAME_DOMAIN, request.reference.gameDomain) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 02e15179b9..fdf8b63276 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -49,6 +49,7 @@ import androidx.compose.runtime.mutableStateListOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.rememberUpdatedState import androidx.compose.runtime.saveable.rememberSaveable import androidx.compose.runtime.setValue import androidx.compose.runtime.snapshotFlow @@ -81,6 +82,7 @@ import app.gamenative.mods.BethesdaPluginAssetIssue import app.gamenative.mods.BethesdaPluginDependencyIssue import app.gamenative.mods.BethesdaPluginManager import app.gamenative.mods.AuthorizedNexusWebsiteDownload +import app.gamenative.mods.BrowserFirstNexusWebsiteDownload import app.gamenative.mods.FomodInstaller import app.gamenative.mods.FomodAutoSelector import app.gamenative.mods.FomodInstallerDetector @@ -110,6 +112,9 @@ import app.gamenative.mods.ModTargetResolver import app.gamenative.mods.NexusApiClient import app.gamenative.mods.NexusApiErrorReason import app.gamenative.mods.NexusApiException +import app.gamenative.mods.NexusAuthManager +import app.gamenative.mods.NexusAuthState +import app.gamenative.mods.NexusConnectionState import app.gamenative.mods.NexusCollectionFile import app.gamenative.mods.NexusCollectionInfo import app.gamenative.mods.NexusCollectionPrioritySuggester @@ -128,6 +133,7 @@ import app.gamenative.mods.PendingNexusWebsiteDownload import app.gamenative.mods.NexusUrlParser import app.gamenative.mods.isPastPendingTtl import app.gamenative.service.NexusModImportService +import app.gamenative.ui.screen.auth.NexusOAuthBrowserLauncher import app.gamenative.ui.util.LocalSnackbarHostController import app.gamenative.ui.util.SnackbarManager import app.gamenative.utils.StorageUtils @@ -180,6 +186,73 @@ internal data class PendingFileSelection( val files: List, ) +internal sealed interface BrowserFirstNexusResolution { + data class Resolved( + val reference: NexusModReference, + val modInfo: NexusModInfo, + val file: NexusModFile, + ) : BrowserFirstNexusResolution + + data object Expired : BrowserFirstNexusResolution + data object WrongAccount : BrowserFirstNexusResolution + data object MissingFile : BrowserFirstNexusResolution + data object Invalid : BrowserFirstNexusResolution +} + +/** + * Derives the download identity directly from the current OAuth state. + * + * Keeping a separately remembered user can leak account A's ID or membership tier into account B + * after an automatic invalid-grant disconnect and reconnect while this dialog remains composed. + */ +internal fun NexusAuthState.currentNexusUserInfo(): NexusUserInfo? { + if (!isConnected) return null + val currentAccount = account ?: return null + val userId = currentAccount.id.toLongOrNull()?.takeIf { it > 0L } ?: return null + return NexusUserInfo( + name = currentAccount.name, + userId = userId, + isPremium = currentAccount.isPremium, + ) +} + +/** Reads the account at execution time so a retained callback cannot reuse an older session. */ +internal suspend fun currentNexusUserForDownload( + reference: NexusModReference, + getCurrentUser: suspend () -> NexusUserInfo, +): NexusUserInfo? { + val currentUser = getCurrentUser() + val authorizationUserId = reference.downloadAuthorization?.userId + return currentUser.takeIf { authorizationUserId == null || authorizationUserId == currentUser.userId } +} + +internal suspend fun resolveBrowserFirstNexusDownload( + reference: NexusModReference, + getCurrentUser: suspend () -> NexusUserInfo, + getModInfo: suspend (String, Long) -> NexusModInfo, + getModFiles: suspend (String, Long) -> List, + nowEpochSeconds: () -> Long = { System.currentTimeMillis() / 1000L }, +): BrowserFirstNexusResolution { + val fileId = reference.fileId?.takeIf { it > 0L } ?: return BrowserFirstNexusResolution.Invalid + val authorization = reference.downloadAuthorization ?: return BrowserFirstNexusResolution.Invalid + val authorizationUserId = authorization.userId?.takeIf { it > 0L } + ?: return BrowserFirstNexusResolution.Invalid + if (authorization.isExpired(nowEpochSeconds())) return BrowserFirstNexusResolution.Expired + + val user = getCurrentUser() + if (user.userId <= 0L) return BrowserFirstNexusResolution.Invalid + if (user.userId != authorizationUserId) return BrowserFirstNexusResolution.WrongAccount + + val modInfo = getModInfo(reference.gameDomain, reference.modId) + val file = getModFiles(reference.gameDomain, reference.modId) + .firstOrNull { it.fileId == fileId } + ?: return BrowserFirstNexusResolution.MissingFile + if (authorization.isExpired(nowEpochSeconds())) return BrowserFirstNexusResolution.Expired + val currentUser = getCurrentUser() + if (currentUser.userId != authorizationUserId) return BrowserFirstNexusResolution.WrongAccount + return BrowserFirstNexusResolution.Resolved(reference, modInfo, file) +} + internal data class PendingLocalModImport( val source: LocalModSourceSelection, val installId: String? = null, @@ -634,6 +707,7 @@ fun NexusModsDialog( val profileStates by profileStateFlow.collectAsState(initial = emptyList()) val priorityByInstallId = remember(profileStates) { profileStates.associate { it.installId to it.priority } } val profileEnabledByInstallId = remember(profileStates) { profileStates.associate { it.installId to it.enabled } } + val nexusAuthState by NexusAuthManager.state.collectAsState() val apiClient = remember { NexusApiClient() } val roots = remember(gameRootDir, winePrefix, context) { ModTargetResolver.roots(gameRootDir, winePrefix).ifEmpty { @@ -646,7 +720,7 @@ fun NexusModsDialog( RecipeDraft(targetRoot = roots.firstOrNull()?.type?.name ?: ModTargetRoot.GAME_DIR.name) } - var nexusUserInfo by remember { mutableStateOf(null) } + val nexusUserInfo = nexusAuthState.currentNexusUserInfo() var nexusUrl by remember { mutableStateOf("") } var loadingMessage by remember { mutableStateOf(null) } var progress by remember { mutableFloatStateOf(0f) } @@ -671,6 +745,19 @@ fun NexusModsDialog( var selectedCollectionKeys by remember { mutableStateOf>(emptySet()) } val collectionQueue = remember { mutableStateMapOf() } val websiteAuthorizationWaiters = remember { mutableMapOf>() } + LaunchedEffect(nexusAuthState.isConnected) { + if (!nexusAuthState.isConnected && websiteAuthorizationWaiters.isNotEmpty()) { + val error = NexusWebsiteAuthorizationException( + context.getString(R.string.nexus_oauth_sign_in_required), + ) + websiteAuthorizationWaiters.values.toList().forEach { waiter -> + if (waiter.isActive) waiter.completeExceptionally(error) + } + } + if (!nexusAuthState.isConnected && pendingFileSelection?.reference?.downloadAuthorization != null) { + pendingFileSelection = null + } + } var collectionPaused by remember { mutableStateOf(false) } var collectionCancelRequested by remember { mutableStateOf(false) } var collectionImportRunning by remember { mutableStateOf(false) } @@ -693,8 +780,17 @@ fun NexusModsDialog( var healthReport by remember(libraryItem.appId) { mutableStateOf(null) } var healthLoading by remember(libraryItem.appId) { mutableStateOf(false) } var diagnosticsPaused by remember { mutableStateOf(false) } + var nexusAuthActionInProgress by remember { mutableStateOf(false) } val nexusAuthenticationUnavailableMessage = - context.getString(R.string.nexus_integration_temporarily_unavailable) + context.getString( + when { + !NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE -> { + R.string.nexus_integration_temporarily_unavailable + } + !nexusAuthState.isConnected -> R.string.nexus_oauth_sign_in_required + else -> R.string.nexus_oauth_session_unavailable + }, + ) val nexusAdultContentBlockedMessage = context.getString(R.string.nexus_adult_content_blocked) fun nexusUserMessage( @@ -722,11 +818,67 @@ fun NexusModsDialog( } fun blockUnavailableOnlineAccess(): Boolean { - if (NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE) return false - SnackbarManager.show(context.getString(R.string.nexus_integration_temporarily_unavailable)) + val message = when { + !NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE -> { + context.getString(R.string.nexus_integration_temporarily_unavailable) + } + !nexusAuthState.isConnected -> context.getString(R.string.nexus_oauth_sign_in_required) + else -> return false + } + SnackbarManager.show(message) return true } + fun connectNexusAccount() { + if (!NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE || nexusAuthActionInProgress) { + blockUnavailableOnlineAccess() + return + } + val authorizationUri = runCatching { NexusAuthManager.beginAuthorization() } + .getOrElse { error -> + Timber.w( + "[NexusOAuth]: Could not prepare browser sign-in (%s)", + error.javaClass.simpleName, + ) + SnackbarManager.show(context.getString(R.string.nexus_oauth_sign_in_failed)) + return + } + NexusOAuthBrowserLauncher.launch(context, authorizationUri) + .onFailure { error -> + Timber.w( + "[NexusOAuth]: Could not launch the sign-in browser (%s)", + error.javaClass.simpleName, + ) + SnackbarManager.show(context.getString(R.string.nexus_oauth_browser_failed)) + // Reset the pending transaction and CONNECTING state when no browser accepted it. + NexusAuthManager.cancelAuthorization() + } + } + + fun disconnectNexusAccount() { + if (nexusAuthActionInProgress) return + scope.launch { + nexusAuthActionInProgress = true + try { + NexusAuthManager.disconnect() + .onSuccess { + pendingFileSelection = null + pendingCollectionSelection = null + SnackbarManager.show(context.getString(R.string.nexus_oauth_disconnected)) + } + .onFailure { error -> + Timber.w( + "[NexusOAuth]: Account disconnect did not complete (%s)", + error.javaClass.simpleName, + ) + SnackbarManager.show(context.getString(R.string.nexus_oauth_disconnect_failed)) + } + } finally { + nexusAuthActionInProgress = false + } + } + } + fun inspectLocalSource( retryInstallId: String?, inspect: suspend () -> LocalModSourceSelection, @@ -1572,9 +1724,11 @@ fun NexusModsDialog( modInfo: NexusModInfo, file: NexusModFile, requestId: String? = null, - nexusUserId: Long? = nexusUserInfo?.userId, + nexusUserId: Long? = null, ): Boolean { if (blockUnavailableOnlineAccess()) return false + val currentNexusUserId = nexusUserId + ?: NexusAuthManager.state.value.currentNexusUserInfo()?.userId val pendingReference = reference.copy( fileId = file.fileId, downloadAuthorization = null, @@ -1584,7 +1738,7 @@ fun NexusModsDialog( reference = pendingReference, modInfo = modInfo, file = file, - nexusUserId = nexusUserId, + nexusUserId = currentNexusUserId, requestId = requestId, ) val expected = NexusDownloadLinkInbox.expect(pending) { @@ -1669,16 +1823,14 @@ fun NexusModsDialog( fun importFile(reference: NexusModReference, modInfo: NexusModInfo, file: NexusModFile) { if (blockUnavailableOnlineAccess()) return - val knownUser = nexusUserInfo if (reference.downloadAuthorization?.isExpired() == true) { requestWebsiteDownloadAuthorization(reference, modInfo, file) return } scope.launch { try { - val user = knownUser ?: apiClient.getCurrentUser().also { nexusUserInfo = it } - val authorizationUserId = reference.downloadAuthorization?.userId - if (authorizationUserId != null && authorizationUserId != user.userId) { + val user = currentNexusUserForDownload(reference, apiClient::getCurrentUser) + if (user == null) { SnackbarManager.show(context.getString(R.string.nexus_authorization_wrong_account)) return@launch } @@ -1893,9 +2045,73 @@ fun NexusModsDialog( importFile(reference, matchingPending.modInfo, matchingPending.file) } + suspend fun receiveBrowserFirstDownload(download: BrowserFirstNexusWebsiteDownload) { + if (download.appId != libraryItem.appId || blockUnavailableOnlineAccess()) return + loadingMessage = context.getString(R.string.nexus_resolving_nexus_mod) + try { + when ( + val resolution = resolveBrowserFirstNexusDownload( + reference = download.reference, + getCurrentUser = apiClient::getCurrentUser, + getModInfo = apiClient::getModInfo, + getModFiles = apiClient::getModFiles, + ) + ) { + is BrowserFirstNexusResolution.Resolved -> { + pendingCollectionSelection = null + pendingFileSelection = PendingFileSelection( + reference = resolution.reference, + modInfo = resolution.modInfo, + files = listOf(resolution.file), + ) + selectedTab = ManageModsTab.IMPORT + } + BrowserFirstNexusResolution.Expired -> { + SnackbarManager.show(context.getString(R.string.nexus_authorization_expired)) + } + BrowserFirstNexusResolution.WrongAccount -> { + SnackbarManager.show(context.getString(R.string.nexus_authorization_wrong_account)) + } + BrowserFirstNexusResolution.MissingFile -> { + SnackbarManager.show(context.getString(R.string.nexus_nxm_file_not_found)) + } + BrowserFirstNexusResolution.Invalid -> { + SnackbarManager.show(context.getString(R.string.nexus_invalid_nxm_callback)) + } + } + } catch (e: CancellationException) { + throw e + } catch (e: Exception) { + SnackbarManager.show( + nexusUserMessage(e, context.getString(R.string.nexus_resolve_url_failed)), + ) + } finally { + if (loadingMessage == context.getString(R.string.nexus_resolving_nexus_mod)) { + loadingMessage = null + } + } + } + if (NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE) { + val currentReceiveAuthorizedDownload = rememberUpdatedState(::receiveAuthorizedDownload) + val currentReceiveBrowserFirstDownload = rememberUpdatedState(::receiveBrowserFirstDownload) + DisposableEffect(libraryItem.appId, nexusAuthState.isConnected) { + val registration = if (nexusAuthState.isConnected) { + NexusDownloadLinkInbox.registerReceiver(libraryItem.appId) + } else { + null + } + onDispose { registration?.unregister() } + } LaunchedEffect(apiClient, libraryItem.appId) { - NexusDownloadLinkInbox.callbacksFor(libraryItem.appId).collect(::receiveAuthorizedDownload) + NexusDownloadLinkInbox.callbacksFor(libraryItem.appId) + .collect { download -> currentReceiveAuthorizedDownload.value(download) } + } + LaunchedEffect(apiClient, libraryItem.appId, nexusAuthState.isConnected) { + if (nexusAuthState.isConnected) { + NexusDownloadLinkInbox.browserFirstCallbacksFor(libraryItem.appId) + .collect { download -> currentReceiveBrowserFirstDownload.value(download) } + } } } @@ -2215,7 +2431,7 @@ fun NexusModsDialog( } val nexusUserForDownloads = if (modsNeedingDownload.isNotEmpty()) { try { - knownUser ?: apiClient.getCurrentUser().also { nexusUserInfo = it } + knownUser ?: apiClient.getCurrentUser() } catch (e: CancellationException) { throw e } catch (e: Exception) { @@ -2811,29 +3027,42 @@ fun NexusModsDialog( if (!NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE) { NexusIntegrationUnavailableSection() } else { - ImportSection( - nexusUrl = nexusUrl, - onUrlChange = { nexusUrl = it }, - onImport = ::resolveUrlAndImport, + NexusOAuthAccountSection( + connected = nexusAuthState.isConnected, + connecting = nexusAuthState.connection == NexusConnectionState.CONNECTING, + accountName = nexusAuthState.account?.name, + premium = nexusAuthState.account?.isPremium, + errorMessage = nexusAuthState.errorMessage, + actionInProgress = nexusAuthActionInProgress, + onConnect = ::connectNexusAccount, + onCancelConnect = NexusAuthManager::cancelAuthorization, + onDisconnect = ::disconnectNexusAccount, ) - pendingFileSelection?.let { pending -> - FileSelectionSection( - pending = pending, - onImport = { file -> - val authorization = pending.reference.downloadAuthorization - ?.takeIf { pending.reference.fileId == file.fileId } - importFile( - reference = pending.reference.copy( - fileId = file.fileId, - downloadAuthorization = authorization, - ), - modInfo = pending.modInfo, - file = file, - ) - }, + if (nexusAuthState.isConnected) { + ImportSection( + nexusUrl = nexusUrl, + onUrlChange = { nexusUrl = it }, + onImport = ::resolveUrlAndImport, ) + pendingFileSelection?.let { pending -> + FileSelectionSection( + pending = pending, + onImport = { file -> + val authorization = pending.reference.downloadAuthorization + ?.takeIf { pending.reference.fileId == file.fileId } + importFile( + reference = pending.reference.copy( + fileId = file.fileId, + downloadAuthorization = authorization, + ), + modInfo = pending.modInfo, + file = file, + ) + }, + ) + } + pendingCollectionSelection?.let { pending -> CollectionSelectionContent(pending) } } - pendingCollectionSelection?.let { pending -> CollectionSelectionContent(pending) } } } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt new file mode 100644 index 0000000000..d4a645a15b --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt @@ -0,0 +1,170 @@ +package app.gamenative.ui.component.dialog + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.filled.AccountCircle +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.Button +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.Icon +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import app.gamenative.R + +@Composable +internal fun NexusOAuthAccountSection( + connected: Boolean, + connecting: Boolean, + accountName: String?, + premium: Boolean?, + errorMessage: String?, + actionInProgress: Boolean, + onConnect: () -> Unit, + onCancelConnect: () -> Unit, + onDisconnect: () -> Unit, +) { + var confirmDisconnect by remember { mutableStateOf(false) } + val busy = actionInProgress + + Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surfaceVariant) { + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(10.dp), + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(8.dp), + ) { + Icon( + Icons.Default.AccountCircle, + contentDescription = null, + tint = MaterialTheme.colorScheme.primary, + ) + Text( + text = stringResource(R.string.nexus_oauth_account_title), + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + ) + } + + Text( + text = when { + actionInProgress -> stringResource(R.string.nexus_oauth_disconnecting) + connecting -> stringResource(R.string.nexus_oauth_connecting) + connected && !accountName.isNullOrBlank() -> { + stringResource(R.string.nexus_oauth_connected_as, accountName) + } + connected -> stringResource(R.string.nexus_oauth_connected) + else -> stringResource(R.string.nexus_oauth_disconnected_description) + }, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + + if (connected && premium != null) { + Text( + text = stringResource( + if (premium) { + R.string.nexus_oauth_premium_account + } else { + R.string.nexus_oauth_free_account + }, + ), + style = MaterialTheme.typography.labelMedium, + color = MaterialTheme.colorScheme.primary, + ) + } + + if (!errorMessage.isNullOrBlank()) { + Text( + text = errorMessage, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } + + if (connected) { + OutlinedButton( + onClick = { confirmDisconnect = true }, + enabled = !busy, + modifier = Modifier.fillMaxWidth(), + ) { + if (busy) { + CircularProgressIndicator(Modifier.size(18.dp), strokeWidth = 2.dp) + Spacer(Modifier.size(8.dp)) + } + Text(stringResource(R.string.nexus_oauth_disconnect)) + } + } else if (connecting) { + OutlinedButton( + onClick = onCancelConnect, + enabled = !busy, + modifier = Modifier.fillMaxWidth(), + ) { + CircularProgressIndicator(Modifier.size(18.dp), strokeWidth = 2.dp) + Spacer(Modifier.size(8.dp)) + Text(stringResource(R.string.nexus_oauth_cancel_sign_in)) + } + } else { + Button( + onClick = onConnect, + enabled = !busy, + modifier = Modifier.fillMaxWidth(), + ) { + if (busy) { + CircularProgressIndicator(Modifier.size(18.dp), strokeWidth = 2.dp) + Spacer(Modifier.size(8.dp)) + } + Text( + stringResource( + if (busy) R.string.nexus_oauth_disconnecting else R.string.nexus_oauth_connect, + ), + ) + } + } + } + } + + if (confirmDisconnect) { + AlertDialog( + onDismissRequest = { confirmDisconnect = false }, + title = { Text(stringResource(R.string.nexus_oauth_disconnect_title)) }, + text = { Text(stringResource(R.string.nexus_oauth_disconnect_message)) }, + confirmButton = { + TextButton( + onClick = { + confirmDisconnect = false + onDisconnect() + }, + ) { + Text(stringResource(R.string.nexus_oauth_disconnect)) + } + }, + dismissButton = { + TextButton(onClick = { confirmDisconnect = false }) { + Text(stringResource(R.string.cancel)) + } + }, + ) + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncher.kt b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncher.kt new file mode 100644 index 0000000000..2beca888f3 --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncher.kt @@ -0,0 +1,29 @@ +package app.gamenative.ui.screen.auth + +import android.content.Context +import android.net.Uri +import androidx.browser.customtabs.CustomTabsIntent + +/** Opens only the Nexus authorization endpoint used by the native OAuth flow. */ +internal object NexusOAuthBrowserLauncher { + private const val AUTHORIZATION_HOST = "users.nexusmods.com" + private const val AUTHORIZATION_PATH = "/oauth/authorize" + + fun launch(context: Context, authorizationUri: Uri): Result = runCatching { + require(isAllowedAuthorizationUri(authorizationUri)) { + "Refusing to open an unexpected Nexus authorization URL" + } + CustomTabsIntent.Builder() + .setShowTitle(true) + .setShareState(CustomTabsIntent.SHARE_STATE_OFF) + .build() + .launchUrl(context, authorizationUri) + } + + internal fun isAllowedAuthorizationUri(uri: Uri): Boolean = + uri.isHierarchical && + uri.scheme == "https" && + uri.encodedAuthority == AUTHORIZATION_HOST && + uri.encodedPath == AUTHORIZATION_PATH && + uri.fragment == null +} diff --git a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt new file mode 100644 index 0000000000..2b82db3846 --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt @@ -0,0 +1,84 @@ +package app.gamenative.ui.screen.auth + +import android.content.Intent +import android.os.Bundle +import androidx.activity.ComponentActivity +import androidx.lifecycle.lifecycleScope +import app.gamenative.MainActivity +import app.gamenative.R +import app.gamenative.mods.NexusAuthManager +import app.gamenative.ui.util.SnackbarManager +import kotlinx.coroutines.Job +import kotlinx.coroutines.launch +import timber.log.Timber + +/** + * Minimal trampoline for the browser-based Nexus OAuth redirect. + * + * The callback URI is scrubbed from both the source intent and the Activity's retained intent + * before any suspension point. This prevents Android from replaying an authorization code after + * recreation or exposing it through a later inspection of the launch intent. + */ +class NexusOAuthCallbackActivity : ComponentActivity() { + private var callbackJob: Job? = null + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + receiveCallback(intent) + } + + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + receiveCallback(intent) + } + + private fun receiveCallback(sourceIntent: Intent) { + val callbackUri = NexusOAuthCallbackContract.consumeAndScrub(sourceIntent) + setIntent(Intent(this, NexusOAuthCallbackActivity::class.java)) + + if (callbackUri == null) { + Timber.w("[NexusOAuth]: Rejected an intent that did not match the registered redirect") + SnackbarManager.show(getString(R.string.nexus_oauth_invalid_callback)) + returnToApp() + return + } + if (callbackJob?.isActive == true) { + Timber.w("[NexusOAuth]: Ignoring a second callback while one is already being processed") + return + } + + callbackJob = lifecycleScope.launch { + NexusAuthManager.handleAuthorizationCallback(callbackUri) + .onSuccess { account -> + if (account != null) { + SnackbarManager.show( + getString(R.string.nexus_oauth_connected_as, account.name), + ) + } + } + .onFailure { error -> + // Do not log exception messages here: OAuth server errors can include + // callback details that do not belong in application logs. + Timber.w( + "[NexusOAuth]: Browser sign-in did not complete (%s)", + error.javaClass.simpleName, + ) + SnackbarManager.show(getString(R.string.nexus_oauth_sign_in_failed)) + } + returnToApp() + } + } + + private fun returnToApp() { + startActivity( + Intent(this, MainActivity::class.java) + .setAction(Intent.ACTION_MAIN) + .addFlags( + Intent.FLAG_ACTIVITY_NEW_TASK or + Intent.FLAG_ACTIVITY_CLEAR_TOP or + Intent.FLAG_ACTIVITY_SINGLE_TOP, + ), + ) + finish() + } +} diff --git a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContract.kt b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContract.kt new file mode 100644 index 0000000000..a1dbbd5c20 --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContract.kt @@ -0,0 +1,38 @@ +package app.gamenative.ui.screen.auth + +import android.content.Intent +import android.net.Uri +import android.os.Bundle +import app.gamenative.mods.NexusOAuthConfig + +/** + * The exact native redirect registered for GameNative with Nexus Mods. + * + * Keep this check in addition to the manifest intent filter. Exported activities can be + * launched explicitly, bypassing their filters, and an OAuth authorization code must never + * be accepted from a look-alike URI. + */ +internal object NexusOAuthCallbackContract { + private val callbackUri = Uri.parse(NexusOAuthConfig.REDIRECT_URI) + + fun matches(intent: Intent?): Boolean = + intent?.action == Intent.ACTION_VIEW && matches(intent.data) + + /** Returns a matching URI and removes all callback-bearing data from [intent]. */ + fun consumeAndScrub(intent: Intent): Uri? { + val callbackUri = intent.takeIf(::matches)?.data + intent.data = null + intent.clipData = null + intent.selector = null + intent.replaceExtras(null as Bundle?) + return callbackUri + } + + fun matches(uri: Uri?): Boolean = + uri != null && + uri.isHierarchical && + uri.scheme == callbackUri.scheme && + uri.encodedAuthority == callbackUri.encodedAuthority && + uri.encodedPath == callbackUri.encodedPath && + uri.fragment == null +} diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 68132fc377..53a4e123a8 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -1574,9 +1574,32 @@ Placering Manuel Ikke understøttet + Nexus Mods-konto + Opret forbindelse til Nexus Mods + Opretter forbindelse til Nexus Mods… + Annuller login + Forbundet til Nexus Mods + Forbundet som %1$s + Opret forbindelse til din Nexus Mods-konto for at gennemse og importere mods og samlinger. + Premium-konto + Gratis konto + Afbryd forbindelsen + Afbryder forbindelsen til Nexus Mods… + Afbryd forbindelsen til Nexus Mods? + GameNative tilbagekalder denne kontos Nexus-tokens på denne enhed. Installerede mods og lokale filer fjernes ikke. + Forbindelsen til Nexus Mods-kontoen er afbrudt. + Login på Nexus Mods blev ikke gennemført. Prøv at oprette forbindelse igen. + Forbindelsen til Nexus Mods-kontoen kunne ikke afbrydes. Prøv igen. + Login på Nexus Mods kunne ikke åbnes i en browser. + GameNative afviste et ugyldigt svar fra Nexus Mods-login. + Opret forbindelse til en Nexus Mods-konto, før du bruger Nexus-onlinefunktioner. + Nexus-godkendelse er midlertidigt utilgængelig. Prøv igen. Understøttelse af Nexus Mods er midlertidigt deaktiveret, mens GameNative bliver registreret hos Nexus Mods. Allerede installerede mods kan stadig administreres. Denne Nexus-godkendelse er ugyldig, udløbet, allerede brugt eller svarer ikke længere til en aktiv GameNative-anmodning. Start downloadingen fra Administrer Nexus-mods igen. Godkendelse af Nexus-download modtaget. Gå tilbage til Administrer Nexus-mods, hvis downloadingen ikke genoptages automatisk. + Åbn Administrer Nexus-mods for destinationsspillet, og tryk derefter på Mod Manager Download på Nexus Mods igen. + GameNative kan ikke vælge sikkert mellem flere åbne mod-dialoger. Luk den ekstra dialog, og prøv Mod Manager Download igen. + Nexus godkendte en fil, der ikke længere er tilgængelig for denne mod. Anmod om downloadingen igen. Nexus kræver bekræftelse på webstedet for denne konto. Vælg Download with Manager og derefter Slow Download i browseren; GameNative genoptager automatisk. Nexus Mods kunne ikke åbnes i en browser. Godkendelsen på Nexus-webstedet fik timeout. Prøv filen igen, og fuldfør Download with Manager i browseren. diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index f8e1f16d9b..d7f661002e 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -1644,9 +1644,32 @@ Platzierung Manuell Nicht unterstützt + Nexus-Mods-Konto + Mit Nexus Mods verbinden + Verbindung mit Nexus Mods wird hergestellt… + Anmeldung abbrechen + Mit Nexus Mods verbunden + Verbunden als %1$s + Verbinde dein Nexus-Mods-Konto, um Mods und Sammlungen zu durchsuchen und zu importieren. + Premium-Konto + Kostenloses Konto + Trennen + Verbindung mit Nexus Mods wird getrennt… + Verbindung zu Nexus Mods trennen? + GameNative widerruft die Nexus-Token dieses Kontos auf diesem Gerät. Installierte Mods und lokale Dateien werden nicht entfernt. + Nexus-Mods-Konto getrennt. + Die Anmeldung bei Nexus Mods wurde nicht abgeschlossen. Versuche erneut, eine Verbindung herzustellen. + Das Nexus-Mods-Konto konnte nicht getrennt werden. Versuche es erneut. + Die Anmeldung bei Nexus Mods konnte nicht in einem Browser geöffnet werden. + GameNative hat eine ungültige Anmeldeantwort von Nexus Mods abgelehnt. + Verbinde ein Nexus-Mods-Konto, bevor du Onlinefunktionen von Nexus verwendest. + Die Nexus-Autorisierung ist vorübergehend nicht verfügbar. Versuche es erneut. Die Nexus-Mods-Unterstützung wurde vorübergehend deaktiviert, während GameNative bei Nexus Mods registriert wird. Bereits installierte Mods können weiterhin verwaltet werden. Diese Nexus-Autorisierung ist ungültig, abgelaufen, wurde bereits verwendet oder entspricht keiner aktiven GameNative-Anfrage mehr. Starte den Download erneut über Nexus-Mods verwalten. Nexus-Download-Autorisierung erhalten. Kehre zu Nexus-Mods verwalten zurück, falls der Download nicht automatisch fortgesetzt wird. + Öffne „Nexus-Mods verwalten“ für das Zielspiel und tippe dann in Nexus Mods erneut auf Mod Manager Download. + GameNative kann nicht sicher zwischen mehreren geöffneten Mod-Dialogen wählen. Schließe den zusätzlichen Dialog und versuche Mod Manager Download erneut. + Nexus hat eine Datei autorisiert, die für diese Mod nicht mehr verfügbar ist. Fordere den Download erneut an. Nexus erfordert für dieses Konto eine Bestätigung auf der Website. Wähle im Browser Download with Manager und anschließend Slow Download aus; GameNative fährt automatisch fort. Nexus Mods konnte nicht in einem Browser geöffnet werden. Zeitüberschreitung bei der Autorisierung auf der Nexus-Website. Versuche die Datei erneut und schließe Download with Manager im Browser ab. diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 427159ce24..82dde47ce2 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -1702,9 +1702,32 @@ Ubicación Manual No compatible + Cuenta de Nexus Mods + Conectar con Nexus Mods + Conectando con Nexus Mods… + Cancelar inicio de sesión + Conectado con Nexus Mods + Conectado como %1$s + Conecta tu cuenta de Nexus Mods para explorar e importar mods y colecciones. + Cuenta premium + Cuenta gratuita + Desconectar + Desconectando de Nexus Mods… + ¿Desconectar Nexus Mods? + GameNative revocará los tokens de Nexus de esta cuenta en este dispositivo. No se eliminarán los mods instalados ni los archivos locales. + Cuenta de Nexus Mods desconectada. + El inicio de sesión en Nexus Mods no se completó. Intenta conectarte de nuevo. + No se pudo desconectar la cuenta de Nexus Mods. Inténtalo de nuevo. + No se pudo abrir el inicio de sesión de Nexus Mods en un navegador. + GameNative rechazó una respuesta de inicio de sesión no válida de Nexus Mods. + Conecta una cuenta de Nexus Mods antes de usar las funciones en línea de Nexus. + La autorización de Nexus no está disponible temporalmente. Inténtalo de nuevo. La compatibilidad con Nexus Mods se ha desactivado temporalmente mientras GameNative se registra en Nexus Mods. Los mods ya instalados se pueden seguir administrando. Esta autorización de Nexus no es válida, ha caducado, ya se utilizó o ya no coincide con una solicitud activa de GameNative. Inicia de nuevo la descarga desde Administrar mods de Nexus. Se recibió la autorización de descarga de Nexus. Vuelve a Administrar mods de Nexus si la descarga no se reanuda automáticamente. + Abre Administrar mods de Nexus para el juego de destino y luego vuelve a tocar Mod Manager Download en Nexus Mods. + GameNative no puede elegir de forma segura entre varias ventanas de mods abiertas. Cierra la ventana adicional y vuelve a intentar Mod Manager Download. + Nexus autorizó un archivo que ya no está disponible para este mod. Solicita de nuevo la descarga. Nexus requiere confirmación en el sitio web para esta cuenta. En el navegador, selecciona Download with Manager y luego Slow Download; GameNative reanudará la descarga automáticamente. No se pudo abrir Nexus Mods en un navegador. Se agotó el tiempo de espera de la autorización en el sitio web de Nexus. Reintenta el archivo y completa Download with Manager en el navegador. diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 3dd7479c3b..928934755d 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -1722,9 +1722,32 @@ Placement Manuel Non pris en charge + Compte Nexus Mods + Se connecter à Nexus Mods + Connexion à Nexus Mods… + Annuler la connexion + Connecté à Nexus Mods + Connecté en tant que %1$s + Connectez votre compte Nexus Mods pour parcourir et importer des mods et des collections. + Compte premium + Compte gratuit + Déconnecter + Déconnexion de Nexus Mods… + Se déconnecter de Nexus Mods ? + GameNative révoquera les jetons Nexus de ce compte sur cet appareil. Les mods installés et les fichiers locaux ne seront pas supprimés. + Compte Nexus Mods déconnecté. + La connexion à Nexus Mods n’a pas abouti. Essayez de vous connecter à nouveau. + Impossible de déconnecter le compte Nexus Mods. Réessayez. + Impossible d’ouvrir la connexion à Nexus Mods dans un navigateur. + GameNative a rejeté une réponse de connexion invalide de Nexus Mods. + Connectez un compte Nexus Mods avant d’utiliser les fonctionnalités Nexus en ligne. + L’autorisation Nexus est temporairement indisponible. Réessayez. La prise en charge de Nexus Mods est temporairement désactivée pendant l’enregistrement de GameNative auprès de Nexus Mods. Les mods déjà installés peuvent toujours être gérés. Cette autorisation Nexus est invalide, a expiré, a déjà été utilisée ou ne correspond plus à une requête GameNative active. Relancez le téléchargement depuis Gérer les mods Nexus. Autorisation de téléchargement Nexus reçue. Revenez dans Gérer les mods Nexus si le téléchargement ne reprend pas automatiquement. + Ouvrez Gérer les mods Nexus pour le jeu de destination, puis touchez à nouveau Mod Manager Download sur Nexus Mods. + GameNative ne peut pas choisir en toute sécurité parmi plusieurs fenêtres de mods ouvertes. Fermez la fenêtre superflue et réessayez avec Mod Manager Download. + Nexus a autorisé un fichier qui n’est plus disponible pour ce mod. Demandez à nouveau le téléchargement. Nexus exige une confirmation sur son site Web pour ce compte. Dans le navigateur, choisissez Download with Manager, puis Slow Download ; GameNative reprendra automatiquement. Impossible d’ouvrir Nexus Mods dans un navigateur. Le délai d’autorisation sur le site Web de Nexus a expiré. Réessayez le fichier et terminez Download with Manager dans le navigateur. diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 69e213cebc..1675941165 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -1695,9 +1695,32 @@ Posizionamento Manuale Non supportato + Account Nexus Mods + Connetti Nexus Mods + Connessione a Nexus Mods… + Annulla accesso + Connesso a Nexus Mods + Connesso come %1$s + Connetti il tuo account Nexus Mods per sfogliare e importare mod e raccolte. + Account premium + Account gratuito + Disconnetti + Disconnessione da Nexus Mods… + Disconnettere Nexus Mods? + GameNative revocherà i token Nexus di questo account sul dispositivo. Le mod installate e i file locali non verranno rimossi. + Account Nexus Mods disconnesso. + L’accesso a Nexus Mods non è stato completato. Prova a connetterti di nuovo. + Impossibile disconnettere l’account Nexus Mods. Riprova. + Impossibile aprire l’accesso a Nexus Mods in un browser. + GameNative ha rifiutato una risposta di accesso non valida da Nexus Mods. + Connetti un account Nexus Mods prima di usare le funzionalità online di Nexus. + L’autorizzazione Nexus è temporaneamente non disponibile. Riprova. Il supporto per Nexus Mods è stato temporaneamente disattivato mentre GameNative viene registrato su Nexus Mods. Le mod già installate possono ancora essere gestite. Questa autorizzazione Nexus non è valida, è scaduta, è già stata usata o non corrisponde più a una richiesta GameNative attiva. Avvia di nuovo il download da Gestisci mod Nexus. Autorizzazione al download da Nexus ricevuta. Torna a Gestisci mod Nexus se il download non riprende automaticamente. + Apri Gestisci mod Nexus per il gioco di destinazione, quindi tocca di nuovo Mod Manager Download su Nexus Mods. + GameNative non può scegliere in sicurezza tra più finestre di mod aperte. Chiudi la finestra aggiuntiva e riprova Mod Manager Download. + Nexus ha autorizzato un file che non è più disponibile per questa mod. Richiedi di nuovo il download. Nexus richiede una conferma sul sito web per questo account. Nel browser, scegli Download with Manager e poi Slow Download; GameNative riprenderà automaticamente. Impossibile aprire Nexus Mods in un browser. L’autorizzazione sul sito web di Nexus è scaduta. Riprova il file e completa Download with Manager nel browser. diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 3787795feb..b8d6f6dab9 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -1660,9 +1660,32 @@ 配置 手動 未対応 + Nexus Mods アカウント + Nexus Mods に接続 + Nexus Mods に接続しています… + サインインをキャンセル + Nexus Mods に接続済み + %1$s として接続済み + Nexus Mods アカウントに接続すると、Mod やコレクションを参照してインポートできます。 + プレミアムアカウント + 無料アカウント + 接続を解除 + Nexus Mods との接続を解除しています… + Nexus Mods との接続を解除しますか？ + GameNative は、このデバイス上にあるこのアカウントの Nexus トークンを失効させます。インストール済みの Mod とローカルファイルは削除されません。 + Nexus Mods アカウントとの接続を解除しました。 + Nexus Mods へのサインインが完了しませんでした。もう一度接続してください。 + Nexus Mods アカウントとの接続を解除できませんでした。もう一度お試しください。 + ブラウザで Nexus Mods のサインインを開けませんでした。 + GameNative は Nexus Mods からの無効なサインイン応答を拒否しました。 + Nexus のオンライン機能を使用する前に、Nexus Mods アカウントへ接続してください。 + Nexus の認証を一時的に利用できません。もう一度お試しください。 GameNative を Nexus Mods に登録している間、Nexus Mods サポートは一時的に無効になっています。インストール済みの Mod は引き続き管理できます。 この Nexus 認証は無効か期限切れ、使用済み、または GameNative の有効なリクエストと一致しません。もう一度「Nexus Mod を管理」からダウンロードを開始してください。 Nexus のダウンロード認証を受信しました。ダウンロードが自動的に再開しない場合は、「Nexus Mod を管理」に戻ってください。 + 対象ゲームの「Nexus Mod を管理」を開き、Nexus Mods でもう一度「Mod Manager Download」をタップしてください。 + 複数の Mod ダイアログが開いているため、GameNative は安全に選択できません。余分なダイアログを閉じて、もう一度「Mod Manager Download」をお試しください。 + Nexus が認証したファイルは、この Mod では利用できなくなっています。もう一度ダウンロードをリクエストしてください。 このアカウントでは、Nexus のウェブサイトでの確認が必要です。ブラウザで「Download with Manager」、続いて「Slow Download」を選択してください。GameNative が自動的に再開します。 ブラウザで Nexus Mods を開けませんでした。 Nexus ウェブサイトでの認証がタイムアウトしました。ファイルを再試行し、ブラウザで「Download with Manager」を完了してください。 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 97cb10a2fe..bd259d8e18 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -1701,9 +1701,32 @@ 배치 수동 지원 안 됨 + Nexus Mods 계정 + Nexus Mods 연결 + Nexus Mods에 연결하는 중… + 로그인 취소 + Nexus Mods에 연결됨 + %1$s 계정으로 연결됨 + 모드와 컬렉션을 찾아보고 가져오려면 Nexus Mods 계정을 연결하세요. + 프리미엄 계정 + 무료 계정 + 연결 해제 + Nexus Mods 연결을 해제하는 중… + Nexus Mods 연결을 해제하시겠습니까? + GameNative가 이 기기에서 이 계정의 Nexus 토큰을 취소합니다. 설치된 모드와 로컬 파일은 삭제되지 않습니다. + Nexus Mods 계정 연결이 해제되었습니다. + Nexus Mods 로그인이 완료되지 않았습니다. 다시 연결해 보세요. + Nexus Mods 계정 연결을 해제할 수 없습니다. 다시 시도하세요. + 브라우저에서 Nexus Mods 로그인을 열 수 없습니다. + GameNative가 잘못된 Nexus Mods 로그인 응답을 거부했습니다. + Nexus 온라인 기능을 사용하기 전에 Nexus Mods 계정을 연결하세요. + Nexus 인증을 일시적으로 사용할 수 없습니다. 다시 시도하세요. GameNative를 Nexus Mods에 등록하는 동안 Nexus Mods 지원이 일시적으로 비활성화되었습니다. 이미 설치된 모드는 계속 관리할 수 있습니다. 이 Nexus 인증은 유효하지 않거나 만료되었거나 이미 사용되었거나, 더 이상 활성 GameNative 요청과 일치하지 않습니다. Nexus 모드 관리에서 다운로드를 다시 시작하세요. Nexus 다운로드 인증을 받았습니다. 다운로드가 자동으로 재개되지 않으면 Nexus 모드 관리로 돌아가세요. + 대상 게임의 Nexus 모드 관리를 연 다음 Nexus Mods에서 Mod Manager Download를 다시 탭하세요. + 열려 있는 모드 대화상자가 여러 개라 GameNative에서 안전하게 선택할 수 없습니다. 추가 대화상자를 닫고 Mod Manager Download를 다시 시도하세요. + Nexus가 인증한 파일을 이 모드에서 더 이상 사용할 수 없습니다. 다운로드를 다시 요청하세요. 이 계정은 Nexus 웹사이트에서 확인해야 합니다. 브라우저에서 Download with Manager를 선택한 다음 Slow Download를 선택하세요. GameNative가 자동으로 재개됩니다. 브라우저에서 Nexus Mods를 열 수 없습니다. Nexus 웹사이트 인증 시간이 초과되었습니다. 파일을 다시 시도하고 브라우저에서 Download with Manager를 완료하세요. diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 3794bebdab..131fe34821 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -1704,9 +1704,32 @@ Umieszczenie Ręczne Nieobsługiwane + Konto Nexus Mods + Połącz z Nexus Mods + Łączenie z Nexus Mods… + Anuluj logowanie + Połączono z Nexus Mods + Połączono jako %1$s + Połącz konto Nexus Mods, aby przeglądać i importować mody oraz kolekcje. + Konto premium + Konto bezpłatne + Odłącz + Odłączanie od Nexus Mods… + Odłączyć konto Nexus Mods? + GameNative unieważni tokeny Nexus tego konta na tym urządzeniu. Zainstalowane mody ani pliki lokalne nie zostaną usunięte. + Konto Nexus Mods zostało odłączone. + Logowanie w Nexus Mods nie zostało ukończone. Spróbuj połączyć się ponownie. + Nie udało się odłączyć konta Nexus Mods. Spróbuj ponownie. + Nie udało się otworzyć logowania do Nexus Mods w przeglądarce. + GameNative odrzucił nieprawidłową odpowiedź logowania z Nexus Mods. + Przed użyciem funkcji online Nexus połącz konto Nexus Mods. + Autoryzacja Nexus jest tymczasowo niedostępna. Spróbuj ponownie. Obsługa Nexus Mods została tymczasowo wyłączona na czas rejestracji GameNative w Nexus Mods. Nadal możesz zarządzać już zainstalowanymi modami. Ta autoryzacja Nexus jest nieprawidłowa, wygasła, została już użyta albo nie odpowiada już aktywnemu żądaniu GameNative. Ponownie rozpocznij pobieranie na ekranie „Zarządzaj modami Nexus”. Otrzymano autoryzację pobierania z Nexus. Wróć do ekranu „Zarządzaj modami Nexus”, jeśli pobieranie nie zostanie automatycznie wznowione. + Otwórz ekran „Zarządzaj modami Nexus” dla gry docelowej, a następnie ponownie wybierz Mod Manager Download w Nexus Mods. + GameNative nie może bezpiecznie wybrać spośród kilku otwartych okien modów. Zamknij dodatkowe okno i ponownie wybierz Mod Manager Download. + Nexus autoryzował plik, który nie jest już dostępny dla tego moda. Ponownie rozpocznij jego pobieranie. Nexus wymaga potwierdzenia w witrynie dla tego konta. W przeglądarce wybierz Download with Manager, a następnie Slow Download; GameNative automatycznie wznowi pobieranie. Nie udało się otworzyć Nexus Mods w przeglądarce. Upłynął limit czasu autoryzacji w witrynie Nexus. Ponów próbę pobrania pliku i dokończ Download with Manager w przeglądarce. diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index bbf24b52ff..94708d1101 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -1574,9 +1574,32 @@ Local Manual Não compatível + Conta do Nexus Mods + Conectar ao Nexus Mods + Conectando ao Nexus Mods… + Cancelar login + Conectado ao Nexus Mods + Conectado como %1$s + Conecte sua conta do Nexus Mods para navegar e importar mods e coleções. + Conta premium + Conta gratuita + Desconectar + Desconectando do Nexus Mods… + Desconectar do Nexus Mods? + O GameNative revogará os tokens do Nexus desta conta neste dispositivo. Os mods instalados e os arquivos locais não serão removidos. + Conta do Nexus Mods desconectada. + O login no Nexus Mods não foi concluído. Tente conectar novamente. + Não foi possível desconectar a conta do Nexus Mods. Tente novamente. + Não foi possível abrir o login do Nexus Mods em um navegador. + O GameNative rejeitou uma resposta de login inválida do Nexus Mods. + Conecte uma conta do Nexus Mods antes de usar os recursos online do Nexus. + A autorização do Nexus está temporariamente indisponível. Tente novamente. O suporte ao Nexus Mods foi temporariamente desativado enquanto o GameNative está sendo registrado no Nexus Mods. Os mods já instalados ainda podem ser gerenciados. Esta autorização do Nexus é inválida, expirou, já foi usada ou não corresponde mais a uma solicitação ativa do GameNative. Inicie o download novamente em Gerenciar mods Nexus. Autorização de download do Nexus recebida. Volte para Gerenciar mods Nexus se o download não for retomado automaticamente. + Abra Gerenciar mods Nexus para o jogo de destino e toque em Mod Manager Download novamente no Nexus Mods. + O GameNative não pode escolher com segurança entre várias janelas de mods abertas. Feche a janela adicional e tente Mod Manager Download novamente. + O Nexus autorizou um arquivo que não está mais disponível para este mod. Solicite o download novamente. O Nexus exige uma confirmação no site para esta conta. No navegador, escolha Download with Manager e depois Slow Download; o GameNative retomará automaticamente. Não foi possível abrir o Nexus Mods em um navegador. A autorização no site do Nexus expirou. Tente baixar o arquivo novamente e conclua Download with Manager no navegador. diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 751d77e339..2987833fa3 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -1706,9 +1706,32 @@ Plasare Manual Neacceptat + Cont Nexus Mods + Conectează Nexus Mods + Se conectează la Nexus Mods… + Anulează autentificarea + Conectat la Nexus Mods + Conectat ca %1$s + Conectează-ți contul Nexus Mods pentru a răsfoi și importa moduri și colecții. + Cont premium + Cont gratuit + Deconectează + Se deconectează de la Nexus Mods… + Deconectezi Nexus Mods? + GameNative va revoca tokenurile Nexus ale acestui cont de pe acest dispozitiv. Modurile instalate și fișierele locale nu vor fi eliminate. + Contul Nexus Mods a fost deconectat. + Autentificarea la Nexus Mods nu s-a finalizat. Încearcă să te conectezi din nou. + Contul Nexus Mods nu a putut fi deconectat. Încearcă din nou. + Autentificarea la Nexus Mods nu a putut fi deschisă într-un browser. + GameNative a respins un răspuns nevalid de autentificare de la Nexus Mods. + Conectează un cont Nexus Mods înainte de a utiliza funcțiile Nexus online. + Autorizarea Nexus este indisponibilă temporar. Încearcă din nou. Suportul pentru Nexus Mods a fost dezactivat temporar cât timp GameNative este în curs de înregistrare la Nexus Mods. Modurile deja instalate pot fi gestionate în continuare. Această autorizare Nexus este nevalidă, a expirat, a fost deja utilizată sau nu mai corespunde unei solicitări GameNative active. Pornește din nou descărcarea din „Gestionează modurile Nexus”. Autorizarea descărcării Nexus a fost primită. Revino la „Gestionează modurile Nexus” dacă descărcarea nu se reia automat. + Deschide „Gestionează modurile Nexus” pentru jocul de destinație, apoi atinge din nou Mod Manager Download pe Nexus Mods. + GameNative nu poate alege în siguranță între mai multe dialoguri de mod deschise. Închide dialogul suplimentar și încearcă din nou Mod Manager Download. + Nexus a autorizat un fișier care nu mai este disponibil pentru acest mod. Solicită din nou descărcarea. Nexus necesită confirmarea pe site pentru acest cont. În browser, alege Download with Manager, apoi Slow Download; GameNative va relua automat descărcarea. Nexus Mods nu a putut fi deschis într-un browser. Autorizarea pe site-ul Nexus a expirat. Reîncearcă fișierul și finalizează Download with Manager în browser. diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 1812132be3..69b69abd4d 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -1632,9 +1632,32 @@ https://gamenative.app Размещение Вручную Не поддерживается + Учётная запись Nexus Mods + Подключить Nexus Mods + Подключение к Nexus Mods… + Отменить вход + Подключено к Nexus Mods + Подключено как %1$s + Подключите учётную запись Nexus Mods, чтобы просматривать и импортировать моды и коллекции. + Учётная запись Premium + Бесплатная учётная запись + Отключить + Отключение от Nexus Mods… + Отключиться от Nexus Mods? + GameNative отзовёт токены Nexus этой учётной записи на данном устройстве. Установленные моды и локальные файлы удалены не будут. + Учётная запись Nexus Mods отключена. + Не удалось завершить вход в Nexus Mods. Попробуйте подключиться снова. + Не удалось отключить учётную запись Nexus Mods. Повторите попытку. + Не удалось открыть вход в Nexus Mods в браузере. + GameNative отклонил недействительный ответ на вход от Nexus Mods. + Подключите учётную запись Nexus Mods, прежде чем использовать онлайн-функции Nexus. + Авторизация Nexus временно недоступна. Повторите попытку. Поддержка Nexus Mods временно отключена, пока GameNative проходит регистрацию в Nexus Mods. Уже установленными модами по-прежнему можно управлять. Эта авторизация Nexus недействительна, истекла, уже использована или больше не соответствует активному запросу GameNative. Снова начните загрузку в разделе «Управление модами Nexus». Авторизация загрузки Nexus получена. Вернитесь в раздел «Управление модами Nexus», если загрузка не возобновится автоматически. + Откройте раздел «Управление модами Nexus» для нужной игры, затем снова нажмите Mod Manager Download на Nexus Mods. + GameNative не может безопасно выбрать одно из нескольких открытых окон управления модами. Закройте лишнее окно и повторите Mod Manager Download. + Nexus авторизовал файл, который больше недоступен для этого мода. Запросите загрузку снова. Nexus требует подтверждения на сайте для этой учётной записи. В браузере выберите Download with Manager, а затем Slow Download; GameNative автоматически возобновит загрузку. Не удалось открыть Nexus Mods в браузере. Время ожидания авторизации на сайте Nexus истекло. Повторите попытку для файла и завершите Download with Manager в браузере. diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index d86322c79c..7f009af0b5 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -1700,9 +1700,32 @@ Розміщення Вручну Не підтримується + Обліковий запис Nexus Mods + Підключити Nexus Mods + Підключення до Nexus Mods… + Скасувати вхід + Підключено до Nexus Mods + Підключено як %1$s + Підключіть обліковий запис Nexus Mods, щоб переглядати й імпортувати моди та колекції. + Обліковий запис Premium + Безкоштовний обліковий запис + Відключити + Відключення від Nexus Mods… + Відключитися від Nexus Mods? + GameNative відкличе токени Nexus цього облікового запису на цьому пристрої. Встановлені моди та локальні файли не буде видалено. + Обліковий запис Nexus Mods відключено. + Не вдалося завершити вхід у Nexus Mods. Спробуйте підключитися знову. + Не вдалося відключити обліковий запис Nexus Mods. Повторіть спробу. + Не вдалося відкрити вхід у Nexus Mods у браузері. + GameNative відхилив недійсну відповідь на вхід від Nexus Mods. + Підключіть обліковий запис Nexus Mods, перш ніж використовувати онлайн-функції Nexus. + Авторизація Nexus тимчасово недоступна. Повторіть спробу. Підтримку Nexus Mods тимчасово вимкнено, поки GameNative проходить реєстрацію в Nexus Mods. Уже встановленими модами все ще можна керувати. Ця авторизація Nexus недійсна, прострочена, уже використана або більше не відповідає активному запиту GameNative. Знову почніть завантаження в розділі «Керування модами Nexus». Авторизацію завантаження Nexus отримано. Поверніться до розділу «Керування модами Nexus», якщо завантаження не продовжиться автоматично. + Відкрийте розділ «Керування модами Nexus» для потрібної гри, а потім знову торкніться Mod Manager Download на Nexus Mods. + GameNative не може безпечно вибрати одне з кількох відкритих вікон керування модами. Закрийте зайве вікно й повторіть Mod Manager Download. + Nexus авторизував файл, який більше недоступний для цього мода. Запросіть завантаження знову. Nexus вимагає підтвердження на вебсайті для цього облікового запису. У браузері виберіть Download with Manager, а потім Slow Download; GameNative автоматично продовжить завантаження. Не вдалося відкрити Nexus Mods у браузері. Час очікування авторизації на вебсайті Nexus минув. Повторіть спробу для файлу та завершіть Download with Manager у браузері. diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 634d2a888e..710e7dd7fa 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -1721,9 +1721,32 @@ 放置 手动 不支持 + Nexus Mods 账号 + 连接 Nexus Mods + 正在连接 Nexus Mods… + 取消登录 + 已连接到 Nexus Mods + 已以 %1$s 身份连接 + 连接您的 Nexus Mods 账号以浏览和导入模组及合集。 + 高级账号 + 免费账号 + 断开连接 + 正在断开与 Nexus Mods 的连接… + 断开 Nexus Mods 连接？ + GameNative 将撤销此设备上该账号的 Nexus 令牌。已安装的模组和本地文件不会被删除。 + 已断开 Nexus Mods 账号连接。 + Nexus Mods 登录未完成。请重新连接。 + 无法断开 Nexus Mods 账号连接。请重试。 + 无法在浏览器中打开 Nexus Mods 登录页面。 + GameNative 已拒绝无效的 Nexus Mods 登录响应。 + 使用 Nexus 在线功能前，请先连接 Nexus Mods 账号。 + Nexus 授权暂时不可用。请重试。 在 GameNative 向 Nexus Mods 注册期间，Nexus Mods 支持已暂时停用。仍可继续管理已安装的模组。 此 Nexus 授权无效、已过期、已被使用，或不再与有效的 GameNative 请求匹配。请从“管理 Nexus 模组”重新开始下载。 已收到 Nexus 下载授权。如果下载没有自动继续，请返回“管理 Nexus 模组”。 + 打开目标游戏的“管理 Nexus 模组”，然后再次点击 Nexus Mods 上的 Mod Manager Download。 + GameNative 无法在多个已打开的模组对话框之间安全选择。请关闭多余的对话框，然后重试 Mod Manager Download。 + Nexus 授权的文件已不再由此模组提供。请重新请求下载。 此账号需要在 Nexus 网站上确认。请在浏览器中依次选择“Download with Manager”和“Slow Download”，GameNative 将自动继续。 无法在浏览器中打开 Nexus Mods。 Nexus 网站授权超时。请重试此文件，并在浏览器中完成“Download with Manager”操作。 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index d0f63734d8..9243ca7656 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -1712,9 +1712,32 @@ 放置 手動 不支援 + Nexus Mods 帳號 + 連結至 Nexus Mods + 正在連結至 Nexus Mods… + 取消登入 + 已連結至 Nexus Mods + 已以 %1$s 身分連結 + 連結您的 Nexus Mods 帳號以瀏覽及匯入模組與收藏。 + 高級帳號 + 免費帳號 + 解除連結 + 正在解除與 Nexus Mods 的連結… + 解除 Nexus Mods 連結？ + GameNative 將撤銷此裝置上該帳號的 Nexus 權杖。已安裝的模組與本機檔案不會被移除。 + 已解除 Nexus Mods 帳號連結。 + Nexus Mods 登入未完成。請重新連結。 + 無法解除 Nexus Mods 帳號連結。請再試一次。 + 無法在瀏覽器中開啟 Nexus Mods 登入頁面。 + GameNative 已拒絕無效的 Nexus Mods 登入回應。 + 使用 Nexus 線上功能前，請先連結 Nexus Mods 帳號。 + Nexus 授權暫時無法使用。請再試一次。 在 GameNative 向 Nexus Mods 註冊期間，Nexus Mods 支援已暫時停用。仍可繼續管理已安裝的模組。 此 Nexus 授權無效、已過期、已使用，或不再符合有效的 GameNative 要求。請從「管理 Nexus 模組」重新開始下載。 已收到 Nexus 下載授權。如果下載未自動繼續，請返回「管理 Nexus 模組」。 + 開啟目標遊戲的「管理 Nexus 模組」，然後再次點選 Nexus Mods 上的 Mod Manager Download。 + GameNative 無法在多個已開啟的模組對話框之間安全選擇。請關閉多餘的對話框，然後重試 Mod Manager Download。 + Nexus 授權的檔案已不再由此模組提供。請重新要求下載。 此帳號需要在 Nexus 網站上確認。請在瀏覽器中依序選擇「Download with Manager」和「Slow Download」，GameNative 將自動繼續。 無法在瀏覽器中開啟 Nexus Mods。 Nexus 網站授權逾時。請重試此檔案，並在瀏覽器中完成「Download with Manager」操作。 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index c34c5719dd..dead7a0b3c 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1754,9 +1754,32 @@ Placement Manual Unsupported + Nexus Mods account + Connect Nexus Mods + Connecting to Nexus Mods… + Cancel sign-in + Connected to Nexus Mods + Connected as %1$s + Connect your Nexus Mods account to browse and import mods and collections. + Premium account + Free account + Disconnect + Disconnecting from Nexus Mods… + Disconnect Nexus Mods? + GameNative will revoke this account’s Nexus tokens on this device. Installed mods and local files will not be removed. + Nexus Mods account disconnected. + Nexus Mods sign-in did not complete. Try connecting again. + Could not disconnect the Nexus Mods account. Try again. + Could not open a browser for Nexus Mods sign-in. + GameNative rejected an invalid Nexus Mods sign-in response. + Connect a Nexus Mods account before using online Nexus features. + Nexus authorization is temporarily unavailable. Try again. Nexus Mods support has been temporarily disabled while GameNative is being registered with Nexus Mods. Existing installed mods can still be managed. This Nexus authorization is invalid, expired, already used, or no longer matches an active GameNative request. Start the download from Manage Nexus Mods again. Nexus download authorization received. Return to Manage Nexus Mods if the download does not resume automatically. + Open Manage Nexus Mods for the destination game, then tap Mod Manager Download on Nexus Mods again. + GameNative cannot safely choose between multiple open mod dialogs. Close the extra dialog and try Mod Manager Download again. + Nexus authorized a file that is no longer available for this mod. Request the download again. Nexus requires website confirmation for this account. In the browser, choose Download with Manager and then Slow Download; GameNative will resume automatically. Could not open Nexus Mods in a browser. Nexus website authorization timed out. Retry the file and complete Download with Manager in the browser. diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml index 5ddabaa509..69c224bb5f 100644 --- a/app/src/main/res/values/themes.xml +++ b/app/src/main/res/values/themes.xml @@ -7,4 +7,12 @@ false shortEdges + + diff --git a/app/src/test/java/app/gamenative/mods/NexusApiClientTest.kt b/app/src/test/java/app/gamenative/mods/NexusApiClientTest.kt index 069b25600f..77927eff92 100644 --- a/app/src/test/java/app/gamenative/mods/NexusApiClientTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusApiClientTest.kt @@ -27,7 +27,7 @@ class NexusApiClientTest { baseUrl = server.url("/v1").toString().trimEnd('/'), nexusBaseUrl = server.url("").toString().trimEnd('/'), graphUrls = listOf(server.url("/graphql").toString()), - accessTokenProvider = { "test-access-token" }, + accessTokenProvider = { _, _ -> "test-access-token" }, ) } @@ -100,6 +100,113 @@ class NexusApiClientTest { assertEquals(0, server.requestCount) } + @Test + fun getCurrentUser_usesOAuthAccountWithoutLegacyValidationRequest() = runBlocking { + var accessTokenCalls = 0 + val accountClient = NexusApiClient( + client = okHttpClient, + baseUrl = server.url("/v1").toString().trimEnd('/'), + nexusBaseUrl = server.url("").toString().trimEnd('/'), + graphUrls = listOf(server.url("/graphql").toString()), + accessTokenProvider = { _, _ -> + accessTokenCalls += 1 + "unused-token" + }, + accountProvider = { + NexusOAuthAccount( + id = "51448566", + name = "Recovered Modder", + membershipRoles = listOf("member", "lifetime"), + ) + }, + ) + + val user = accountClient.getCurrentUser() + + assertEquals("Recovered Modder", user.name) + assertEquals(51_448_566L, user.userId) + assertTrue(user.isPremium) + assertEquals(0, accessTokenCalls) + assertEquals(0, server.requestCount) + } + + @Test + fun getCurrentUser_missingOAuthAccountFailsWithoutNetworkRequest() = runBlocking { + val accountClient = NexusApiClient( + client = okHttpClient, + baseUrl = server.url("/v1").toString().trimEnd('/'), + nexusBaseUrl = server.url("").toString().trimEnd('/'), + graphUrls = listOf(server.url("/graphql").toString()), + accessTokenProvider = { _, _ -> "unused-token" }, + accountProvider = { null }, + ) + + val error = runCatching { accountClient.getCurrentUser() }.exceptionOrNull() + + assertTrue(error is NexusApiException) + assertEquals(NexusApiErrorReason.AUTHENTICATION, (error as NexusApiException).reason) + assertEquals(0, server.requestCount) + } + + @Test + fun unauthorized_forcesRefreshAndRetriesExactlyOnce() = runBlocking { + var forceRefreshCalls = 0 + var rejectedAccessToken: String? = null + val retryingClient = NexusApiClient( + client = okHttpClient, + baseUrl = server.url("/v1").toString().trimEnd('/'), + nexusBaseUrl = server.url("").toString().trimEnd('/'), + graphUrls = listOf(server.url("/graphql").toString()), + accessTokenProvider = { forceRefresh, rejectedToken -> + if (forceRefresh) { + forceRefreshCalls += 1 + rejectedAccessToken = rejectedToken + "refreshed-token" + } else { + "stale-token" + } + }, + ) + server.enqueue(MockResponse().setResponseCode(401).setBody("{}")) + server.enqueue( + MockResponse().setResponseCode(200).setBody( + """{"mod_id":1,"name":"Retry worked","summary":"","version":"1"}""", + ), + ) + + val mod = retryingClient.getModInfo("fallout4", 1) + + assertEquals("Retry worked", mod.name) + assertEquals(1, forceRefreshCalls) + assertEquals("stale-token", rejectedAccessToken) + assertEquals("Bearer stale-token", server.takeRequest().headers["Authorization"]) + assertEquals("Bearer refreshed-token", server.takeRequest().headers["Authorization"]) + assertEquals(2, server.requestCount) + } + + @Test + fun unauthorized_retriesOnceEvenWhenRefreshReturnsSameToken() = runBlocking { + var forceRefreshCalls = 0 + val retryingClient = NexusApiClient( + client = okHttpClient, + baseUrl = server.url("/v1").toString().trimEnd('/'), + nexusBaseUrl = server.url("").toString().trimEnd('/'), + graphUrls = listOf(server.url("/graphql").toString()), + accessTokenProvider = { forceRefresh, _ -> + if (forceRefresh) forceRefreshCalls += 1 + "same-token" + }, + ) + server.enqueue(MockResponse().setResponseCode(401).setBody("{}")) + server.enqueue(MockResponse().setResponseCode(401).setBody("{}")) + + val error = runCatching { retryingClient.getModInfo("fallout4", 1) }.exceptionOrNull() + + assertTrue(error is NexusApiException) + assertEquals(1, forceRefreshCalls) + assertEquals(2, server.requestCount) + } + @Test fun rateLimitResponse_throwsNexusApiException() = runBlocking { server.enqueue( @@ -231,6 +338,7 @@ class NexusApiClientTest { assertTrue(collection.files.single().required) val request = server.takeRequest() assertEquals("/graphql", request.path) + assertEquals("Bearer test-access-token", request.headers["Authorization"]) val requestBody = JSONObject(request.body.readUtf8()) assertTrue(requestBody.getString("query").contains("collectionRevision")) assertFalse(requestBody.getJSONObject("variables").getBoolean("viewAdultContent")) diff --git a/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt b/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt index b456cb1022..1f52ab6491 100644 --- a/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt @@ -3,6 +3,7 @@ package app.gamenative.mods import kotlinx.coroutines.flow.first import kotlinx.coroutines.runBlocking import kotlinx.coroutines.withTimeout +import kotlinx.coroutines.withTimeoutOrNull import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertNotNull @@ -93,8 +94,190 @@ class NexusDownloadLinkInboxTest { assertNull(NexusDownloadLinkInbox.submit(callbackUrl(modId = 58280L, fileId = 12348L))) } - private fun callbackUrl(modId: Long, fileId: Long): String = - "nxm://newvegas/mods/$modId/files/$fileId?key=signed-grant&expires=4000000000&user_id=99" + @Test + fun clearAll_removesExpectationsAndDrainsBufferedGrantsWithoutClosingCollectors() = runBlocking { + val pending = pendingDownload(appId = "clear-all", modId = 58281L, fileId = 12349L) + val callback = callbackUrl(modId = 58281L, fileId = 12349L) + try { + assertTrue(NexusDownloadLinkInbox.expect(pending)) + assertNotNull(NexusDownloadLinkInbox.submit(callback)) + + NexusDownloadLinkInbox.clearAll() + + assertNull( + withTimeoutOrNull(50L) { + NexusDownloadLinkInbox.callbacksFor(pending.appId).first() + }, + ) + assertTrue(NexusDownloadLinkInbox.expect(pending.copy(requestId = "after-reconnect"))) + assertNotNull(NexusDownloadLinkInbox.submit(callbackUrl(modId = 58281L, fileId = 12349L, key = "fresh-grant"))) + val delivered = withTimeout(1_000L) { + NexusDownloadLinkInbox.callbacksFor(pending.appId).first() + } + assertEquals("after-reconnect", delivered.pending.requestId) + } finally { + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun browserFirst_routesOnlyToExactlyOneActiveDialog() = runBlocking { + val registration = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + val callback = callbackUrl(modId = 60001L, fileId = 70001L, key = "browser-first") + try { + val result = NexusDownloadLinkInbox.submitIntent(callback) + + assertTrue(result is NexusNxmSubmission.BrowserFirst) + val delivered = withTimeout(1_000L) { + NexusDownloadLinkInbox.browserFirstCallbacksFor("STEAM_22380").first() + } + assertEquals(60001L, delivered.reference.modId) + assertEquals(70001L, delivered.reference.fileId) + } finally { + registration.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun browserFirst_withoutActiveDialog_isNotQueuedForLaterDialog() = runBlocking { + val callback = callbackUrl(modId = 60002L, fileId = 70002L, key = "no-target") + + assertEquals(NexusNxmSubmission.NoActiveTarget, NexusDownloadLinkInbox.submitIntent(callback)) + + val registration = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + try { + assertNull( + withTimeoutOrNull(50L) { + NexusDownloadLinkInbox.browserFirstCallbacksFor("STEAM_22380").first() + }, + ) + } finally { + registration.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun browserFirst_withMultipleActiveDialogs_isRejectedAsAmbiguous() = runBlocking { + val first = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + val second = NexusDownloadLinkInbox.registerReceiver("GOG_1454587428") + try { + val result = NexusDownloadLinkInbox.submitIntent( + callbackUrl(modId = 60003L, fileId = 70003L, key = "ambiguous"), + ) + + assertEquals(NexusNxmSubmission.AmbiguousTarget, result) + assertNull( + withTimeoutOrNull(50L) { + NexusDownloadLinkInbox.browserFirstCallbacksFor("STEAM_22380").first() + }, + ) + assertNull( + withTimeoutOrNull(50L) { + NexusDownloadLinkInbox.browserFirstCallbacksFor("GOG_1454587428").first() + }, + ) + } finally { + first.unregister() + second.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun exactExpectedDownload_winsOverMultipleActiveDialogs() = runBlocking { + val pending = pendingDownload(appId = "STEAM_22380", modId = 60004L, fileId = 70004L) + val first = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + val second = NexusDownloadLinkInbox.registerReceiver("GOG_1454587428") + try { + assertTrue(NexusDownloadLinkInbox.expect(pending)) + val result = NexusDownloadLinkInbox.submitIntent( + callbackUrl(modId = 60004L, fileId = 70004L, key = "expected-wins"), + ) + + assertTrue(result is NexusNxmSubmission.Expected) + assertEquals("STEAM_22380", (result as NexusNxmSubmission.Expected).appId) + assertEquals( + pending, + withTimeout(1_000L) { + NexusDownloadLinkInbox.callbacksFor("STEAM_22380").first() + }.pending, + ) + } finally { + first.unregister() + second.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun exactExpectedDownload_preservesCompatibilityWhenUserIdIsOmitted() = runBlocking { + val pending = pendingDownload(appId = "STEAM_22380", modId = 60007L, fileId = 70007L) + try { + assertTrue(NexusDownloadLinkInbox.expect(pending)) + val result = NexusDownloadLinkInbox.submitIntent( + "nxm://newvegas/mods/60007/files/70007?key=expected-no-user&expires=4000000000", + ) + + assertTrue(result is NexusNxmSubmission.Expected) + assertEquals( + pending, + withTimeout(1_000L) { + NexusDownloadLinkInbox.callbacksFor("STEAM_22380").first() + }.pending, + ) + } finally { + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun duplicateExpectedGrant_cannotFallThroughAsBrowserFirst() = runBlocking { + val pending = pendingDownload(appId = "STEAM_22380", modId = 60005L, fileId = 70005L) + val callback = callbackUrl(modId = 60005L, fileId = 70005L, key = "one-use") + val registration = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + try { + assertTrue(NexusDownloadLinkInbox.expect(pending)) + assertTrue(NexusDownloadLinkInbox.submitIntent(callback) is NexusNxmSubmission.Expected) + withTimeout(1_000L) { NexusDownloadLinkInbox.callbacksFor("STEAM_22380").first() } + + assertEquals(NexusNxmSubmission.Replayed, NexusDownloadLinkInbox.submitIntent(callback)) + assertNull( + withTimeoutOrNull(50L) { + NexusDownloadLinkInbox.browserFirstCallbacksFor("STEAM_22380").first() + }, + ) + } finally { + registration.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun expiredAndMalformedBrowserFirstGrants_areDistinguished() { + val registration = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + try { + assertEquals( + NexusNxmSubmission.Expired, + NexusDownloadLinkInbox.submitIntent( + "nxm://newvegas/mods/60006/files/70006?key=expired&expires=1&user_id=99", + ), + ) + assertEquals( + NexusNxmSubmission.Malformed, + NexusDownloadLinkInbox.submitIntent( + "nxm://newvegas/mods/60006/files/70006?key=missing-user&expires=4000000000", + ), + ) + } finally { + registration.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + private fun callbackUrl(modId: Long, fileId: Long, key: String = "signed-grant"): String = + "nxm://newvegas/mods/$modId/files/$fileId?key=$key&expires=4000000000&user_id=99" private fun pendingDownload( appId: String, diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt new file mode 100644 index 0000000000..dea83e082c --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt @@ -0,0 +1,75 @@ +package app.gamenative.mods + +import java.util.Base64 +import org.json.JSONArray +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class NexusOAuthAccessTokenTest { + @Test + fun officialNestedUserClaims_parseAccountAndPremiumRole() { + val account = nexusAccountFromAccessToken( + nexusTestAccessToken( + userId = 51_448_566L, + username = "Dragon Modder", + membershipRoles = listOf("member", "premium"), + ), + ) + + assertEquals("51448566", account?.id) + assertEquals("Dragon Modder", account?.name) + assertEquals(listOf("member", "premium"), account?.membershipRoles) + assertTrue(account?.isPremium == true) + } + + @Test + fun lifetimeRole_isPremiumButSupporterAloneIsNot() { + val lifetime = nexusAccountFromAccessToken( + nexusTestAccessToken(membershipRoles = listOf("member", "lifetime")), + ) + val supporter = nexusAccountFromAccessToken( + nexusTestAccessToken(membershipRoles = listOf("member", "supporter")), + ) + + assertTrue(lifetime?.isPremium == true) + assertFalse(supporter?.isPremium == true) + } + + @Test + fun malformedOrNonCanonicalJwt_returnsNullWithoutThrowing() { + val invalidUtf8Payload = Base64.getUrlEncoder().withoutPadding() + .encodeToString(byteArrayOf(0xC3.toByte())) + val missingClaims = nexusTestJwt(JSONObject().put("user", JSONObject())) + val nonStringRole = nexusTestJwt( + JSONObject().put( + "user", + JSONObject() + .put("id", 42) + .put("username", "Modder") + .put("membership_roles", JSONArray().put(123)), + ), + ) + val values = listOf( + "", + "not-a-jwt", + "a.b.c.d", + "header.%%%.signature", + "header.$invalidUtf8Payload.signature", + missingClaims, + nonStringRole, + ) + + values.forEach { value -> assertNull(value, nexusAccountFromAccessToken(value)) } + } + + @Test + fun oversizedJwtPayload_isRejectedBeforeDecode() { + val oversizedPayload = "A".repeat(384 * 1024 + 1) + + assertNull(nexusAccountFromAccessToken("e30.$oversizedPayload.signature")) + } +} diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt new file mode 100644 index 0000000000..9444c97db5 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt @@ -0,0 +1,517 @@ +package app.gamenative.mods + +import java.security.MessageDigest +import java.util.Base64 +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.coroutineScope +import kotlinx.coroutines.delay +import kotlinx.coroutines.runBlocking +import okhttp3.HttpUrl.Companion.toHttpUrl +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class NexusOAuthControllerTest { + @Test + fun pkce_usesRfc7636S256AndUrlSafeValues() { + val pkce = NexusPkce.generate() + val expectedChallenge = Base64.getUrlEncoder().withoutPadding().encodeToString( + MessageDigest.getInstance("SHA-256") + .digest(pkce.verifier.toByteArray(Charsets.US_ASCII)), + ) + + assertEquals(43, pkce.verifier.length) + assertTrue(pkce.verifier.matches(Regex("[A-Za-z0-9_-]+"))) + assertEquals(expectedChallenge, pkce.challenge) + assertFalse(pkce.challenge.contains('=')) + assertNotEquals(pkce.verifier, pkce.challenge) + } + + @Test + fun authorizationUrl_containsExactPublicClientPkceParameters() { + val url = buildNexusAuthorizationUrl("challenge", "state").toHttpUrl() + + assertEquals("https://users.nexusmods.com/oauth/authorize", url.newBuilder().query(null).build().toString().trimEnd('/')) + assertEquals("code", url.queryParameter("response_type")) + assertEquals("gamenative", url.queryParameter("client_id")) + assertEquals("app.gamenative://oauth/callback", url.queryParameter("redirect_uri")) + assertEquals("S256", url.queryParameter("code_challenge_method")) + assertEquals("challenge", url.queryParameter("code_challenge")) + assertEquals("state", url.queryParameter("state")) + assertEquals(listOf("openid"), url.queryParameterValues("scope")) + assertNull(url.queryParameter("client_secret")) + } + + @Test + fun callback_validatesStateConsumesTransactionAndStoresPair() = runBlocking { + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote() + val controller = controller(store, remote, nowMillis = 2_000L) + + val result = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + + assertTrue(result.isSuccess) + assertEquals("authorization-code", remote.exchangedCode) + assertEquals("verifier", remote.exchangedVerifier) + assertNull(store.transaction) + assertEquals("access-two", store.tokens?.accessToken) + assertEquals("refresh-two", store.tokens?.refreshToken) + assertEquals("Modder", store.tokens?.account?.name) + assertTrue(controller.state.value.isConnected) + } + + @Test + fun callback_userInfoFailureKeepsAccountRecoveredFromAccessToken() = runBlocking { + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote( + accessToken = nexusTestAccessToken( + userId = 77L, + username = "Token Modder", + membershipRoles = listOf("member", "premium"), + ), + userInfoError = NexusOAuthException("userinfo unavailable"), + ) + val controller = controller(store, remote, nowMillis = 2_000L) + + val result = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + + assertTrue(result.isSuccess) + assertEquals("77", result.getOrNull()?.id) + assertEquals("Token Modder", store.tokens?.account?.name) + assertTrue(store.tokens?.account?.isPremium == true) + assertEquals("Token Modder", controller.state.value.account?.name) + assertTrue(controller.state.value.isConnected) + } + + @Test + fun callback_successfulUserInfoEnrichesRecoveredTokenAccount() = runBlocking { + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote( + accessToken = nexusTestAccessToken(username = "Token Modder"), + ) + val controller = controller(store, remote, nowMillis = 2_000L) + + val result = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + + assertTrue(result.isSuccess) + assertEquals("Modder", store.tokens?.account?.name) + assertTrue(store.tokens?.account?.isPremium == true) + } + + @Test + fun cancelAuthorization_duringExchangePreventsLateTokenInstallation() = runBlocking { + val exchangeStarted = CompletableDeferred() + val exchangeRelease = CompletableDeferred() + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote( + exchangeStarted = exchangeStarted, + exchangeRelease = exchangeRelease, + ) + val controller = controller(store, remote, nowMillis = 2_000L) + + val callback = async { + controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + } + exchangeStarted.await() + + controller.cancelAuthorization() + assertNull(store.transaction) + assertNull(store.tokens) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + + exchangeRelease.complete(Unit) + val result = callback.await() + + assertTrue(result.isFailure) + assertNull(store.tokens) + assertEquals(0, store.tokenWrites) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + } + + @Test + fun cancelAuthorization_duringAccountSwitchPreservesExistingSession() = runBlocking { + val exchangeStarted = CompletableDeferred() + val exchangeRelease = CompletableDeferred() + val priorTokens = expiredTokens().copy( + accessTokenExpiresAtEpochSeconds = 10_000L, + account = NexusOAuthAccount("7", "Prior Modder"), + ) + val store = MemoryOAuthStore().apply { + tokens = priorTokens + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote( + exchangeStarted = exchangeStarted, + exchangeRelease = exchangeRelease, + ) + val controller = controller(store, remote, nowMillis = 2_000L) + + val callback = async { + controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + } + exchangeStarted.await() + + assertTrue(controller.state.value.isConnected) + assertEquals("Prior Modder", controller.state.value.account?.name) + controller.cancelAuthorization() + exchangeRelease.complete(Unit) + val result = callback.await() + + assertTrue(result.isFailure) + assertEquals(priorTokens, store.tokens) + assertEquals(0, store.tokenWrites) + assertTrue(controller.state.value.isConnected) + assertEquals("Prior Modder", controller.state.value.account?.name) + } + + @Test + fun callback_wrongStateDoesNotConsumeLegitimateTransaction() = runBlocking { + val transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + val store = MemoryOAuthStore().apply { this.transaction = transaction } + val remote = FakeOAuthRemote() + val controller = controller(store, remote, nowMillis = 2_000L) + + val result = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=attacker-state", + ) + + assertTrue(result.isFailure) + assertEquals(transaction, store.transaction) + assertEquals(0, remote.exchangeCalls) + assertFalse(controller.state.value.isConnected) + } + + @Test + fun callback_expiredTransactionIsClearedWithoutExchange() = runBlocking { + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote() + val now = 1_000L + NexusOAuthConfig.AUTH_TRANSACTION_TTL_MILLIS + 1L + val controller = controller(store, remote, now) + + val result = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + + assertTrue(result.isFailure) + assertNull(store.transaction) + assertEquals(0, remote.exchangeCalls) + } + + @Test + fun callback_rejectsEncodedPathAndCodePlusError() = runBlocking { + val transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + val store = MemoryOAuthStore().apply { this.transaction = transaction } + val remote = FakeOAuthRemote() + val controller = controller(store, remote, nowMillis = 2_000L) + + val encodedPath = controller.handleAuthorizationCallback( + "app.gamenative://oauth/%63allback?code=code&state=expected-state", + ) + val ambiguous = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=code&error=denied&state=expected-state", + ) + + assertTrue(encodedPath.isFailure) + assertTrue(ambiguous.isFailure) + assertEquals(transaction, store.transaction) + assertEquals(0, remote.exchangeCalls) + } + + @Test + fun concurrentExpiryRefresh_isSingleFlightAndRotatesBothTokens() = runBlocking { + val store = MemoryOAuthStore().apply { tokens = expiredTokens() } + val remote = FakeOAuthRemote(refreshDelayMillis = 40L) + val controller = controller(store, remote, nowMillis = 2_000_000L) + + val tokens = coroutineScope { + List(8) { async { controller.getValidAccessToken() } }.awaitAll() + } + + assertEquals(List(8) { "access-two" }, tokens) + assertEquals(1, remote.refreshCalls) + assertEquals("access-two", store.tokens?.accessToken) + assertEquals("refresh-two", store.tokens?.refreshToken) + } + + @Test + fun concurrentUnauthorizedRefresh_reusesTokenAlreadyRotatedForRejectedToken() = runBlocking { + val store = MemoryOAuthStore().apply { tokens = expiredTokens() } + val remote = FakeOAuthRemote(refreshDelayMillis = 40L) + val controller = controller(store, remote, nowMillis = 2_000_000L) + + val tokens = coroutineScope { + List(8) { + async { + controller.getValidAccessToken( + forceRefresh = true, + rejectedAccessToken = "access-one", + ) + } + }.awaitAll() + } + val lateToken = controller.getValidAccessToken( + forceRefresh = true, + rejectedAccessToken = "access-one", + ) + + assertEquals(List(8) { "access-two" }, tokens) + assertEquals("access-two", lateToken) + assertEquals(1, remote.refreshCalls) + } + + @Test + fun refreshInvalidGrant_clearsSessionAndRequiresReconnect() = runBlocking { + val store = MemoryOAuthStore().apply { tokens = expiredTokens() } + val remote = FakeOAuthRemote(refreshError = NexusOAuthException("revoked", "invalid_grant")) + var invalidations = 0 + val controller = controller(store, remote, nowMillis = 2_000_000L) { invalidations += 1 } + + val token = controller.getValidAccessToken() + + assertNull(token) + assertNull(store.tokens) + assertEquals(1, invalidations) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + assertTrue(controller.state.value.errorMessage.orEmpty().contains("connect", ignoreCase = true)) + } + + @Test + fun refreshStorageFailure_clearsSessionAndInvalidatesAccountBoundState() = runBlocking { + val store = MemoryOAuthStore().apply { + tokens = expiredTokens() + failTokenWrites = true + } + val remote = FakeOAuthRemote() + var invalidations = 0 + val controller = controller(store, remote, nowMillis = 2_000_000L) { invalidations += 1 } + + val error = runCatching { controller.getValidAccessToken() }.exceptionOrNull() + + assertTrue(error is IllegalStateException) + assertNull(store.tokens) + assertEquals(1, invalidations) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + } + + @Test + fun initializationWithoutStoredSession_invalidatesStaleAccountBoundState() { + val store = MemoryOAuthStore() + val remote = FakeOAuthRemote() + var invalidations = 0 + + controller(store, remote, nowMillis = 2_000_000L) { invalidations += 1 } + + assertEquals(1, invalidations) + } + + @Test + fun initialization_recoversAndPersistsAccountFromExistingStoredAccessToken() { + val store = MemoryOAuthStore().apply { + tokens = expiredTokens().copy( + accessToken = nexusTestAccessToken( + userId = 88L, + username = "Recovered Modder", + membershipRoles = listOf("lifetime"), + ), + accessTokenExpiresAtEpochSeconds = 10_000L, + account = null, + ) + } + val remote = FakeOAuthRemote() + + val controller = controller(store, remote, nowMillis = 2_000_000L) + + assertTrue(controller.state.value.isConnected) + assertEquals("Recovered Modder", controller.state.value.account?.name) + assertTrue(controller.state.value.account?.isPremium == true) + assertEquals("Recovered Modder", store.tokens?.account?.name) + assertEquals(1, store.tokenWrites) + assertEquals(0, remote.exchangeCalls) + } + + @Test + fun disconnect_isLocalEvenWhenBestEffortRevocationFails() = runBlocking { + val store = MemoryOAuthStore().apply { + tokens = expiredTokens() + transaction = NexusAuthorizationTransaction("state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote(revocationFails = true) + var invalidations = 0 + val controller = controller(store, remote, nowMillis = 2_000_000L) { invalidations += 1 } + + val result = controller.disconnect() + + assertTrue(result.isSuccess) + assertNull(store.tokens) + assertNull(store.transaction) + assertEquals(1, invalidations) + assertEquals(listOf("refresh_token", "access_token"), remote.revocationHints) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + } + + @Test + fun disconnect_returnsStorageFailureInsteadOfThrowingIt() = runBlocking { + val store = MemoryOAuthStore().apply { + tokens = expiredTokens() + failTokenClears = true + } + val remote = FakeOAuthRemote() + var invalidations = 0 + val controller = controller(store, remote, nowMillis = 2_000_000L) { invalidations += 1 } + + val result = controller.disconnect() + + assertTrue(result.isFailure) + assertTrue(result.exceptionOrNull() is IllegalStateException) + assertEquals(1, invalidations) + assertTrue(controller.state.value.isConnected) + } + + @Test + fun disconnect_clearsCredentialsWhenTransactionCleanupFails() = runBlocking { + val store = MemoryOAuthStore().apply { + tokens = expiredTokens() + transaction = NexusAuthorizationTransaction("state", "verifier", 1_000L) + failTransactionClears = true + } + val remote = FakeOAuthRemote() + var invalidations = 0 + val controller = controller(store, remote, nowMillis = 2_000_000L) { invalidations += 1 } + + val result = controller.disconnect() + + assertTrue(result.isFailure) + assertNull(store.tokens) + assertEquals("state", store.transaction?.state) + assertEquals(1, invalidations) + assertEquals(listOf("refresh_token", "access_token"), remote.revocationHints) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + } + + private fun controller( + store: MemoryOAuthStore, + remote: FakeOAuthRemote, + nowMillis: Long, + onSessionInvalidated: () -> Unit = {}, + ): NexusOAuthController = NexusOAuthController( + store = store, + remote = remote, + clock = NexusOAuthClock { nowMillis }, + onSessionInvalidated = onSessionInvalidated, + ) + + private fun expiredTokens(): NexusStoredTokens = NexusStoredTokens( + accessToken = "access-one", + refreshToken = "refresh-one", + accessTokenExpiresAtEpochSeconds = 1_000L, + account = NexusOAuthAccount("42", "Modder"), + ) +} + +private class MemoryOAuthStore : NexusOAuthStore { + var tokens: NexusStoredTokens? = null + var transaction: NexusAuthorizationTransaction? = null + var tokenWrites: Int = 0 + var failTokenWrites: Boolean = false + var failTokenClears: Boolean = false + var failTransactionClears: Boolean = false + + override fun readTokens(): NexusStoredTokens? = tokens + + override fun writeTokens(tokens: NexusStoredTokens) { + if (failTokenWrites) throw IllegalStateException("storage full") + tokenWrites += 1 + this.tokens = tokens + } + + override fun clearTokens() { + if (failTokenClears) throw IllegalStateException("storage unavailable") + tokens = null + } + + override fun readTransaction(): NexusAuthorizationTransaction? = transaction + + override fun writeTransaction(transaction: NexusAuthorizationTransaction) { + this.transaction = transaction + } + + override fun clearTransaction() { + if (failTransactionClears) throw IllegalStateException("transaction storage unavailable") + transaction = null + } +} + +private class FakeOAuthRemote( + private val refreshDelayMillis: Long = 0L, + private val refreshError: NexusOAuthException? = null, + private val revocationFails: Boolean = false, + private val exchangeStarted: CompletableDeferred? = null, + private val exchangeRelease: CompletableDeferred? = null, + private val accessToken: String = "access-two", + private val userInfoError: NexusOAuthException? = null, +) : NexusOAuthRemote { + var exchangeCalls = 0 + var refreshCalls = 0 + var exchangedCode: String? = null + var exchangedVerifier: String? = null + val revocationHints = mutableListOf() + + override suspend fun exchangeAuthorizationCode(code: String, codeVerifier: String): NexusTokenResponse { + exchangeCalls += 1 + exchangedCode = code + exchangedVerifier = codeVerifier + exchangeStarted?.complete(Unit) + exchangeRelease?.await() + return tokenResponse() + } + + override suspend fun refresh(refreshToken: String): NexusTokenResponse { + refreshCalls += 1 + if (refreshDelayMillis > 0L) delay(refreshDelayMillis) + refreshError?.let { throw it } + return tokenResponse() + } + + override suspend fun getUserInfo(accessToken: String): NexusOAuthAccount { + userInfoError?.let { throw it } + return NexusOAuthAccount("42", "Modder", membershipRoles = listOf("premium")) + } + + override suspend fun revoke(token: String, tokenTypeHint: String) { + revocationHints += tokenTypeHint + if (revocationFails) throw NexusOAuthException("offline") + } + + private fun tokenResponse(): NexusTokenResponse = NexusTokenResponse( + accessToken = accessToken, + refreshToken = "refresh-two", + tokenType = "Bearer", + expiresInSeconds = 3_600L, + createdAtEpochSeconds = 2_000L, + ) +} diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt new file mode 100644 index 0000000000..5d47f8e21f --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt @@ -0,0 +1,196 @@ +package app.gamenative.mods + +import kotlinx.coroutines.runBlocking +import okhttp3.OkHttpClient +import okhttp3.mockwebserver.MockResponse +import okhttp3.mockwebserver.MockWebServer +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test + +class NexusOAuthServiceTest { + private lateinit var server: MockWebServer + private lateinit var client: OkHttpClient + private lateinit var service: NexusOAuthService + + @Before + fun setUp() { + server = MockWebServer() + server.start() + client = OkHttpClient() + service = NexusOAuthService( + client = client, + endpoints = NexusOAuthEndpoints( + token = server.url("/oauth/token").toString(), + revocation = server.url("/oauth/revoke").toString(), + userInfo = server.url("/oauth/userinfo").toString(), + ), + ) + } + + @After + fun tearDown() { + client.dispatcher.executorService.shutdown() + client.connectionPool.evictAll() + server.shutdown() + } + + @Test + fun exchange_usesPublicPkceFlowWithoutClientSecret() = runBlocking { + server.enqueue( + MockResponse().setBody( + """ + { + "access_token": "access-one", + "refresh_token": "refresh-one", + "token_type": "bearer", + "expires_in": 3600, + "scope": "public openid", + "created_at": 1000 + } + """.trimIndent(), + ), + ) + + val response = service.exchangeAuthorizationCode("authorization-code", "pkce-verifier") + + assertEquals("access-one", response.accessToken) + assertEquals("refresh-one", response.refreshToken) + assertEquals("Bearer", response.tokenType) + val request = server.takeRequest() + assertEquals("/oauth/token", request.path) + val form = request.body.readUtf8() + assertTrue(form.contains("grant_type=authorization_code")) + assertTrue(form.contains("client_id=gamenative")) + assertTrue(form.contains("redirect_uri=app.gamenative%3A%2F%2Foauth%2Fcallback")) + assertTrue(form.contains("code=authorization-code")) + assertTrue(form.contains("code_verifier=pkce-verifier")) + assertFalse(form.contains("client_secret")) + assertNull(request.headers["Authorization"]) + } + + @Test + fun refresh_acceptsAndReturnsRotatedTokenPair() = runBlocking { + server.enqueue( + MockResponse().setBody( + """ + { + "access_token": "access-two", + "refresh_token": "refresh-two", + "token_type": "Bearer", + "expires_in": 1800 + } + """.trimIndent(), + ), + ) + + val response = service.refresh("refresh-one") + + assertEquals("access-two", response.accessToken) + assertEquals("refresh-two", response.refreshToken) + val form = server.takeRequest().body.readUtf8() + assertTrue(form.contains("grant_type=refresh_token")) + assertTrue(form.contains("refresh_token=refresh-one")) + assertFalse(form.contains("client_secret")) + } + + @Test + fun tokenResponse_rejectsNonBearerTokenType() = runBlocking { + server.enqueue( + MockResponse().setBody( + """ + { + "access_token": "access-one", + "refresh_token": "refresh-one", + "token_type": "mac", + "expires_in": 3600 + } + """.trimIndent(), + ), + ) + + val error = runCatching { service.refresh("refresh-one") }.exceptionOrNull() + + assertTrue(error is NexusOAuthException) + } + + @Test + fun invalidGrant_isClassifiedForDisconnectHandling() = runBlocking { + server.enqueue( + MockResponse() + .setResponseCode(400) + .setBody( + """ + { + "error": "invalid_grant", + "error_description": "Refresh token was revoked" + } + """.trimIndent(), + ), + ) + + val error = runCatching { service.refresh("revoked") }.exceptionOrNull() + + assertTrue(error is NexusOAuthException) + assertTrue((error as NexusOAuthException).isInvalidGrant) + } + + @Test + fun revoke_usesPublicClientIdAndTokenHint() = runBlocking { + server.enqueue(MockResponse().setResponseCode(200)) + + service.revoke("refresh-one", "refresh_token") + + val form = server.takeRequest().body.readUtf8() + assertTrue(form.contains("client_id=gamenative")) + assertTrue(form.contains("token=refresh-one")) + assertTrue(form.contains("token_type_hint=refresh_token")) + assertFalse(form.contains("client_secret")) + } + + @Test + fun userInfo_parsesAccountAndPremiumRole() = runBlocking { + server.enqueue( + MockResponse().setBody( + """ + { + "sub": "42", + "name": "Modder", + "avatar": "https://example.test/avatar.png", + "membership_roles": ["member", "premium"] + } + """.trimIndent(), + ), + ) + + val account = service.getUserInfo("access-one") + + assertEquals("42", account.id) + assertEquals("Modder", account.name) + assertTrue(account.isPremium) + assertEquals("Bearer access-one", server.takeRequest().headers["Authorization"]) + } + + @Test + fun userInfo_rejectsNonNumericNexusUserId() = runBlocking { + server.enqueue( + MockResponse().setBody( + """ + { + "sub": "opaque-subject", + "name": "Modder", + "membership_roles": [] + } + """.trimIndent(), + ), + ) + + val error = runCatching { service.getUserInfo("access-one") }.exceptionOrNull() + + assertTrue(error is NexusOAuthException) + } +} diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthTestTokens.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthTestTokens.kt new file mode 100644 index 0000000000..b96001c4d3 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthTestTokens.kt @@ -0,0 +1,32 @@ +package app.gamenative.mods + +import java.util.Base64 +import org.json.JSONArray +import org.json.JSONObject + +internal fun nexusTestAccessToken( + userId: Long = 42L, + username: String = "Modder", + membershipRoles: List = listOf("member"), +): String = nexusTestJwt( + JSONObject() + .put("iss", "https://users.nexusmods.com") + .put("sub", userId.toString()) + .put( + "user", + JSONObject() + .put("id", userId) + .put("username", username) + .put("membership_roles", JSONArray(membershipRoles)), + ), +) + +internal fun nexusTestJwt(payload: JSONObject): String { + val encoder = Base64.getUrlEncoder().withoutPadding() + fun encode(value: ByteArray): String = encoder.encodeToString(value) + return listOf( + encode("""{"alg":"RS256","typ":"JWT"}""".toByteArray(Charsets.UTF_8)), + encode(payload.toString().toByteArray(Charsets.UTF_8)), + encode(ByteArray(32) { index -> (index + 1).toByte() }), + ).joinToString(".") +} diff --git a/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt b/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt index cb5e05a42b..a62c2871d6 100644 --- a/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt @@ -2,6 +2,7 @@ package app.gamenative.mods import org.junit.Assert.assertEquals import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue import org.junit.Test class NexusUrlParserTest { @@ -37,6 +38,61 @@ class NexusUrlParserTest { ) } + @Test + fun parseNxmDownloadGrant_preservesLiteralPlusInSignedKey() { + val result = NexusUrlParser.parseNxmDownloadGrant( + input = "nxm://newvegas/mods/12/files/34?key=signed+grant%2Bpart&expires=200&user_id=99", + nowEpochSeconds = 100L, + ) + + val reference = (result as NexusUrlParser.NxmDownloadGrantResult.Valid).reference + assertEquals("signed+grant+part", reference.downloadAuthorization?.key) + assertEquals(99L, reference.downloadAuthorization?.userId) + } + + @Test + fun parseNxmDownloadGrant_rejectsExpiredGrantSeparately() { + val result = NexusUrlParser.parseNxmDownloadGrant( + input = "nxm://newvegas/mods/12/files/34?key=signed&expires=100&user_id=99", + nowEpochSeconds = 100L, + ) + + assertEquals(NexusUrlParser.NxmDownloadGrantResult.Expired, result) + } + + @Test + fun parseNxmDownloadGrant_rejectsMissingOrDuplicateAccountBoundFields() { + val missingUser = NexusUrlParser.parseNxmDownloadGrant( + input = "nxm://newvegas/mods/12/files/34?key=signed&expires=200", + nowEpochSeconds = 100L, + ) + val duplicateKey = NexusUrlParser.parseNxmDownloadGrant( + input = "nxm://newvegas/mods/12/files/34?key=one&key=two&expires=200&user_id=99", + nowEpochSeconds = 100L, + ) + + assertEquals(NexusUrlParser.NxmDownloadGrantResult.Malformed, missingUser) + assertEquals(NexusUrlParser.NxmDownloadGrantResult.Malformed, duplicateKey) + } + + @Test + fun parseNxmDownloadGrant_rejectsNonCanonicalAuthorityPathAndFragment() { + val malformed = listOf( + "nxm://user@newvegas/mods/12/files/34?key=signed&expires=200&user_id=99", + "nxm://newvegas:443/mods/12/files/34?key=signed&expires=200&user_id=99", + "nxm://newvegas/extra/mods/12/files/34?key=signed&expires=200&user_id=99", + "nxm://newvegas/mods/12/files/34/extra?key=signed&expires=200&user_id=99", + "nxm://newvegas/mods/12/files/34?key=signed&expires=200&user_id=99#fragment", + ) + + assertTrue( + malformed.all { + NexusUrlParser.parseNxmDownloadGrant(it, nowEpochSeconds = 100L) == + NexusUrlParser.NxmDownloadGrantResult.Malformed + }, + ) + } + @Test fun parse_nonNexusUrl_returnsNull() { assertNull(NexusUrlParser.parse("https://example.com/skyrim/mods/1")) diff --git a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt index 84da937cb1..1722b66a84 100644 --- a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt +++ b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt @@ -1,22 +1,31 @@ package app.gamenative.service +import android.app.Application import android.content.ContentProvider import android.content.ContentValues import android.content.Intent import android.database.Cursor import android.net.Uri import android.provider.DocumentsContract +import androidx.test.core.app.ApplicationProvider +import app.gamenative.R import app.gamenative.data.ModInstall import app.gamenative.data.ModInstallSource import app.gamenative.data.ModInstallStatus import app.gamenative.mods.NexusImportState +import app.gamenative.mods.NexusModFile +import app.gamenative.mods.NexusModInfo +import app.gamenative.mods.NexusModReference +import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf import org.robolectric.shadows.ShadowContentResolver @RunWith(RobolectricTestRunner::class) @@ -65,6 +74,35 @@ class NexusModImportServiceRobolectricTest { assertEquals(2, intent.clipData?.itemCount) } + @Test + fun enqueueNexusImport_disconnected_failsBeforeStartingService() = runBlocking { + val context = ApplicationProvider.getApplicationContext() + val shadowApplication = shadowOf(context) + while (shadowApplication.nextStartedService != null) { + // Ignore unrelated services started by application initialization. + } + + val result = NexusModImportService.enqueueImport( + context = context, + appId = "steam_123", + reference = NexusModReference("fallout4", 10L, 20L), + modInfo = NexusModInfo(10L, "Test mod", "", "1.0"), + file = NexusModFile( + fileId = 20L, + name = "Test file", + version = "1.0", + fileName = "test.zip", + sizeBytes = 1L, + uploadedTimestamp = 1L, + ), + displayName = "Test mod", + ) + val error = runCatching { result.await() }.exceptionOrNull() + + assertEquals(context.getString(R.string.nexus_oauth_sign_in_required), error?.message) + assertNull(shadowApplication.nextStartedService) + } + @Test fun terminalLocalResumeFailure_restoresPreviousInstallOnlyWhenContentIsAvailable() { val previous = localInstall(ModInstallStatus.READY) diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogBrowserFirstTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogBrowserFirstTest.kt new file mode 100644 index 0000000000..e987efeab3 --- /dev/null +++ b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogBrowserFirstTest.kt @@ -0,0 +1,189 @@ +package app.gamenative.ui.component.dialog + +import app.gamenative.mods.NexusDownloadAuthorization +import app.gamenative.mods.NexusAuthState +import app.gamenative.mods.NexusConnectionState +import app.gamenative.mods.NexusModFile +import app.gamenative.mods.NexusModInfo +import app.gamenative.mods.NexusModReference +import app.gamenative.mods.NexusOAuthAccount +import app.gamenative.mods.NexusUserInfo +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +class NexusModsDialogBrowserFirstTest { + @Test + fun nexusUserInfo_isAlwaysDerivedFromTheCurrentAuthAccount() { + val accountA = NexusAuthState( + connection = NexusConnectionState.CONNECTED, + account = NexusOAuthAccount("41", "Account A"), + ).currentNexusUserInfo() + val expiredSession = NexusAuthState( + connection = NexusConnectionState.DISCONNECTED, + ).currentNexusUserInfo() + val accountB = NexusAuthState( + connection = NexusConnectionState.CONNECTED, + account = NexusOAuthAccount( + id = "42", + name = "Account B", + membershipRoles = listOf("premium"), + ), + ).currentNexusUserInfo() + + assertEquals(41L, accountA?.userId) + assertFalse(accountA?.isPremium == true) + assertNull(expiredSession) + assertEquals(42L, accountB?.userId) + assertEquals("Account B", accountB?.name) + assertTrue(accountB?.isPremium == true) + } + + @Test + fun currentDownloadUser_readsAccountAtExecutionAfterSwitch() = runBlocking { + var currentUser = NexusUserInfo("Account A", 41L, false) + val liveAccountProvider: suspend () -> NexusUserInfo = { currentUser } + + currentUser = NexusUserInfo("Account B", 42L, false) + + assertEquals( + currentUser, + currentNexusUserForDownload(reference(userId = 42L), liveAccountProvider), + ) + } + + @Test + fun currentDownloadUser_rejectsGrantFromPreviousAccount() = runBlocking { + val currentUser = NexusUserInfo("Account B", 42L, false) + + assertNull( + currentNexusUserForDownload( + reference = reference(userId = 41L), + getCurrentUser = { currentUser }, + ), + ) + } + + @Test + fun resolveBrowserFirst_wrongAccountStopsBeforeMetadataLookup() = runBlocking { + var metadataCalls = 0 + + val result = resolveBrowserFirstNexusDownload( + reference = reference(userId = 99L), + getCurrentUser = { NexusUserInfo("Other account", 100L, false) }, + getModInfo = { _, _ -> + metadataCalls++ + modInfo() + }, + getModFiles = { _, _ -> + metadataCalls++ + listOf(file()) + }, + nowEpochSeconds = { 100L }, + ) + + assertEquals(BrowserFirstNexusResolution.WrongAccount, result) + assertEquals(0, metadataCalls) + } + + @Test + fun resolveBrowserFirst_returnsOnlyTheExactlyAuthorizedFile() = runBlocking { + val expectedFile = file(fileId = 34L) + + val result = resolveBrowserFirstNexusDownload( + reference = reference(userId = 99L), + getCurrentUser = { NexusUserInfo("Same account", 99L, false) }, + getModInfo = { domain, modId -> + assertEquals("newvegas", domain) + assertEquals(12L, modId) + modInfo() + }, + getModFiles = { _, _ -> listOf(file(fileId = 33L), expectedFile, file(fileId = 35L)) }, + nowEpochSeconds = { 100L }, + ) + + assertTrue(result is BrowserFirstNexusResolution.Resolved) + val resolved = result as BrowserFirstNexusResolution.Resolved + assertEquals(expectedFile, resolved.file) + assertEquals(34L, resolved.file.fileId) + } + + @Test + fun resolveBrowserFirst_missingExactFileDoesNotResolve() = runBlocking { + val result = resolveBrowserFirstNexusDownload( + reference = reference(userId = 99L), + getCurrentUser = { NexusUserInfo("Same account", 99L, false) }, + getModInfo = { _, _ -> modInfo() }, + getModFiles = { _, _ -> listOf(file(fileId = 35L)) }, + nowEpochSeconds = { 100L }, + ) + + assertEquals(BrowserFirstNexusResolution.MissingFile, result) + } + + @Test + fun resolveBrowserFirst_rechecksExpiryAfterMetadataLookup() = runBlocking { + val clockValues = ArrayDeque(listOf(100L, 200L)) + + val result = resolveBrowserFirstNexusDownload( + reference = reference(userId = 99L, expires = 200L), + getCurrentUser = { NexusUserInfo("Same account", 99L, false) }, + getModInfo = { _, _ -> modInfo() }, + getModFiles = { _, _ -> listOf(file()) }, + nowEpochSeconds = { clockValues.removeFirst() }, + ) + + assertEquals(BrowserFirstNexusResolution.Expired, result) + } + + @Test + fun resolveBrowserFirst_rechecksAccountAfterMetadataLookup() = runBlocking { + val users = ArrayDeque( + listOf( + NexusUserInfo("Original account", 99L, false), + NexusUserInfo("Replacement account", 100L, false), + ), + ) + + val result = resolveBrowserFirstNexusDownload( + reference = reference(userId = 99L), + getCurrentUser = { users.removeFirst() }, + getModInfo = { _, _ -> modInfo() }, + getModFiles = { _, _ -> listOf(file()) }, + nowEpochSeconds = { 100L }, + ) + + assertEquals(BrowserFirstNexusResolution.WrongAccount, result) + } + + private fun reference(userId: Long, expires: Long = 400L): NexusModReference = + NexusModReference( + gameDomain = "newvegas", + modId = 12L, + fileId = 34L, + downloadAuthorization = NexusDownloadAuthorization( + key = "signed-grant", + expires = expires, + userId = userId, + ), + ) + + private fun modInfo(): NexusModInfo = NexusModInfo( + modId = 12L, + name = "Test mod", + summary = "Summary", + version = "1.0", + ) + + private fun file(fileId: Long = 34L): NexusModFile = NexusModFile( + fileId = fileId, + name = "Test file $fileId", + version = "1.0", + fileName = "test-$fileId.zip", + sizeBytes = 1L, + uploadedTimestamp = 1L, + ) +} diff --git a/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncherTest.kt b/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncherTest.kt new file mode 100644 index 0000000000..daf4083592 --- /dev/null +++ b/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthBrowserLauncherTest.kt @@ -0,0 +1,31 @@ +package app.gamenative.ui.screen.auth + +import android.net.Uri +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner + +@RunWith(RobolectricTestRunner::class) +class NexusOAuthBrowserLauncherTest { + @Test + fun `allows only the Nexus authorization endpoint`() { + assertTrue( + NexusOAuthBrowserLauncher.isAllowedAuthorizationUri( + Uri.parse("https://users.nexusmods.com/oauth/authorize?client_id=gamenative"), + ), + ) + + listOf( + "http://users.nexusmods.com/oauth/authorize?client_id=gamenative", + "https://users.nexusmods.com.evil/oauth/authorize?client_id=gamenative", + "https://users.nexusmods.com/oauth/token", + "https://user@users.nexusmods.com/oauth/authorize", + "https://users.nexusmods.com:444/oauth/authorize", + "https://users.nexusmods.com/oauth/authorize#fragment", + ).forEach { value -> + assertFalse(value, NexusOAuthBrowserLauncher.isAllowedAuthorizationUri(Uri.parse(value))) + } + } +} diff --git a/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt b/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt new file mode 100644 index 0000000000..0f9e7150a9 --- /dev/null +++ b/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt @@ -0,0 +1,65 @@ +package app.gamenative.ui.screen.auth + +import android.content.ClipData +import android.content.Intent +import android.net.Uri +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner + +@RunWith(RobolectricTestRunner::class) +class NexusOAuthCallbackContractTest { + @Test + fun `accepts exact registered redirect with OAuth response parameters`() { + val intent = Intent( + Intent.ACTION_VIEW, + Uri.parse("app.gamenative://oauth/callback?code=authorization-code&state=random-state"), + ) + + assertTrue(NexusOAuthCallbackContract.matches(intent)) + } + + @Test + fun `accepts exact registered redirect with OAuth error parameters`() { + val uri = Uri.parse("app.gamenative://oauth/callback?error=access_denied&state=random-state") + + assertTrue(NexusOAuthCallbackContract.matches(uri)) + } + + @Test + fun `consume returns valid callback then scrubs all sensitive intent data`() { + val intent = Intent( + Intent.ACTION_VIEW, + Uri.parse("app.gamenative://oauth/callback?code=secret-code&state=secret-state"), + ).apply { + putExtra("secret", "value") + clipData = ClipData.newPlainText("secret", "value") + } + + val callback = NexusOAuthCallbackContract.consumeAndScrub(intent) + + assertEquals("secret-code", callback?.getQueryParameter("code")) + assertNull(intent.data) + assertNull(intent.extras) + assertNull(intent.clipData) + } + + @Test + fun `rejects explicit launches and look-alike redirects`() { + val lookAlikes = listOf( + Intent(Intent.ACTION_MAIN, Uri.parse("app.gamenative://oauth/callback?code=code&state=state")), + Intent(Intent.ACTION_VIEW, Uri.parse("app.gamenative://oauth/callback/extra?code=code&state=state")), + Intent(Intent.ACTION_VIEW, Uri.parse("app.gamenative://oauth.evil/callback?code=code&state=state")), + Intent(Intent.ACTION_VIEW, Uri.parse("app.gamenative://oauth@evil/callback?code=code&state=state")), + Intent(Intent.ACTION_VIEW, Uri.parse("app.gamenative://oauth:443/callback?code=code&state=state")), + Intent(Intent.ACTION_VIEW, Uri.parse("app.gamenative://oauth/callback#code=fragment")), + Intent(Intent.ACTION_VIEW, Uri.parse("https://oauth/callback?code=code&state=state")), + ) + + lookAlikes.forEach { assertFalse(it.dataString, NexusOAuthCallbackContract.matches(it)) } + } +} From 5f401a841fd1c20bc66b3ee6f8920ce992af917f Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 20:48:49 -0500 Subject: [PATCH 02/60] fix: harden Nexus OAuth review findings --- .../main/java/app/gamenative/MainActivity.kt | 133 ++++++++++-------- .../app/gamenative/mods/NexusAuthManager.kt | 98 +++++++++---- .../gamenative/mods/NexusDownloadLinkInbox.kt | 41 ++++-- .../gamenative/mods/NexusOAuthAccessToken.kt | 8 +- .../app/gamenative/mods/NexusOAuthModels.kt | 9 +- .../app/gamenative/mods/NexusOAuthService.kt | 8 +- .../app/gamenative/mods/NexusUrlParser.kt | 60 +++++--- .../service/NexusModImportService.kt | 3 +- .../ui/component/dialog/NexusModsDialog.kt | 99 ++++++++++--- .../dialog/NexusOAuthAccountSection.kt | 8 +- .../screen/auth/NexusOAuthCallbackActivity.kt | 15 +- .../mods/NexusDownloadLinkInboxTest.kt | 75 +++++++++- .../mods/NexusOAuthAccessTokenTest.kt | 22 ++- .../mods/NexusOAuthControllerTest.kt | 52 ++++++- .../gamenative/mods/NexusOAuthServiceTest.kt | 13 ++ .../app/gamenative/mods/NexusUrlParserTest.kt | 14 +- .../auth/NexusOAuthCallbackContractTest.kt | 3 + 17 files changed, 500 insertions(+), 161 deletions(-) diff --git a/app/src/main/java/app/gamenative/MainActivity.kt b/app/src/main/java/app/gamenative/MainActivity.kt index 6b4fc7613f..f94d09026b 100644 --- a/app/src/main/java/app/gamenative/MainActivity.kt +++ b/app/src/main/java/app/gamenative/MainActivity.kt @@ -62,7 +62,11 @@ import com.skydoves.landscapist.coil.LocalCoilImageLoader import com.winlator.core.AppUtils import com.winlator.inputcontrols.ControllerManager import dagger.hilt.android.AndroidEntryPoint +import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext import java.util.EnumSet import kotlin.math.abs import okio.Path.Companion.toOkioPath @@ -71,6 +75,8 @@ import timber.log.Timber @AndroidEntryPoint class MainActivity : ComponentActivity() { + private val nxmIntentMutex = Mutex() + companion object { private var totalIndex = 0 @@ -307,65 +313,12 @@ class MainActivity : ComponentActivity() { return } if (intent.action == Intent.ACTION_VIEW && intent.data?.scheme.equals("nxm", ignoreCase = true)) { + val rawNxmUrl = intent.dataString.orEmpty() // Do not retain a signed NXM grant as the Activity's launch intent. Android can // otherwise replay it after a configuration change or process recreation. setIntent(Intent(this, MainActivity::class.java).setAction(Intent.ACTION_MAIN)) - if (!NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE) { - Timber.i("[NexusDownload]: Ignoring NXM callback while online Nexus access is disabled") - SnackbarManager.show(getString(R.string.nexus_integration_temporarily_unavailable)) - return - } - if (!NexusAuthManager.hasStoredSession()) { - // A signed NXM grant is short lived and account-bound. Do not restore or consume - // it while disconnected: the user must reconnect and request a fresh grant. - Timber.i("[NexusDownload]: Ignoring NXM callback while the Nexus account is disconnected") - SnackbarManager.show(getString(R.string.nexus_oauth_sign_in_required)) - return - } - val restoredDownloads = NexusPendingDownloadStore.restore(this) - restoredDownloads.forEach { NexusDownloadLinkInbox.expect(it) } - when (val submission = NexusDownloadLinkInbox.submitIntent(intent.dataString.orEmpty())) { - is NexusNxmSubmission.Expected -> { - BaseAppScreen.requestManageMods(submission.appId) - NexusPendingDownloadStore.removeMatching(this, submission.reference) - Timber.i( - "[NexusDownload]: Received expected NXM callback for %s/%d/%s", - submission.reference.gameDomain, - submission.reference.modId, - submission.reference.fileId, - ) - SnackbarManager.show(getString(R.string.nexus_nxm_callback_received)) - } - is NexusNxmSubmission.BrowserFirst -> { - Timber.i( - "[NexusDownload]: Routed browser-first NXM callback for %s/%d/%s", - submission.reference.gameDomain, - submission.reference.modId, - submission.reference.fileId, - ) - } - NexusNxmSubmission.Expired -> { - Timber.i("[NexusDownload]: Ignoring expired NXM callback") - SnackbarManager.show(getString(R.string.nexus_authorization_expired)) - } - NexusNxmSubmission.NoActiveTarget -> { - Timber.i("[NexusDownload]: Browser-first NXM callback has no active target") - SnackbarManager.show(getString(R.string.nexus_nxm_no_active_target)) - } - NexusNxmSubmission.AmbiguousTarget -> { - Timber.w("[NexusDownload]: Browser-first NXM callback has multiple active targets") - SnackbarManager.show(getString(R.string.nexus_nxm_ambiguous_target)) - } - NexusNxmSubmission.DeliveryFailed -> { - Timber.w("[NexusDownload]: Could not deliver NXM callback to the active target") - SnackbarManager.show(getString(R.string.nexus_oauth_session_unavailable)) - } - NexusNxmSubmission.Replayed, - NexusNxmSubmission.Malformed, - -> { - Timber.w("[NexusDownload]: Ignoring malformed, unsigned, or replayed NXM callback") - SnackbarManager.show(getString(R.string.nexus_invalid_nxm_callback)) - } + lifecycleScope.launch { + nxmIntentMutex.withLock { handleNxmIntent(rawNxmUrl) } } return } @@ -402,6 +355,74 @@ class MainActivity : ComponentActivity() { } } + private suspend fun handleNxmIntent(rawNxmUrl: String) { + if (!NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE) { + Timber.i("[NexusDownload]: Ignoring NXM callback while online Nexus access is disabled") + SnackbarManager.show(getString(R.string.nexus_integration_temporarily_unavailable)) + return + } + if (!NexusAuthManager.hasStoredSession()) { + // A signed NXM grant is short lived and account-bound. Do not restore or consume + // it while disconnected: the user must reconnect and request a fresh grant. + Timber.i("[NexusDownload]: Ignoring NXM callback while the Nexus account is disconnected") + SnackbarManager.show(getString(R.string.nexus_oauth_sign_in_required)) + return + } + val restoredDownloads = withContext(Dispatchers.IO) { + NexusPendingDownloadStore.restore(this@MainActivity) + } + restoredDownloads.forEach { NexusDownloadLinkInbox.expect(it) } + when (val submission = NexusDownloadLinkInbox.submitIntent(rawNxmUrl)) { + is NexusNxmSubmission.Expected -> { + BaseAppScreen.requestManageMods(submission.appId) + withContext(Dispatchers.IO) { + NexusPendingDownloadStore.removeMatching(this@MainActivity, submission.reference) + } + Timber.i( + "[NexusDownload]: Received expected NXM callback for %s/%d/%s", + submission.reference.gameDomain, + submission.reference.modId, + submission.reference.fileId, + ) + SnackbarManager.show(getString(R.string.nexus_nxm_callback_received)) + } + is NexusNxmSubmission.BrowserFirst -> { + Timber.i( + "[NexusDownload]: Routed browser-first NXM callback for %s/%d/%s", + submission.reference.gameDomain, + submission.reference.modId, + submission.reference.fileId, + ) + } + is NexusNxmSubmission.Expired -> { + NexusDownloadLinkInbox.cancelExpected(submission.reference) + withContext(Dispatchers.IO) { + NexusPendingDownloadStore.removeMatching(this@MainActivity, submission.reference) + } + Timber.i("[NexusDownload]: Ignoring expired NXM callback") + SnackbarManager.show(getString(R.string.nexus_authorization_expired)) + } + NexusNxmSubmission.NoActiveTarget -> { + Timber.i("[NexusDownload]: Browser-first NXM callback has no active target") + SnackbarManager.show(getString(R.string.nexus_nxm_no_active_target)) + } + NexusNxmSubmission.AmbiguousTarget -> { + Timber.w("[NexusDownload]: Browser-first NXM callback has multiple active targets") + SnackbarManager.show(getString(R.string.nexus_nxm_ambiguous_target)) + } + NexusNxmSubmission.DeliveryFailed -> { + Timber.w("[NexusDownload]: Could not deliver NXM callback to the active target") + SnackbarManager.show(getString(R.string.download_failed_try_again)) + } + NexusNxmSubmission.Replayed, + NexusNxmSubmission.Malformed, + -> { + Timber.w("[NexusDownload]: Ignoring malformed, unsigned, or replayed NXM callback") + SnackbarManager.show(getString(R.string.nexus_invalid_nxm_callback)) + } + } + } + override fun onDestroy() { // emit before super so Compose DisposableEffects (which unregister // listeners during super.onDestroy's lifecycle transition) still fire diff --git a/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt index 666eac778e..8babd784de 100644 --- a/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt @@ -16,6 +16,7 @@ import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock +import kotlinx.coroutines.withContext import okhttp3.HttpUrl.Companion.toHttpUrl import timber.log.Timber @@ -143,7 +144,11 @@ internal class NexusOAuthController( activeAuthorizationState = null invalidateSessionSideData() mutableState.value = NexusAuthState( - connection = NexusConnectionState.CONNECTED, + connection = if (tokenAccount == null) { + NexusConnectionState.CONNECTING + } else { + NexusConnectionState.CONNECTED + }, account = tokenAccount, ) true @@ -155,22 +160,51 @@ internal class NexusOAuthController( ) } - val enrichedAccount = try { + suspend fun loadAccount(): NexusOAuthAccount? = try { remote.getUserInfo(response.accessToken) } catch (error: CancellationException) { - // The durable token pair is already installed. Preserve the connected state; - // account details can be loaded on the next screen/app start. throw error } catch (error: Exception) { - Timber.w("Nexus sign-in succeeded but account lookup failed (%s)", error.javaClass.simpleName) + Timber.w( + "Nexus sign-in succeeded but account lookup failed (%s)", + error.javaClass.simpleName, + ) null } + var enrichedAccount = loadAccount() + if (enrichedAccount == null && tokenAccount == null) { + // An opaque token gives us no local identity to bind signed file grants to. + // Retry once before rejecting the otherwise successful token exchange. + enrichedAccount = loadAccount() + } val account = enrichedAccount ?: tokenAccount + if (account == null) { + synchronized(authorizationLock) { + if (store.readTokens()?.accessToken == response.accessToken) { + runCatching { store.clearTokens() } + invalidateSessionSideData() + mutableState.value = NexusAuthState( + connection = NexusConnectionState.DISCONNECTED, + error = NexusAuthError.SIGN_IN_FAILED, + ) + } + } + throw NexusOAuthException("Nexus account identity could not be verified") + } if (enrichedAccount != null) { synchronized(authorizationLock) { val current = store.readTokens() if (current?.accessToken == response.accessToken) { - store.writeTokens(current.copy(account = enrichedAccount)) + try { + store.writeTokens(current.copy(account = enrichedAccount)) + } catch (storageError: Exception) { + // The durable token pair is already installed. Account metadata is + // an enrichment and can be recovered again from the access token. + Timber.w( + "Unable to persist Nexus account metadata (%s)", + storageError.javaClass.simpleName, + ) + } mutableState.value = NexusAuthState( connection = NexusConnectionState.CONNECTED, account = enrichedAccount, @@ -183,7 +217,7 @@ internal class NexusOAuthController( restoreStateAfterAuthorizationFailure(attemptState) throw error } catch (error: Exception) { - restoreStateAfterAuthorizationFailure(attemptState, error.safeMessage()) + restoreStateAfterAuthorizationFailure(attemptState, NexusAuthError.SIGN_IN_FAILED) Result.failure(error) } } @@ -231,7 +265,7 @@ internal class NexusOAuthController( invalidateSessionSideData() mutableState.value = NexusAuthState( connection = NexusConnectionState.DISCONNECTED, - errorMessage = "Your Nexus connection expired. Please connect it again.", + error = NexusAuthError.SESSION_EXPIRED, ) return@withLock null } @@ -242,7 +276,7 @@ internal class NexusOAuthController( mutableState.value = NexusAuthState( connection = NexusConnectionState.CONNECTED, account = current.account, - errorMessage = "Nexus token refresh will be retried", + error = NexusAuthError.REFRESH_RETRY_PENDING, ) return@withLock current.accessToken } @@ -258,7 +292,7 @@ internal class NexusOAuthController( invalidateSessionSideData() mutableState.value = NexusAuthState( connection = NexusConnectionState.DISCONNECTED, - errorMessage = "Nexus credentials could not be saved; reconnect your account", + error = NexusAuthError.CREDENTIAL_STORAGE_FAILED, ) throw storageError } @@ -339,14 +373,14 @@ internal class NexusOAuthController( private fun restoreStateAfterAuthorizationFailure( attemptState: String?, - errorMessage: String? = null, + error: NexusAuthError? = null, ) { synchronized(authorizationLock) { if (attemptState == null) { - mutableState.value = stateFromStoredTokens(errorMessage) + mutableState.value = stateFromStoredTokens(error) } else if (activeAuthorizationState == attemptState) { activeAuthorizationState = null - mutableState.value = stateFromStoredTokens(errorMessage) + mutableState.value = stateFromStoredTokens(error) } } } @@ -368,12 +402,12 @@ internal class NexusOAuthController( return transaction } - private fun stateFromStoredTokens(errorMessage: String? = null): NexusAuthState { + private fun stateFromStoredTokens(error: NexusAuthError? = null): NexusAuthState { val tokens = store.readTokens() return if (tokens == null) { NexusAuthState( connection = NexusConnectionState.DISCONNECTED, - errorMessage = errorMessage, + error = error, ) } else { val account = tokens.account ?: nexusAccountFromAccessToken(tokens.accessToken) @@ -392,7 +426,7 @@ internal class NexusOAuthController( NexusAuthState( connection = NexusConnectionState.CONNECTED, account = account, - errorMessage = errorMessage, + error = error, ) } } @@ -447,7 +481,9 @@ internal class NexusOAuthController( object NexusAuthManager { private val initializationLock = Any() private val initializationScope = CoroutineScope(SupervisorJob() + Dispatchers.IO) - private val mutableState = MutableStateFlow(NexusAuthState()) + private val mutableState = MutableStateFlow( + NexusAuthState(connection = NexusConnectionState.CONNECTING), + ) @Volatile private var controller: NexusOAuthController? = null @@ -466,24 +502,33 @@ object NexusAuthManager { initializationScope.launch { requireController() } } - fun beginAuthorization(): Uri = requireController().beginAuthorization() + suspend fun beginAuthorization(): Uri = withContext(Dispatchers.IO) { + requireController().beginAuthorization() + } - fun cancelAuthorization() { - controller?.cancelAuthorization() + suspend fun cancelAuthorization() = withContext(Dispatchers.IO) { + requireController().cancelAuthorization() } suspend fun handleAuthorizationCallback(callbackUri: Uri): Result = - requireController().handleAuthorizationCallback(callbackUri) + withContext(Dispatchers.IO) { + requireController().handleAuthorizationCallback(callbackUri) + } suspend fun getValidAccessToken( forceRefresh: Boolean = false, rejectedAccessToken: String? = null, - ): String? = requireController().getValidAccessToken(forceRefresh, rejectedAccessToken) + ): String? = withContext(Dispatchers.IO) { + requireController().getValidAccessToken(forceRefresh, rejectedAccessToken) + } - fun hasStoredSession(): Boolean = requireController().hasStoredSession() + suspend fun hasStoredSession(): Boolean = withContext(Dispatchers.IO) { + requireController().hasStoredSession() + } - suspend fun disconnect(): Result = + suspend fun disconnect(): Result = withContext(Dispatchers.IO) { requireController().disconnect() + } private fun requireController(): NexusOAuthController { controller?.let { return it } @@ -586,8 +631,3 @@ private fun Map>.singleValue(name: String): String? { } private fun Long.toEpochSeconds(): Long = this / 1000L - -private fun Exception.safeMessage(): String = when (this) { - is NexusOAuthException -> message ?: "Nexus authorization failed" - else -> "Nexus authorization failed" -} diff --git a/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt b/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt index 1866a27c70..c41a2d7f88 100644 --- a/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt +++ b/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt @@ -37,7 +37,7 @@ sealed interface NexusNxmSubmission { val reference: NexusModReference, ) : NexusNxmSubmission - data object Expired : NexusNxmSubmission + data class Expired(val reference: NexusModReference) : NexusNxmSubmission data object NoActiveTarget : NexusNxmSubmission data object AmbiguousTarget : NexusNxmSubmission data object Replayed : NexusNxmSubmission @@ -105,7 +105,14 @@ object NexusDownloadLinkInbox { internal fun unregisterReceiver(registration: NexusNxmReceiverRegistration) { synchronized(pendingLock) { - activeReceivers.remove(registration.token) + val appId = activeReceivers.remove(registration.token) ?: return@synchronized + if (appId !in activeReceivers.values) { + browserFirstChannels.remove(appId)?.let { channel -> + while (channel.tryReceive().isSuccess) { + // A later dialog must never receive a grant sent to a closed one. + } + } + } } } @@ -143,7 +150,20 @@ object NexusDownloadLinkInbox { val parsed = NexusUrlParser.parseNxmDownloadGrant(rawUrl, requireUserId = false) ) { is NexusUrlParser.NxmDownloadGrantResult.Valid -> parsed.reference - NexusUrlParser.NxmDownloadGrantResult.Expired -> return NexusNxmSubmission.Expired + is NexusUrlParser.NxmDownloadGrantResult.Expired -> { + val reference = parsed.reference + synchronized(pendingLock) { + removeExpiredPendingDownloads() + pendingWebsiteDownloads.remove(reference.fileKey())?.let { pending -> + if (pending.appId in activeReceivers.values) { + callbackChannelFor(pending.appId).trySend( + AuthorizedNexusWebsiteDownload(pending, reference), + ) + } + } + } + return NexusNxmSubmission.Expired(reference) + } NexusUrlParser.NxmDownloadGrantResult.Malformed -> return NexusNxmSubmission.Malformed } val authorization = reference.downloadAuthorization ?: return NexusNxmSubmission.Malformed @@ -156,6 +176,9 @@ object NexusDownloadLinkInbox { if (consumedGrantFingerprints.containsKey(fingerprint)) { return@synchronized NexusNxmSubmission.Replayed } + if (consumedGrantFingerprints.size >= MAX_CONSUMED_GRANT_FINGERPRINTS) { + return@synchronized NexusNxmSubmission.DeliveryFailed + } val pending = pendingWebsiteDownloads.remove(key) if (pending != null) { @@ -174,7 +197,7 @@ object NexusDownloadLinkInbox { if (authorization.userId?.takeIf { it > 0L } == null) { return@synchronized NexusNxmSubmission.Malformed } - val activeAppIds = activeReceivers.values.toList() + val activeAppIds = activeReceivers.values.distinct() if (activeAppIds.isEmpty()) return@synchronized NexusNxmSubmission.NoActiveTarget if (activeAppIds.size != 1) return@synchronized NexusNxmSubmission.AmbiguousTarget val appId = activeAppIds.single() @@ -204,6 +227,12 @@ object NexusDownloadLinkInbox { } } + fun cancelExpected(reference: NexusModReference) { + synchronized(pendingLock) { + pendingWebsiteDownloads.remove(reference.fileKey()) + } + } + /** Clears account-bound website expectations and any already buffered one-use grants. */ fun clearAll() { synchronized(pendingLock) { @@ -244,10 +273,6 @@ object NexusDownloadLinkInbox { } private fun rememberConsumedGrant(fingerprint: String, authorization: NexusDownloadAuthorization) { - while (consumedGrantFingerprints.size >= MAX_CONSUMED_GRANT_FINGERPRINTS) { - consumedGrantFingerprints.entries.firstOrNull()?.key?.let(consumedGrantFingerprints::remove) - ?: break - } consumedGrantFingerprints[fingerprint] = authorization.expires } diff --git a/app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt b/app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt index add2bb0165..7ac6aaafcb 100644 --- a/app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt +++ b/app/src/main/java/app/gamenative/mods/NexusOAuthAccessToken.kt @@ -72,9 +72,11 @@ internal fun nexusAccountFromAccessToken(accessToken: String): NexusOAuthAccount ?.trim() ?.takeIf { it.isNotEmpty() && it.length <= MAX_USERNAME_CHARS } ?: return null - val roles = user.optJSONArray("membership_roles") - ?.strictStringValues() - ?: return null + val roles = if (user.has("membership_roles")) { + user.optJSONArray("membership_roles")?.strictStringValues() ?: return null + } else { + emptyList() + } return NexusOAuthAccount( id = userId.toString(), diff --git a/app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt b/app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt index 6d1f9f18a5..94080a8a7a 100644 --- a/app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt +++ b/app/src/main/java/app/gamenative/mods/NexusOAuthModels.kt @@ -24,6 +24,13 @@ enum class NexusConnectionState { CONNECTED, } +enum class NexusAuthError { + SIGN_IN_FAILED, + SESSION_EXPIRED, + REFRESH_RETRY_PENDING, + CREDENTIAL_STORAGE_FAILED, +} + data class NexusOAuthAccount( val id: String, val name: String, @@ -40,7 +47,7 @@ data class NexusOAuthAccount( data class NexusAuthState( val connection: NexusConnectionState = NexusConnectionState.DISCONNECTED, val account: NexusOAuthAccount? = null, - val errorMessage: String? = null, + val error: NexusAuthError? = null, ) { val isConnected: Boolean get() = connection == NexusConnectionState.CONNECTED diff --git a/app/src/main/java/app/gamenative/mods/NexusOAuthService.kt b/app/src/main/java/app/gamenative/mods/NexusOAuthService.kt index 1ce129853b..f7b394404f 100644 --- a/app/src/main/java/app/gamenative/mods/NexusOAuthService.kt +++ b/app/src/main/java/app/gamenative/mods/NexusOAuthService.kt @@ -98,10 +98,14 @@ internal class NexusOAuthService( if (id == null || name.isBlank()) { throw NexusOAuthException("Nexus returned an incomplete account response") } - val rolesJson = json.optJSONArray("membership_roles") ?: JSONArray() + val rolesJson = json.optJSONArray("membership_roles") + ?: throw NexusOAuthException("Nexus returned an incomplete account response") val roles = buildList { for (index in 0 until rolesJson.length()) { - rolesJson.optString(index).takeIf(String::isNotBlank)?.let(::add) + val role = (rolesJson.opt(index) as? String) + ?.takeIf(String::isNotBlank) + ?: throw NexusOAuthException("Nexus returned an invalid account response") + add(role) } } NexusOAuthAccount( diff --git a/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt b/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt index d0eb877de1..0dcbf26bda 100644 --- a/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt +++ b/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt @@ -46,7 +46,7 @@ data class NexusCollectionReference( object NexusUrlParser { internal sealed interface NxmDownloadGrantResult { data class Valid(val reference: NexusModReference) : NxmDownloadGrantResult - data object Expired : NxmDownloadGrantResult + data class Expired(val reference: NexusModReference) : NxmDownloadGrantResult data object Malformed : NxmDownloadGrantResult } @@ -93,23 +93,42 @@ object NexusUrlParser { } private fun parseNxmUrl(uri: URI): NexusModReference? { - val structure = parseNxmStructure(uri) ?: return null - val query = parseNxmQuery(uri.rawQuery) ?: return null - val downloadAuthorization = query.singleValue("key") + if (uri.isOpaque || uri.userInfo != null || uri.port != -1 || uri.fragment != null) return null + val gameDomain = uri.host + ?.lowercase(Locale.US) + ?.takeIf(nexusGameDomainPattern::matches) + ?: return null + val segments = uri.path + ?.split('/') + ?.filter(String::isNotBlank) + ?: return null + val modsIndex = segments.indexOfFirst { it.equals("mods", ignoreCase = true) } + if (modsIndex < 0 || modsIndex + 1 >= segments.size) return null + val modId = segments[modsIndex + 1].toLongOrNull()?.takeIf { it > 0L } ?: return null + val query = parseQuery(uri.rawQuery) + val fileId = if ( + modsIndex + 3 < segments.size && + segments[modsIndex + 2].equals("files", ignoreCase = true) + ) { + segments[modsIndex + 3].toLongOrNull()?.takeIf { it > 0L } + } else { + query["file_id"]?.toLongOrNull()?.takeIf { it > 0L } + } + val downloadAuthorization = query["key"] ?.takeIf { it.isNotBlank() && it.length <= 2048 } ?.let { key -> - val expires = query.singleValue("expires")?.toLongOrNull()?.takeIf { it > 0L } + val expires = query["expires"]?.toLongOrNull()?.takeIf { it > 0L } ?: return@let null NexusDownloadAuthorization( key = key, expires = expires, - userId = query.singleValue("user_id")?.toLongOrNull()?.takeIf { it > 0L }, + userId = query["user_id"]?.toLongOrNull()?.takeIf { it > 0L }, ) } return NexusModReference( - gameDomain = structure.gameDomain, - modId = structure.modId, - fileId = structure.fileId, + gameDomain = gameDomain, + modId = modId, + fileId = fileId, downloadAuthorization = downloadAuthorization, ) } @@ -147,20 +166,19 @@ object NexusUrlParser { if ((requireUserId || rawUserId != null) && userId == null) { return NxmDownloadGrantResult.Malformed } - if (expires <= nowEpochSeconds) return NxmDownloadGrantResult.Expired - - return NxmDownloadGrantResult.Valid( - NexusModReference( - gameDomain = structure.gameDomain, - modId = structure.modId, - fileId = structure.fileId, - downloadAuthorization = NexusDownloadAuthorization( - key = key, - expires = expires, - userId = userId, - ), + val reference = NexusModReference( + gameDomain = structure.gameDomain, + modId = structure.modId, + fileId = structure.fileId, + downloadAuthorization = NexusDownloadAuthorization( + key = key, + expires = expires, + userId = userId, ), ) + if (expires <= nowEpochSeconds) return NxmDownloadGrantResult.Expired(reference) + + return NxmDownloadGrantResult.Valid(reference) } private data class NxmStructure( diff --git a/app/src/main/java/app/gamenative/service/NexusModImportService.kt b/app/src/main/java/app/gamenative/service/NexusModImportService.kt index 0bf9eaa86e..37a13911d1 100644 --- a/app/src/main/java/app/gamenative/service/NexusModImportService.kt +++ b/app/src/main/java/app/gamenative/service/NexusModImportService.kt @@ -29,6 +29,7 @@ import app.gamenative.mods.ModDownloadRegistry import app.gamenative.mods.ModImportProgress import app.gamenative.mods.NexusApiClient import app.gamenative.mods.NexusAuthManager +import app.gamenative.mods.NexusConnectionState import app.gamenative.mods.NexusDownloadAuthorization import app.gamenative.mods.NexusImportState import app.gamenative.mods.NexusIntegrationStatus @@ -863,7 +864,7 @@ class NexusModImportService : Service() { private fun nexusOnlineBlockMessage(context: Context): String? = when { !NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE -> context.getString(R.string.nexus_integration_temporarily_unavailable) - !NexusAuthManager.hasStoredSession() -> + NexusAuthManager.state.value.connection == NexusConnectionState.DISCONNECTED -> context.getString(R.string.nexus_oauth_sign_in_required) else -> null } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index fdf8b63276..028be7691c 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -113,6 +113,7 @@ import app.gamenative.mods.NexusApiClient import app.gamenative.mods.NexusApiErrorReason import app.gamenative.mods.NexusApiException import app.gamenative.mods.NexusAuthManager +import app.gamenative.mods.NexusAuthError import app.gamenative.mods.NexusAuthState import app.gamenative.mods.NexusConnectionState import app.gamenative.mods.NexusCollectionFile @@ -745,8 +746,11 @@ fun NexusModsDialog( var selectedCollectionKeys by remember { mutableStateOf>(emptySet()) } val collectionQueue = remember { mutableStateMapOf() } val websiteAuthorizationWaiters = remember { mutableMapOf>() } - LaunchedEffect(nexusAuthState.isConnected) { - if (!nexusAuthState.isConnected && websiteAuthorizationWaiters.isNotEmpty()) { + LaunchedEffect(nexusAuthState.connection) { + if ( + nexusAuthState.connection == NexusConnectionState.DISCONNECTED && + websiteAuthorizationWaiters.isNotEmpty() + ) { val error = NexusWebsiteAuthorizationException( context.getString(R.string.nexus_oauth_sign_in_required), ) @@ -754,7 +758,10 @@ fun NexusModsDialog( if (waiter.isActive) waiter.completeExceptionally(error) } } - if (!nexusAuthState.isConnected && pendingFileSelection?.reference?.downloadAuthorization != null) { + if ( + nexusAuthState.connection == NexusConnectionState.DISCONNECTED && + pendingFileSelection?.reference?.downloadAuthorization != null + ) { pendingFileSelection = null } } @@ -792,6 +799,17 @@ fun NexusModsDialog( }, ) val nexusAdultContentBlockedMessage = context.getString(R.string.nexus_adult_content_blocked) + val nexusAuthErrorMessage = nexusAuthState.error?.let { error -> + context.getString( + when (error) { + NexusAuthError.SIGN_IN_FAILED, + NexusAuthError.CREDENTIAL_STORAGE_FAILED, + -> R.string.nexus_oauth_sign_in_failed + NexusAuthError.SESSION_EXPIRED -> R.string.nexus_oauth_sign_in_required + NexusAuthError.REFRESH_RETRY_PENDING -> R.string.nexus_oauth_session_unavailable + }, + ) + } fun nexusUserMessage( error: Throwable, @@ -834,25 +852,55 @@ fun NexusModsDialog( blockUnavailableOnlineAccess() return } - val authorizationUri = runCatching { NexusAuthManager.beginAuthorization() } - .getOrElse { error -> - Timber.w( - "[NexusOAuth]: Could not prepare browser sign-in (%s)", - error.javaClass.simpleName, - ) - SnackbarManager.show(context.getString(R.string.nexus_oauth_sign_in_failed)) - return + scope.launch { + nexusAuthActionInProgress = true + try { + val authorizationUri = try { + NexusAuthManager.beginAuthorization() + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { + Timber.w( + "[NexusOAuth]: Could not prepare browser sign-in (%s)", + error.javaClass.simpleName, + ) + SnackbarManager.show(context.getString(R.string.nexus_oauth_sign_in_failed)) + return@launch + } + val launchError = NexusOAuthBrowserLauncher.launch(context, authorizationUri) + .exceptionOrNull() + if (launchError != null) { + Timber.w( + "[NexusOAuth]: Could not launch the sign-in browser (%s)", + launchError.javaClass.simpleName, + ) + SnackbarManager.show(context.getString(R.string.nexus_oauth_browser_failed)) + // Reset the pending transaction and CONNECTING state when no browser accepted it. + NexusAuthManager.cancelAuthorization() + } + } finally { + nexusAuthActionInProgress = false } - NexusOAuthBrowserLauncher.launch(context, authorizationUri) - .onFailure { error -> + } + } + + fun cancelNexusAuthorization() { + if (nexusAuthActionInProgress) return + scope.launch { + nexusAuthActionInProgress = true + try { + NexusAuthManager.cancelAuthorization() + } catch (error: CancellationException) { + throw error + } catch (error: Exception) { Timber.w( - "[NexusOAuth]: Could not launch the sign-in browser (%s)", + "[NexusOAuth]: Could not cancel browser sign-in (%s)", error.javaClass.simpleName, ) - SnackbarManager.show(context.getString(R.string.nexus_oauth_browser_failed)) - // Reset the pending transaction and CONNECTING state when no browser accepted it. - NexusAuthManager.cancelAuthorization() + } finally { + nexusAuthActionInProgress = false } + } } fun disconnectNexusAccount() { @@ -2534,7 +2582,14 @@ fun NexusModsDialog( ) continue } - val downloadReference = if (nexusUserForDownloads?.isPremium == false) { + val activeNexusUser = apiClient.getCurrentUser() + if (activeNexusUser.userId != nexusUserForDownloads?.userId) { + collectionCancelRequested = true + throw NexusWebsiteAuthorizationException( + context.getString(R.string.nexus_authorization_wrong_account), + ) + } + val downloadReference = if (!activeNexusUser.isPremium) { loadingMessage = context.getString( R.string.nexus_waiting_for_website_authorization, index + 1, @@ -2551,7 +2606,7 @@ fun NexusModsDialog( reference, modInfo, file, - nexusUserForDownloads?.userId, + activeNexusUser.userId, ) if (authorizedReference == null) { updateQueue( @@ -2588,7 +2643,7 @@ fun NexusModsDialog( modInfo = modInfo, file = file, displayName = context.getString(R.string.nexus_collection_display_name, index + 1, collectionMods.size, modInfo.name), - isPremiumAccount = nexusUserForDownloads?.isPremium, + isPremiumAccount = activeNexusUser.isPremium, onProgress = { detail -> scope.launch(Dispatchers.Main) { updateQueue( @@ -3032,10 +3087,10 @@ fun NexusModsDialog( connecting = nexusAuthState.connection == NexusConnectionState.CONNECTING, accountName = nexusAuthState.account?.name, premium = nexusAuthState.account?.isPremium, - errorMessage = nexusAuthState.errorMessage, + errorMessage = nexusAuthErrorMessage, actionInProgress = nexusAuthActionInProgress, onConnect = ::connectNexusAccount, - onCancelConnect = NexusAuthManager::cancelAuthorization, + onCancelConnect = ::cancelNexusAuthorization, onDisconnect = ::disconnectNexusAccount, ) if (nexusAuthState.isConnected) { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt index d4a645a15b..fd262eb5f0 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusOAuthAccountSection.kt @@ -69,7 +69,7 @@ internal fun NexusOAuthAccountSection( Text( text = when { - actionInProgress -> stringResource(R.string.nexus_oauth_disconnecting) + connected && actionInProgress -> stringResource(R.string.nexus_oauth_disconnecting) connecting -> stringResource(R.string.nexus_oauth_connecting) connected && !accountName.isNullOrBlank() -> { stringResource(R.string.nexus_oauth_connected_as, accountName) @@ -135,11 +135,7 @@ internal fun NexusOAuthAccountSection( CircularProgressIndicator(Modifier.size(18.dp), strokeWidth = 2.dp) Spacer(Modifier.size(8.dp)) } - Text( - stringResource( - if (busy) R.string.nexus_oauth_disconnecting else R.string.nexus_oauth_connect, - ), - ) + Text(stringResource(R.string.nexus_oauth_connect)) } } } diff --git a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt index 2b82db3846..86b7e329b9 100644 --- a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt +++ b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt @@ -24,6 +24,12 @@ class NexusOAuthCallbackActivity : ComponentActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) + if (savedInstanceState != null) { + NexusOAuthCallbackContract.consumeAndScrub(intent) + setIntent(Intent(this, NexusOAuthCallbackActivity::class.java)) + returnToApp() + return + } receiveCallback(intent) } @@ -36,17 +42,16 @@ class NexusOAuthCallbackActivity : ComponentActivity() { val callbackUri = NexusOAuthCallbackContract.consumeAndScrub(sourceIntent) setIntent(Intent(this, NexusOAuthCallbackActivity::class.java)) + if (callbackJob?.isActive == true) { + Timber.w("[NexusOAuth]: Ignoring a second callback while one is already being processed") + return + } if (callbackUri == null) { Timber.w("[NexusOAuth]: Rejected an intent that did not match the registered redirect") SnackbarManager.show(getString(R.string.nexus_oauth_invalid_callback)) returnToApp() return } - if (callbackJob?.isActive == true) { - Timber.w("[NexusOAuth]: Ignoring a second callback while one is already being processed") - return - } - callbackJob = lifecycleScope.launch { NexusAuthManager.handleAuthorizationCallback(callbackUri) .onSuccess { account -> diff --git a/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt b/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt index 1f52ab6491..b109e33812 100644 --- a/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt @@ -258,11 +258,10 @@ class NexusDownloadLinkInboxTest { fun expiredAndMalformedBrowserFirstGrants_areDistinguished() { val registration = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") try { - assertEquals( - NexusNxmSubmission.Expired, + assertTrue( NexusDownloadLinkInbox.submitIntent( "nxm://newvegas/mods/60006/files/70006?key=expired&expires=1&user_id=99", - ), + ) is NexusNxmSubmission.Expired, ) assertEquals( NexusNxmSubmission.Malformed, @@ -276,6 +275,76 @@ class NexusDownloadLinkInboxTest { } } + @Test + fun expiredExpectedGrant_clearsExpectationAndNotifiesCollector() = runBlocking { + val pending = pendingDownload(appId = "STEAM_22380", modId = 60010L, fileId = 70010L) + val registration = NexusDownloadLinkInbox.registerReceiver(pending.appId) + try { + assertTrue(NexusDownloadLinkInbox.expect(pending)) + + val result = NexusDownloadLinkInbox.submitIntent( + "nxm://newvegas/mods/60010/files/70010?key=expired-expected&expires=1&user_id=99", + ) + + assertTrue(result is NexusNxmSubmission.Expired) + val delivered = withTimeout(1_000L) { + NexusDownloadLinkInbox.callbacksFor(pending.appId).first() + } + assertEquals(pending, delivered.pending) + assertTrue(delivered.reference.downloadAuthorization?.isExpired() == true) + assertTrue(NexusDownloadLinkInbox.expect(pending.copy(requestId = "retry"))) + } finally { + registration.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun browserFirst_duplicateRegistrationsForSameGame_areNotAmbiguous() = runBlocking { + val first = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + val second = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + try { + val result = NexusDownloadLinkInbox.submitIntent( + callbackUrl(modId = 60008L, fileId = 70008L, key = "same-game-overlap"), + ) + + assertTrue(result is NexusNxmSubmission.BrowserFirst) + assertEquals( + 60008L, + withTimeout(1_000L) { + NexusDownloadLinkInbox.browserFirstCallbacksFor("STEAM_22380").first() + }.reference.modId, + ) + } finally { + first.unregister() + second.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + + @Test + fun browserFirst_grantBufferedForClosedDialog_isDiscarded() = runBlocking { + val first = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + assertTrue( + NexusDownloadLinkInbox.submitIntent( + callbackUrl(modId = 60009L, fileId = 70009L, key = "closed-dialog"), + ) is NexusNxmSubmission.BrowserFirst, + ) + first.unregister() + + val reopened = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") + try { + assertNull( + withTimeoutOrNull(50L) { + NexusDownloadLinkInbox.browserFirstCallbacksFor("STEAM_22380").first() + }, + ) + } finally { + reopened.unregister() + NexusDownloadLinkInbox.clearAll() + } + } + private fun callbackUrl(modId: Long, fileId: Long, key: String = "signed-grant"): String = "nxm://newvegas/mods/$modId/files/$fileId?key=$key&expires=4000000000&user_id=99" diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt index dea83e082c..5c6fa8f46e 100644 --- a/app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthAccessTokenTest.kt @@ -5,6 +5,7 @@ import org.json.JSONArray import org.json.JSONObject import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotNull import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -36,7 +37,26 @@ class NexusOAuthAccessTokenTest { ) assertTrue(lifetime?.isPremium == true) - assertFalse(supporter?.isPremium == true) + assertNotNull(supporter) + assertFalse(requireNotNull(supporter).isPremium) + } + + @Test + fun omittedMembershipRoles_parsesAsFreeAccount() { + val token = nexusTestJwt( + JSONObject().put( + "user", + JSONObject() + .put("id", 42) + .put("username", "Free Modder"), + ), + ) + + val account = nexusAccountFromAccessToken(token) + + assertNotNull(account) + assertEquals(emptyList(), account?.membershipRoles) + assertFalse(requireNotNull(account).isPremium) } @Test diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt index 9444c97db5..e09c3ac49c 100644 --- a/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt @@ -115,6 +115,49 @@ class NexusOAuthControllerTest { assertTrue(store.tokens?.account?.isPremium == true) } + @Test + fun callback_accountMetadataPersistenceFailureKeepsInstalledSessionUsable() = runBlocking { + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + failTokenWriteAfter = 1 + } + val remote = FakeOAuthRemote( + accessToken = nexusTestAccessToken(username = "Token Modder"), + ) + val controller = controller(store, remote, nowMillis = 2_000L) + + val result = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + + assertTrue(result.isSuccess) + assertEquals("Modder", result.getOrNull()?.name) + assertEquals("Token Modder", store.tokens?.account?.name) + assertEquals("Modder", controller.state.value.account?.name) + assertTrue(controller.state.value.isConnected) + } + + @Test + fun callback_retriesMissingIdentityThenRejectsUnverifiableSession() = runBlocking { + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val remote = FakeOAuthRemote( + accessToken = "opaque-access-token", + userInfoError = NexusOAuthException("userinfo unavailable"), + ) + val controller = controller(store, remote, nowMillis = 2_000L) + + val result = controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + + assertTrue(result.isFailure) + assertEquals(2, remote.userInfoCalls) + assertNull(store.tokens) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + } + @Test fun cancelAuthorization_duringExchangePreventsLateTokenInstallation() = runBlocking { val exchangeStarted = CompletableDeferred() @@ -297,7 +340,7 @@ class NexusOAuthControllerTest { assertNull(store.tokens) assertEquals(1, invalidations) assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) - assertTrue(controller.state.value.errorMessage.orEmpty().contains("connect", ignoreCase = true)) + assertEquals(NexusAuthError.SESSION_EXPIRED, controller.state.value.error) } @Test @@ -438,13 +481,16 @@ private class MemoryOAuthStore : NexusOAuthStore { var transaction: NexusAuthorizationTransaction? = null var tokenWrites: Int = 0 var failTokenWrites: Boolean = false + var failTokenWriteAfter: Int? = null var failTokenClears: Boolean = false var failTransactionClears: Boolean = false override fun readTokens(): NexusStoredTokens? = tokens override fun writeTokens(tokens: NexusStoredTokens) { - if (failTokenWrites) throw IllegalStateException("storage full") + if (failTokenWrites || tokenWrites >= (failTokenWriteAfter ?: Int.MAX_VALUE)) { + throw IllegalStateException("storage full") + } tokenWrites += 1 this.tokens = tokens } @@ -477,6 +523,7 @@ private class FakeOAuthRemote( ) : NexusOAuthRemote { var exchangeCalls = 0 var refreshCalls = 0 + var userInfoCalls = 0 var exchangedCode: String? = null var exchangedVerifier: String? = null val revocationHints = mutableListOf() @@ -498,6 +545,7 @@ private class FakeOAuthRemote( } override suspend fun getUserInfo(accessToken: String): NexusOAuthAccount { + userInfoCalls += 1 userInfoError?.let { throw it } return NexusOAuthAccount("42", "Modder", membershipRoles = listOf("premium")) } diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt index 5d47f8e21f..8d0d2891db 100644 --- a/app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthServiceTest.kt @@ -193,4 +193,17 @@ class NexusOAuthServiceTest { assertTrue(error is NexusOAuthException) } + + @Test + fun userInfo_rejectsMissingMembershipRoles() = runBlocking { + server.enqueue( + MockResponse().setBody( + """{"sub":"42","name":"Modder"}""", + ), + ) + + val error = runCatching { service.getUserInfo("access-one") }.exceptionOrNull() + + assertTrue(error is NexusOAuthException) + } } diff --git a/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt b/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt index a62c2871d6..b33358b248 100644 --- a/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt @@ -57,7 +57,7 @@ class NexusUrlParserTest { nowEpochSeconds = 100L, ) - assertEquals(NexusUrlParser.NxmDownloadGrantResult.Expired, result) + assertTrue(result is NexusUrlParser.NxmDownloadGrantResult.Expired) } @Test @@ -98,6 +98,18 @@ class NexusUrlParserTest { assertNull(NexusUrlParser.parse("https://example.com/skyrim/mods/1")) } + @Test + fun parseNxmReference_preservesLegacyModOnlyAndQueryFileForms() { + val modOnly = NexusUrlParser.parse("nxm://skyrimspecialedition/mods/30379") + val queryFile = NexusUrlParser.parse( + "nxm://skyrimspecialedition/mods/30379?file_id=92910", + ) + + assertEquals(30379L, modOnly?.modId) + assertNull(modOnly?.fileId) + assertEquals(92910L, queryFile?.fileId) + } + @Test fun parse_collectionUrl_extractsGameSlugAndRevision() { val parsed = NexusCollectionUrlParser.parse( diff --git a/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt b/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt index 0f9e7150a9..f6b37ce43d 100644 --- a/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt +++ b/app/src/test/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackContractTest.kt @@ -38,14 +38,17 @@ class NexusOAuthCallbackContractTest { ).apply { putExtra("secret", "value") clipData = ClipData.newPlainText("secret", "value") + selector = Intent(Intent.ACTION_VIEW, Uri.parse("https://example.test/secret")) } val callback = NexusOAuthCallbackContract.consumeAndScrub(intent) assertEquals("secret-code", callback?.getQueryParameter("code")) + assertEquals("secret-state", callback?.getQueryParameter("state")) assertNull(intent.data) assertNull(intent.extras) assertNull(intent.clipData) + assertNull(intent.selector) } @Test From 10c8968403c75013da98483c6ada590e9db87576 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 20:59:25 -0500 Subject: [PATCH 03/60] fix: block Nexus imports until authentication completes --- .../app/gamenative/service/NexusModImportService.kt | 7 +++++-- .../service/NexusModImportServiceRobolectricTest.kt | 13 +++++++++++++ 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/app/src/main/java/app/gamenative/service/NexusModImportService.kt b/app/src/main/java/app/gamenative/service/NexusModImportService.kt index 37a13911d1..eb828463ca 100644 --- a/app/src/main/java/app/gamenative/service/NexusModImportService.kt +++ b/app/src/main/java/app/gamenative/service/NexusModImportService.kt @@ -861,10 +861,13 @@ class NexusModImportService : Service() { } } - private fun nexusOnlineBlockMessage(context: Context): String? = when { + internal fun nexusOnlineBlockMessage( + context: Context, + connection: NexusConnectionState = NexusAuthManager.state.value.connection, + ): String? = when { !NexusIntegrationStatus.ONLINE_ACCESS_AVAILABLE -> context.getString(R.string.nexus_integration_temporarily_unavailable) - NexusAuthManager.state.value.connection == NexusConnectionState.DISCONNECTED -> + connection != NexusConnectionState.CONNECTED -> context.getString(R.string.nexus_oauth_sign_in_required) else -> null } diff --git a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt index 1722b66a84..9c4a04610d 100644 --- a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt +++ b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt @@ -12,6 +12,7 @@ import app.gamenative.R import app.gamenative.data.ModInstall import app.gamenative.data.ModInstallSource import app.gamenative.data.ModInstallStatus +import app.gamenative.mods.NexusConnectionState import app.gamenative.mods.NexusImportState import app.gamenative.mods.NexusModFile import app.gamenative.mods.NexusModInfo @@ -103,6 +104,18 @@ class NexusModImportServiceRobolectricTest { assertNull(shadowApplication.nextStartedService) } + @Test + fun nexusOnlineBlockMessage_connectingRequiresSignIn() { + val context = ApplicationProvider.getApplicationContext() + + val message = NexusModImportService.nexusOnlineBlockMessage( + context, + NexusConnectionState.CONNECTING, + ) + + assertEquals(context.getString(R.string.nexus_oauth_sign_in_required), message) + } + @Test fun terminalLocalResumeFailure_restoresPreviousInstallOnlyWhenContentIsAvailable() { val previous = localInstall(ModInstallStatus.READY) From 6cf14bdba8f3d2d09b7b0e3b2208094959d3e878 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 21:07:11 -0500 Subject: [PATCH 04/60] test: isolate Nexus import authentication states --- .../NexusModImportServiceRobolectricTest.kt | 57 +++++++------------ 1 file changed, 19 insertions(+), 38 deletions(-) diff --git a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt index 9c4a04610d..f9738cff75 100644 --- a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt +++ b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt @@ -14,10 +14,6 @@ import app.gamenative.data.ModInstallSource import app.gamenative.data.ModInstallStatus import app.gamenative.mods.NexusConnectionState import app.gamenative.mods.NexusImportState -import app.gamenative.mods.NexusModFile -import app.gamenative.mods.NexusModInfo -import app.gamenative.mods.NexusModReference -import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertNull @@ -26,7 +22,6 @@ import org.junit.Before import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner -import org.robolectric.Shadows.shadowOf import org.robolectric.shadows.ShadowContentResolver @RunWith(RobolectricTestRunner::class) @@ -76,44 +71,30 @@ class NexusModImportServiceRobolectricTest { } @Test - fun enqueueNexusImport_disconnected_failsBeforeStartingService() = runBlocking { + fun nexusOnlineBlockMessage_requiresConnectedState() { val context = ApplicationProvider.getApplicationContext() - val shadowApplication = shadowOf(context) - while (shadowApplication.nextStartedService != null) { - // Ignore unrelated services started by application initialization. - } + val signInRequired = context.getString(R.string.nexus_oauth_sign_in_required) - val result = NexusModImportService.enqueueImport( - context = context, - appId = "steam_123", - reference = NexusModReference("fallout4", 10L, 20L), - modInfo = NexusModInfo(10L, "Test mod", "", "1.0"), - file = NexusModFile( - fileId = 20L, - name = "Test file", - version = "1.0", - fileName = "test.zip", - sizeBytes = 1L, - uploadedTimestamp = 1L, + assertEquals( + signInRequired, + NexusModImportService.nexusOnlineBlockMessage( + context, + NexusConnectionState.DISCONNECTED, ), - displayName = "Test mod", ) - val error = runCatching { result.await() }.exceptionOrNull() - - assertEquals(context.getString(R.string.nexus_oauth_sign_in_required), error?.message) - assertNull(shadowApplication.nextStartedService) - } - - @Test - fun nexusOnlineBlockMessage_connectingRequiresSignIn() { - val context = ApplicationProvider.getApplicationContext() - - val message = NexusModImportService.nexusOnlineBlockMessage( - context, - NexusConnectionState.CONNECTING, + assertEquals( + signInRequired, + NexusModImportService.nexusOnlineBlockMessage( + context, + NexusConnectionState.CONNECTING, + ), + ) + assertNull( + NexusModImportService.nexusOnlineBlockMessage( + context, + NexusConnectionState.CONNECTED, + ), ) - - assertEquals(context.getString(R.string.nexus_oauth_sign_in_required), message) } @Test From 16406e2fe0747a119f85203984cf006ac711abeb Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 21:15:55 -0500 Subject: [PATCH 05/60] test: cover Nexus import authentication gate --- .../service/NexusModImportService.kt | 5 +- .../NexusModImportServiceRobolectricTest.kt | 90 ++++++++++++++----- 2 files changed, 71 insertions(+), 24 deletions(-) diff --git a/app/src/main/java/app/gamenative/service/NexusModImportService.kt b/app/src/main/java/app/gamenative/service/NexusModImportService.kt index eb828463ca..e982dfc2f8 100644 --- a/app/src/main/java/app/gamenative/service/NexusModImportService.kt +++ b/app/src/main/java/app/gamenative/service/NexusModImportService.kt @@ -627,7 +627,7 @@ class NexusModImportService : Service() { @Volatile private var currentService: NexusModImportService? = null - fun enqueueImport( + internal fun enqueueImport( context: Context, appId: String, reference: NexusModReference, @@ -636,8 +636,9 @@ class NexusModImportService : Service() { displayName: String, isPremiumAccount: Boolean? = null, onProgress: (ModImportProgress) -> Unit = {}, + connection: NexusConnectionState = NexusAuthManager.state.value.connection, ): Deferred { - nexusOnlineBlockMessage(context)?.let { message -> + nexusOnlineBlockMessage(context, connection)?.let { message -> return failedImport( IllegalStateException(message), ) diff --git a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt index f9738cff75..e9062c207d 100644 --- a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt +++ b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt @@ -1,8 +1,11 @@ package app.gamenative.service import android.app.Application +import android.content.ComponentName import android.content.ContentProvider import android.content.ContentValues +import android.content.Context +import android.content.ContextWrapper import android.content.Intent import android.database.Cursor import android.net.Uri @@ -14,6 +17,10 @@ import app.gamenative.data.ModInstallSource import app.gamenative.data.ModInstallStatus import app.gamenative.mods.NexusConnectionState import app.gamenative.mods.NexusImportState +import app.gamenative.mods.NexusModFile +import app.gamenative.mods.NexusModInfo +import app.gamenative.mods.NexusModReference +import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertNull @@ -71,30 +78,33 @@ class NexusModImportServiceRobolectricTest { } @Test - fun nexusOnlineBlockMessage_requiresConnectedState() { - val context = ApplicationProvider.getApplicationContext() - val signInRequired = context.getString(R.string.nexus_oauth_sign_in_required) + fun enqueueNexusImport_requiresConnectedStateBeforeServiceHandoff() = runBlocking { + val application = ApplicationProvider.getApplicationContext() + val signInRequired = application.getString(R.string.nexus_oauth_sign_in_required) + listOf( + NexusConnectionState.DISCONNECTED, + NexusConnectionState.CONNECTING, + ).forEach { connection -> + val context = RecordingServiceContext(application) + val error = runCatching { + enqueueNexusImport(context, connection).await() + }.exceptionOrNull() - assertEquals( - signInRequired, - NexusModImportService.nexusOnlineBlockMessage( - context, - NexusConnectionState.DISCONNECTED, - ), - ) - assertEquals( - signInRequired, - NexusModImportService.nexusOnlineBlockMessage( - context, - NexusConnectionState.CONNECTING, - ), - ) - assertNull( - NexusModImportService.nexusOnlineBlockMessage( - context, - NexusConnectionState.CONNECTED, - ), + assertEquals(signInRequired, error?.message) + assertNull(context.startedIntent) + } + + val connectedContext = RecordingServiceContext(application) + val error = runCatching { + enqueueNexusImport(connectedContext, NexusConnectionState.CONNECTED).await() + }.exceptionOrNull() + + assertEquals(SERVICE_CAPTURED_MESSAGE, error?.message) + val request = NexusModImportService.decodeImportRequest( + requireNotNull(connectedContext.startedIntent), ) + assertEquals("steam_123", request?.appId) + assertEquals(20L, request?.file?.fileId) } @Test @@ -173,6 +183,41 @@ class NexusModImportServiceRobolectricTest { archiveSha256 = "fingerprint", ) + private fun enqueueNexusImport( + context: Context, + connection: NexusConnectionState, + ) = NexusModImportService.enqueueImport( + context = context, + appId = "steam_123", + reference = NexusModReference("fallout4", 10L, 20L), + modInfo = NexusModInfo(10L, "Test mod", "", "1.0"), + file = NexusModFile( + fileId = 20L, + name = "Test file", + version = "1.0", + fileName = "test.zip", + sizeBytes = 1L, + uploadedTimestamp = 1L, + ), + displayName = "Test mod", + connection = connection, + ) + + private class RecordingServiceContext(base: Context) : ContextWrapper(base) { + var startedIntent: Intent? = null + + override fun getApplicationContext(): Context = this + + override fun startService(service: Intent): ComponentName? = capture(service) + + override fun startForegroundService(service: Intent): ComponentName? = capture(service) + + private fun capture(service: Intent): Nothing { + startedIntent = service + throw IllegalStateException(SERVICE_CAPTURED_MESSAGE) + } + } + private class RejectingMimeProbeProvider : ContentProvider() { var mimeTypeProbeCount = 0 @@ -214,5 +259,6 @@ class NexusModImportServiceRobolectricTest { private companion object { const val AUTHORITY = "app.gamenative.test.localmodservice" + const val SERVICE_CAPTURED_MESSAGE = "service intent captured" } } From 2cb85235149d6bc8712df776145e56d5d02e2160 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 21:22:36 -0500 Subject: [PATCH 06/60] fix: preserve resumable local import service work --- .../app/gamenative/service/NexusModImportService.kt | 11 ++--------- .../service/NexusModImportServiceRobolectricTest.kt | 12 ++++++++++++ 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/app/src/main/java/app/gamenative/service/NexusModImportService.kt b/app/src/main/java/app/gamenative/service/NexusModImportService.kt index e982dfc2f8..308a08ff59 100644 --- a/app/src/main/java/app/gamenative/service/NexusModImportService.kt +++ b/app/src/main/java/app/gamenative/service/NexusModImportService.kt @@ -97,7 +97,7 @@ class NexusModImportService : Service() { } } } - return START_NOT_STICKY + return START_STICKY } when { intent?.action == ACTION_RUN_IMPORT || intent?.action == ACTION_RUN_LOCAL_IMPORT -> @@ -106,14 +106,7 @@ class NexusModImportService : Service() { requestResumeInterruptedImports() else -> scheduleStopIfIdle() } - return if ( - intent?.action == ACTION_RUN_LOCAL_IMPORT || - nexusOnlineBlockMessage == null - ) { - START_STICKY - } else { - START_NOT_STICKY - } + return START_STICKY } override fun onBind(intent: Intent?): IBinder? = null diff --git a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt index e9062c207d..7256921ba0 100644 --- a/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt +++ b/app/src/test/java/app/gamenative/service/NexusModImportServiceRobolectricTest.kt @@ -1,6 +1,7 @@ package app.gamenative.service import android.app.Application +import android.app.Service import android.content.ComponentName import android.content.ContentProvider import android.content.ContentValues @@ -28,6 +29,7 @@ import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import org.junit.runner.RunWith +import org.robolectric.Robolectric import org.robolectric.RobolectricTestRunner import org.robolectric.shadows.ShadowContentResolver @@ -107,6 +109,16 @@ class NexusModImportServiceRobolectricTest { assertEquals(20L, request?.file?.fileId) } + @Test + fun nullRestart_remainsStickyWhileResumeWorkMayContinue() { + val controller = Robolectric.buildService(NexusModImportService::class.java).create() + try { + assertEquals(Service.START_STICKY, controller.get().onStartCommand(null, 0, 1)) + } finally { + controller.destroy() + } + } + @Test fun terminalLocalResumeFailure_restoresPreviousInstallOnlyWhenContentIsAvailable() { val previous = localInstall(ModInstallStatus.READY) From 7508183ffd8bc162c8a9fbf76ef3010916f33a98 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 21:41:50 -0500 Subject: [PATCH 07/60] fix: preserve Nexus callbacks across lifecycle changes --- .../main/java/app/gamenative/MainActivity.kt | 16 +++---- .../app/gamenative/mods/NexusAuthManager.kt | 13 +++++ .../gamenative/mods/NexusDownloadLinkInbox.kt | 23 +-------- .../app/gamenative/mods/NexusUrlParser.kt | 14 +++--- .../screen/auth/NexusOAuthCallbackActivity.kt | 48 +++++++++++-------- .../mods/NexusDownloadLinkInboxTest.kt | 26 +++++----- .../mods/NexusOAuthControllerTest.kt | 34 +++++++++++++ .../app/gamenative/mods/NexusUrlParserTest.kt | 11 ++++- 8 files changed, 117 insertions(+), 68 deletions(-) diff --git a/app/src/main/java/app/gamenative/MainActivity.kt b/app/src/main/java/app/gamenative/MainActivity.kt index f94d09026b..88de272136 100644 --- a/app/src/main/java/app/gamenative/MainActivity.kt +++ b/app/src/main/java/app/gamenative/MainActivity.kt @@ -63,6 +63,7 @@ import com.winlator.core.AppUtils import com.winlator.inputcontrols.ControllerManager import dagger.hilt.android.AndroidEntryPoint import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.NonCancellable import kotlinx.coroutines.launch import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock @@ -74,10 +75,9 @@ import timber.log.Timber @AndroidEntryPoint class MainActivity : ComponentActivity() { - - private val nxmIntentMutex = Mutex() - companion object { + private val nxmIntentMutex = Mutex() + private var totalIndex = 0 private var currentOrientationChangeValue: Int = 0 @@ -318,7 +318,9 @@ class MainActivity : ComponentActivity() { // otherwise replay it after a configuration change or process recreation. setIntent(Intent(this, MainActivity::class.java).setAction(Intent.ACTION_MAIN)) lifecycleScope.launch { - nxmIntentMutex.withLock { handleNxmIntent(rawNxmUrl) } + withContext(NonCancellable) { + nxmIntentMutex.withLock { handleNxmIntent(rawNxmUrl) } + } } return } @@ -394,11 +396,7 @@ class MainActivity : ComponentActivity() { submission.reference.fileId, ) } - is NexusNxmSubmission.Expired -> { - NexusDownloadLinkInbox.cancelExpected(submission.reference) - withContext(Dispatchers.IO) { - NexusPendingDownloadStore.removeMatching(this@MainActivity, submission.reference) - } + NexusNxmSubmission.Expired -> { Timber.i("[NexusDownload]: Ignoring expired NXM callback") SnackbarManager.show(getString(R.string.nexus_authorization_expired)) } diff --git a/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt index 8babd784de..db5e703a7a 100644 --- a/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt @@ -215,6 +215,19 @@ internal class NexusOAuthController( Result.success(account) } catch (error: CancellationException) { restoreStateAfterAuthorizationFailure(attemptState) + synchronized(authorizationLock) { + if (mutableState.value.connection == NexusConnectionState.CONNECTING) { + // An opaque token has no locally verifiable account identity. If its + // lookup is canceled, discard it instead of leaving a permanent + // CONNECTING session that cannot safely authorize downloads. + runCatching { store.clearTokens() } + activeAuthorizationState = null + invalidateSessionSideData() + mutableState.value = NexusAuthState( + connection = NexusConnectionState.DISCONNECTED, + ) + } + } throw error } catch (error: Exception) { restoreStateAfterAuthorizationFailure(attemptState, NexusAuthError.SIGN_IN_FAILED) diff --git a/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt b/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt index c41a2d7f88..2283035027 100644 --- a/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt +++ b/app/src/main/java/app/gamenative/mods/NexusDownloadLinkInbox.kt @@ -37,7 +37,7 @@ sealed interface NexusNxmSubmission { val reference: NexusModReference, ) : NexusNxmSubmission - data class Expired(val reference: NexusModReference) : NexusNxmSubmission + data object Expired : NexusNxmSubmission data object NoActiveTarget : NexusNxmSubmission data object AmbiguousTarget : NexusNxmSubmission data object Replayed : NexusNxmSubmission @@ -150,20 +150,7 @@ object NexusDownloadLinkInbox { val parsed = NexusUrlParser.parseNxmDownloadGrant(rawUrl, requireUserId = false) ) { is NexusUrlParser.NxmDownloadGrantResult.Valid -> parsed.reference - is NexusUrlParser.NxmDownloadGrantResult.Expired -> { - val reference = parsed.reference - synchronized(pendingLock) { - removeExpiredPendingDownloads() - pendingWebsiteDownloads.remove(reference.fileKey())?.let { pending -> - if (pending.appId in activeReceivers.values) { - callbackChannelFor(pending.appId).trySend( - AuthorizedNexusWebsiteDownload(pending, reference), - ) - } - } - } - return NexusNxmSubmission.Expired(reference) - } + NexusUrlParser.NxmDownloadGrantResult.Expired -> return NexusNxmSubmission.Expired NexusUrlParser.NxmDownloadGrantResult.Malformed -> return NexusNxmSubmission.Malformed } val authorization = reference.downloadAuthorization ?: return NexusNxmSubmission.Malformed @@ -227,12 +214,6 @@ object NexusDownloadLinkInbox { } } - fun cancelExpected(reference: NexusModReference) { - synchronized(pendingLock) { - pendingWebsiteDownloads.remove(reference.fileKey()) - } - } - /** Clears account-bound website expectations and any already buffered one-use grants. */ fun clearAll() { synchronized(pendingLock) { diff --git a/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt b/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt index 0dcbf26bda..b14d4c9b4d 100644 --- a/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt +++ b/app/src/main/java/app/gamenative/mods/NexusUrlParser.kt @@ -46,7 +46,7 @@ data class NexusCollectionReference( object NexusUrlParser { internal sealed interface NxmDownloadGrantResult { data class Valid(val reference: NexusModReference) : NxmDownloadGrantResult - data class Expired(val reference: NexusModReference) : NxmDownloadGrantResult + data object Expired : NxmDownloadGrantResult data object Malformed : NxmDownloadGrantResult } @@ -105,24 +105,24 @@ object NexusUrlParser { val modsIndex = segments.indexOfFirst { it.equals("mods", ignoreCase = true) } if (modsIndex < 0 || modsIndex + 1 >= segments.size) return null val modId = segments[modsIndex + 1].toLongOrNull()?.takeIf { it > 0L } ?: return null - val query = parseQuery(uri.rawQuery) + val query = parseNxmQuery(uri.rawQuery) ?: return null val fileId = if ( modsIndex + 3 < segments.size && segments[modsIndex + 2].equals("files", ignoreCase = true) ) { segments[modsIndex + 3].toLongOrNull()?.takeIf { it > 0L } } else { - query["file_id"]?.toLongOrNull()?.takeIf { it > 0L } + query.singleValue("file_id")?.toLongOrNull()?.takeIf { it > 0L } } - val downloadAuthorization = query["key"] + val downloadAuthorization = query.singleValue("key") ?.takeIf { it.isNotBlank() && it.length <= 2048 } ?.let { key -> - val expires = query["expires"]?.toLongOrNull()?.takeIf { it > 0L } + val expires = query.singleValue("expires")?.toLongOrNull()?.takeIf { it > 0L } ?: return@let null NexusDownloadAuthorization( key = key, expires = expires, - userId = query["user_id"]?.toLongOrNull()?.takeIf { it > 0L }, + userId = query.singleValue("user_id")?.toLongOrNull()?.takeIf { it > 0L }, ) } return NexusModReference( @@ -176,7 +176,7 @@ object NexusUrlParser { userId = userId, ), ) - if (expires <= nowEpochSeconds) return NxmDownloadGrantResult.Expired(reference) + if (expires <= nowEpochSeconds) return NxmDownloadGrantResult.Expired return NxmDownloadGrantResult.Valid(reference) } diff --git a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt index 86b7e329b9..c00b10ff9a 100644 --- a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt +++ b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt @@ -9,7 +9,9 @@ import app.gamenative.R import app.gamenative.mods.NexusAuthManager import app.gamenative.ui.util.SnackbarManager import kotlinx.coroutines.Job +import kotlinx.coroutines.NonCancellable import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext import timber.log.Timber /** @@ -20,11 +22,13 @@ import timber.log.Timber * recreation or exposing it through a later inspection of the launch intent. */ class NexusOAuthCallbackActivity : ComponentActivity() { - private var callbackJob: Job? = null + private companion object { + var callbackJob: Job? = null + } override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) - if (savedInstanceState != null) { + if (savedInstanceState != null && !NexusOAuthCallbackContract.matches(intent)) { NexusOAuthCallbackContract.consumeAndScrub(intent) setIntent(Intent(this, NexusOAuthCallbackActivity::class.java)) returnToApp() @@ -53,24 +57,30 @@ class NexusOAuthCallbackActivity : ComponentActivity() { return } callbackJob = lifecycleScope.launch { - NexusAuthManager.handleAuthorizationCallback(callbackUri) - .onSuccess { account -> - if (account != null) { - SnackbarManager.show( - getString(R.string.nexus_oauth_connected_as, account.name), - ) - } - } - .onFailure { error -> - // Do not log exception messages here: OAuth server errors can include - // callback details that do not belong in application logs. - Timber.w( - "[NexusOAuth]: Browser sign-in did not complete (%s)", - error.javaClass.simpleName, - ) - SnackbarManager.show(getString(R.string.nexus_oauth_sign_in_failed)) + try { + withContext(NonCancellable) { + NexusAuthManager.handleAuthorizationCallback(callbackUri) + .onSuccess { account -> + if (account != null) { + SnackbarManager.show( + getString(R.string.nexus_oauth_connected_as, account.name), + ) + } + } + .onFailure { error -> + // Do not log exception messages here: OAuth server errors can include + // callback details that do not belong in application logs. + Timber.w( + "[NexusOAuth]: Browser sign-in did not complete (%s)", + error.javaClass.simpleName, + ) + SnackbarManager.show(getString(R.string.nexus_oauth_sign_in_failed)) + } + returnToApp() } - returnToApp() + } finally { + callbackJob = null + } } } diff --git a/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt b/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt index b109e33812..f8f78a800f 100644 --- a/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusDownloadLinkInboxTest.kt @@ -258,10 +258,11 @@ class NexusDownloadLinkInboxTest { fun expiredAndMalformedBrowserFirstGrants_areDistinguished() { val registration = NexusDownloadLinkInbox.registerReceiver("STEAM_22380") try { - assertTrue( + assertEquals( + NexusNxmSubmission.Expired, NexusDownloadLinkInbox.submitIntent( "nxm://newvegas/mods/60006/files/70006?key=expired&expires=1&user_id=99", - ) is NexusNxmSubmission.Expired, + ), ) assertEquals( NexusNxmSubmission.Malformed, @@ -276,25 +277,28 @@ class NexusDownloadLinkInboxTest { } @Test - fun expiredExpectedGrant_clearsExpectationAndNotifiesCollector() = runBlocking { + fun expiredExpectedGrant_doesNotConsumeExpectation() = runBlocking { val pending = pendingDownload(appId = "STEAM_22380", modId = 60010L, fileId = 70010L) - val registration = NexusDownloadLinkInbox.registerReceiver(pending.appId) try { assertTrue(NexusDownloadLinkInbox.expect(pending)) - val result = NexusDownloadLinkInbox.submitIntent( - "nxm://newvegas/mods/60010/files/70010?key=expired-expected&expires=1&user_id=99", + assertEquals( + NexusNxmSubmission.Expired, + NexusDownloadLinkInbox.submitIntent( + "nxm://newvegas/mods/60010/files/70010?key=expired-expected&expires=1&user_id=99", + ), + ) + assertTrue( + NexusDownloadLinkInbox.submitIntent( + callbackUrl(modId = 60010L, fileId = 70010L, key = "valid-after-expired"), + ) is NexusNxmSubmission.Expected, ) - - assertTrue(result is NexusNxmSubmission.Expired) val delivered = withTimeout(1_000L) { NexusDownloadLinkInbox.callbacksFor(pending.appId).first() } assertEquals(pending, delivered.pending) - assertTrue(delivered.reference.downloadAuthorization?.isExpired() == true) - assertTrue(NexusDownloadLinkInbox.expect(pending.copy(requestId = "retry"))) + assertEquals("valid-after-expired", delivered.reference.downloadAuthorization?.key) } finally { - registration.unregister() NexusDownloadLinkInbox.clearAll() } } diff --git a/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt b/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt index e09c3ac49c..a3802ea088 100644 --- a/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusOAuthControllerTest.kt @@ -5,6 +5,7 @@ import java.util.Base64 import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.async import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.cancelAndJoin import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking @@ -158,6 +159,35 @@ class NexusOAuthControllerTest { assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) } + @Test + fun callback_canceledDuringOpaqueIdentityLookupDiscardsUnverifiedSession() = runBlocking { + val userInfoStarted = CompletableDeferred() + val userInfoRelease = CompletableDeferred() + val store = MemoryOAuthStore().apply { + transaction = NexusAuthorizationTransaction("expected-state", "verifier", 1_000L) + } + val controller = controller( + store, + FakeOAuthRemote( + accessToken = "opaque-access-token", + userInfoStarted = userInfoStarted, + userInfoRelease = userInfoRelease, + ), + nowMillis = 2_000L, + ) + val callback = async { + controller.handleAuthorizationCallback( + "app.gamenative://oauth/callback?code=authorization-code&state=expected-state", + ) + } + userInfoStarted.await() + + callback.cancelAndJoin() + + assertNull(store.tokens) + assertEquals(NexusConnectionState.DISCONNECTED, controller.state.value.connection) + } + @Test fun cancelAuthorization_duringExchangePreventsLateTokenInstallation() = runBlocking { val exchangeStarted = CompletableDeferred() @@ -520,6 +550,8 @@ private class FakeOAuthRemote( private val exchangeRelease: CompletableDeferred? = null, private val accessToken: String = "access-two", private val userInfoError: NexusOAuthException? = null, + private val userInfoStarted: CompletableDeferred? = null, + private val userInfoRelease: CompletableDeferred? = null, ) : NexusOAuthRemote { var exchangeCalls = 0 var refreshCalls = 0 @@ -546,6 +578,8 @@ private class FakeOAuthRemote( override suspend fun getUserInfo(accessToken: String): NexusOAuthAccount { userInfoCalls += 1 + userInfoStarted?.complete(Unit) + userInfoRelease?.await() userInfoError?.let { throw it } return NexusOAuthAccount("42", "Modder", membershipRoles = listOf("premium")) } diff --git a/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt b/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt index b33358b248..c64e555fe9 100644 --- a/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt +++ b/app/src/test/java/app/gamenative/mods/NexusUrlParserTest.kt @@ -50,6 +50,15 @@ class NexusUrlParserTest { assertEquals(99L, reference.downloadAuthorization?.userId) } + @Test + fun parseNxmReference_preservesLiteralPlusInSignedKey() { + val reference = NexusUrlParser.parse( + "nxm://newvegas/mods/12/files/34?key=signed+grant%2Bpart&expires=200&user_id=99", + ) + + assertEquals("signed+grant+part", reference?.downloadAuthorization?.key) + } + @Test fun parseNxmDownloadGrant_rejectsExpiredGrantSeparately() { val result = NexusUrlParser.parseNxmDownloadGrant( @@ -57,7 +66,7 @@ class NexusUrlParserTest { nowEpochSeconds = 100L, ) - assertTrue(result is NexusUrlParser.NxmDownloadGrantResult.Expired) + assertEquals(NexusUrlParser.NxmDownloadGrantResult.Expired, result) } @Test From 1f37b4f651aff72aaf59d2d9c24b86494296c191 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 22 Aug 2026 21:51:13 -0500 Subject: [PATCH 08/60] fix: serialize Nexus OAuth callback processing --- .../app/gamenative/mods/NexusAuthManager.kt | 12 +++- .../screen/auth/NexusOAuthCallbackActivity.kt | 59 ++++++++++--------- 2 files changed, 42 insertions(+), 29 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt index db5e703a7a..9ab9bd8915 100644 --- a/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusAuthManager.kt @@ -92,6 +92,7 @@ internal class NexusOAuthController( internal suspend fun handleAuthorizationCallback(callbackUri: String): Result = sessionMutex.withLock { var attemptState: String? = null + var installedAccessToken: String? = null try { val callback = parseAndValidateCallback(callbackUri) val exchange = synchronized(authorizationLock) { @@ -141,6 +142,7 @@ internal class NexusOAuthController( false } else { store.writeTokens(storedTokens) + installedAccessToken = storedTokens.accessToken activeAuthorizationState = null invalidateSessionSideData() mutableState.value = NexusAuthState( @@ -216,7 +218,15 @@ internal class NexusOAuthController( } catch (error: CancellationException) { restoreStateAfterAuthorizationFailure(attemptState) synchronized(authorizationLock) { - if (mutableState.value.connection == NexusConnectionState.CONNECTING) { + val canceledToken = installedAccessToken + val stored = store.readTokens() + if ( + activeAuthorizationState == null && + canceledToken != null && + stored?.accessToken == canceledToken && + stored.account == null && + nexusAccountFromAccessToken(stored.accessToken) == null + ) { // An opaque token has no locally verifiable account identity. If its // lookup is canceled, discard it instead of leaving a permanent // CONNECTING session that cannot safely authorize downloads. diff --git a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt index c00b10ff9a..0d54dfd0ff 100644 --- a/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt +++ b/app/src/main/java/app/gamenative/ui/screen/auth/NexusOAuthCallbackActivity.kt @@ -3,15 +3,16 @@ package app.gamenative.ui.screen.auth import android.content.Intent import android.os.Bundle import androidx.activity.ComponentActivity -import androidx.lifecycle.lifecycleScope import app.gamenative.MainActivity import app.gamenative.R import app.gamenative.mods.NexusAuthManager import app.gamenative.ui.util.SnackbarManager +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.CoroutineStart +import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.Job -import kotlinx.coroutines.NonCancellable +import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.launch -import kotlinx.coroutines.withContext import timber.log.Timber /** @@ -23,7 +24,8 @@ import timber.log.Timber */ class NexusOAuthCallbackActivity : ComponentActivity() { private companion object { - var callbackJob: Job? = null + private val callbackScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) + private var callbackJob: Job? = null } override fun onCreate(savedInstanceState: Bundle?) { @@ -48,6 +50,7 @@ class NexusOAuthCallbackActivity : ComponentActivity() { if (callbackJob?.isActive == true) { Timber.w("[NexusOAuth]: Ignoring a second callback while one is already being processed") + returnToApp() return } if (callbackUri == null) { @@ -56,32 +59,32 @@ class NexusOAuthCallbackActivity : ComponentActivity() { returnToApp() return } - callbackJob = lifecycleScope.launch { - try { - withContext(NonCancellable) { - NexusAuthManager.handleAuthorizationCallback(callbackUri) - .onSuccess { account -> - if (account != null) { - SnackbarManager.show( - getString(R.string.nexus_oauth_connected_as, account.name), - ) - } - } - .onFailure { error -> - // Do not log exception messages here: OAuth server errors can include - // callback details that do not belong in application logs. - Timber.w( - "[NexusOAuth]: Browser sign-in did not complete (%s)", - error.javaClass.simpleName, - ) - SnackbarManager.show(getString(R.string.nexus_oauth_sign_in_failed)) - } - returnToApp() + val appContext = applicationContext + val job = callbackScope.launch(start = CoroutineStart.LAZY) { + NexusAuthManager.handleAuthorizationCallback(callbackUri) + .onSuccess { account -> + if (account != null) { + SnackbarManager.show( + appContext.getString(R.string.nexus_oauth_connected_as, account.name), + ) + } + } + .onFailure { error -> + // Do not log exception messages here: OAuth server errors can include + // callback details that do not belong in application logs. + Timber.w( + "[NexusOAuth]: Browser sign-in did not complete (%s)", + error.javaClass.simpleName, + ) + SnackbarManager.show(appContext.getString(R.string.nexus_oauth_sign_in_failed)) } - } finally { - callbackJob = null - } } + callbackJob = job + job.invokeOnCompletion { + if (callbackJob === job) callbackJob = null + } + job.start() + returnToApp() } private fun returnToApp() { From d3523cdf4c6a8d7f5a54a21342e53db09a801f2c Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 11:51:28 -0500 Subject: [PATCH 09/60] test: add install plan contracts --- .../app/gamenative/mods/ModInstallPlan.kt | 158 ++++++++++++++++++ .../mods/ModInstallPlanContractTest.kt | 74 ++++++++ 2 files changed, 232 insertions(+) create mode 100644 app/src/main/java/app/gamenative/mods/ModInstallPlan.kt create mode 100644 app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt diff --git a/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt new file mode 100644 index 0000000000..e4ac037c95 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt @@ -0,0 +1,158 @@ +package app.gamenative.mods + +import java.security.MessageDigest + +enum class PlannedFileStatus { + PLACED, + INTENTIONALLY_IGNORED, + UNSUPPORTED, + MISSING, + CONFLICTED, +} + +enum class PlacementOrigin { + MANUAL_RECIPE, + GAME_RULE, + LEGACY_PRESET, + FOMOD_REQUIRED, + FOMOD_OPTION, + FOMOD_CONDITIONAL, +} + +enum class PlacementRisk { + SAFE, + REVIEW, + UNSAFE, +} + +data class PlannedModFile( + val sourceRelativePath: String, + val targetRoot: String? = null, + val targetRelativePath: String? = null, + val normalizedTargetKey: String? = null, + val status: PlannedFileStatus, + val origin: PlacementOrigin, + val priority: Int = 0, + val sizeBytes: Long = 0L, + val reason: String, + val evidence: List = emptyList(), + val risk: PlacementRisk = PlacementRisk.SAFE, +) + +data class ModInstallPlan( + val files: List, + val warnings: List = emptyList(), + val blockingIssues: List = emptyList(), +) { + val selectedCount: Int + get() = files.count { it.status != PlannedFileStatus.INTENTIONALLY_IGNORED } + + val placedCount: Int + get() = files.count { it.status == PlannedFileStatus.PLACED } + + val ignoredCount: Int + get() = files.count { it.status == PlannedFileStatus.INTENTIONALLY_IGNORED } + + val unresolvedCount: Int + get() = files.count { + it.status == PlannedFileStatus.UNSUPPORTED || + it.status == PlannedFileStatus.MISSING || + it.status == PlannedFileStatus.CONFLICTED + } + + val installableBytes: Long + get() = files.filter { it.status != PlannedFileStatus.INTENTIONALLY_IGNORED }.sumOf { it.sizeBytes } + + val placedBytes: Long + get() = files.filter { it.status == PlannedFileStatus.PLACED }.sumOf { it.sizeBytes } + + val coverage: Double + get() = if (installableBytes > 0L) { + placedBytes.toDouble() / installableBytes.toDouble() + } else if (selectedCount == 0) { + 1.0 + } else { + placedCount.toDouble() / selectedCount.toDouble() + } + + val isComplete: Boolean + get() = blockingIssues.isEmpty() && + unresolvedCount == 0 && + files.none { it.risk == PlacementRisk.UNSAFE } + + val digest: String + get() { + val canonical = files + .sortedWith( + compareBy { it.normalizedTargetKey.orEmpty() } + .thenBy { it.sourceRelativePath.lowercase() } + .thenByDescending { it.priority }, + ) + .joinToString("\n") { file -> + listOf( + file.sourceRelativePath, + file.targetRoot.orEmpty(), + file.targetRelativePath.orEmpty(), + file.normalizedTargetKey.orEmpty(), + file.status.name, + file.origin.name, + file.priority.toString(), + file.sizeBytes.toString(), + ).joinToString("|") + } + return MessageDigest.getInstance("SHA-256") + .digest(canonical.toByteArray(Charsets.UTF_8)) + .joinToString("") { "%02x".format(it) } + } + + fun sanitizedManifest(): String = buildString { + appendLine("plan-version: 1") + appendLine("digest: $digest") + appendLine("complete: $isComplete") + appendLine("placed: $placedCount/$selectedCount") + files.sortedBy { it.sourceRelativePath.lowercase() }.forEach { file -> + append(file.status.name) + append(' ') + append(file.sourceRelativePath) + if (file.targetRoot != null && file.targetRelativePath != null) { + append(" -> ") + append(file.targetRoot) + append('/') + append(file.targetRelativePath) + } + append(" [") + append(file.reason.replace('\n', ' ')) + appendLine(']') + } + warnings.sorted().forEach { appendLine("warning: ${it.replace('\n', ' ')}") } + blockingIssues.sorted().forEach { appendLine("blocker: ${it.replace('\n', ' ')}") } + } +} + +data class PlacementPlanQuality( + val placedFiles: Int, + val placedBytes: Long, + val unresolvedFiles: Int, + val blockers: Int, + val highestRisk: PlacementRisk, +) + +object PlacementPlanRegressionPolicy { + fun quality(plan: ModInstallPlan): PlacementPlanQuality = PlacementPlanQuality( + placedFiles = plan.placedCount, + placedBytes = plan.placedBytes, + unresolvedFiles = plan.unresolvedCount, + blockers = plan.blockingIssues.size, + highestRisk = plan.files.maxOfOrNull { it.risk } ?: PlacementRisk.SAFE, + ) + + fun canReplace(baseline: ModInstallPlan, candidate: ModInstallPlan): Boolean { + val old = quality(baseline) + val new = quality(candidate) + return new.placedFiles >= old.placedFiles && + new.placedBytes >= old.placedBytes && + new.unresolvedFiles <= old.unresolvedFiles && + new.blockers <= old.blockers && + new.highestRisk <= old.highestRisk + } +} diff --git a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt new file mode 100644 index 0000000000..5db9ca005e --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt @@ -0,0 +1,74 @@ +package app.gamenative.mods + +import app.gamenative.data.ModTargetRoot +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class ModInstallPlanContractTest { + @Test + fun plan_requiresEverySelectedFileToBePlacedOrExplained() { + val complete = plan(placed = listOf("Sounds/theme.xwm"), ignored = listOf("readme.txt")) + val partial = plan(placed = listOf("Sounds/theme.xwm"), unsupported = listOf("install.exe")) + + assertTrue(complete.isComplete) + assertEquals(1.0, complete.coverage, 0.0) + assertFalse(partial.isComplete) + assertEquals(1, partial.unresolvedCount) + } + + @Test + fun differentialPolicy_neverTradesCoverageForAReplacement() { + val baseline = plan(placed = listOf("Scripts/a.pex", "Plugin.esp")) + val worse = plan(placed = listOf("Scripts/a.pex"), unsupported = listOf("Plugin.esp")) + val better = plan(placed = listOf("Scripts/a.pex", "Plugin.esp", "Sounds/theme.xwm")) + + assertFalse(PlacementPlanRegressionPolicy.canReplace(baseline, worse)) + assertTrue(PlacementPlanRegressionPolicy.canReplace(baseline, better)) + } + + @Test + fun digest_isStableAcrossArchiveEnumerationOrder() { + val first = plan(placed = listOf("Scripts/a.pex", "Sounds/theme.xwm")) + val second = plan(placed = listOf("Sounds/theme.xwm", "Scripts/a.pex")) + + assertEquals(first.digest, second.digest) + } + + private fun plan( + placed: List, + ignored: List = emptyList(), + unsupported: List = emptyList(), + ): ModInstallPlan = ModInstallPlan( + files = buildList { + placed.forEach { source -> + add(file(source, PlannedFileStatus.PLACED, "Selected by fixture rule")) + } + ignored.forEach { source -> + add(file(source, PlannedFileStatus.INTENTIONALLY_IGNORED, "Known documentation")) + } + unsupported.forEach { source -> + add(file(source, PlannedFileStatus.UNSUPPORTED, "Requires review", PlacementRisk.REVIEW)) + } + }, + blockingIssues = unsupported.map { "Unresolved installable file: $it" }, + ) + + private fun file( + source: String, + status: PlannedFileStatus, + reason: String, + risk: PlacementRisk = PlacementRisk.SAFE, + ): PlannedModFile = PlannedModFile( + sourceRelativePath = source, + targetRoot = ModTargetRoot.GAME_DIR.name.takeIf { status == PlannedFileStatus.PLACED }, + targetRelativePath = "Data/$source".takeIf { status == PlannedFileStatus.PLACED }, + normalizedTargetKey = "game_dir:data/${source.lowercase()}".takeIf { status == PlannedFileStatus.PLACED }, + status = status, + origin = PlacementOrigin.GAME_RULE, + sizeBytes = 1L, + reason = reason, + risk = risk, + ) +} From dd4eeadbd0fceae0d6d371a547e6e57376992112 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 11:56:37 -0500 Subject: [PATCH 10/60] feat: add Windows-semantic target identity --- .../gamenative/mods/BethesdaPluginManager.kt | 8 +- .../gamenative/mods/ModConflictAnalyzer.kt | 14 +-- .../app/gamenative/mods/ModMaterializer.kt | 78 ++++++------ .../app/gamenative/mods/ModTargetResolver.kt | 21 +++- .../gamenative/mods/WindowsTargetNamespace.kt | 111 ++++++++++++++++++ .../mods/ModConflictAnalyzerTest.kt | 25 ++++ .../gamenative/mods/ModMaterializerTest.kt | 48 +++++++- .../gamenative/mods/ModTargetResolverTest.kt | 33 ++++++ 8 files changed, 286 insertions(+), 52 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt diff --git a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt index 4f67382b49..07dbdcd17a 100644 --- a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt +++ b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt @@ -185,7 +185,10 @@ object BethesdaPluginManager { val missingFiles = buildList { if (!targetPlugin.isFile) add(plugin.fileName) sourcePluginSidecars(sourcePlugin).forEach { sourceSidecar -> - val expectedTarget = File(targetPlugin.parentFile ?: return@forEach, sourceSidecar.name) + val expectedTarget = ModTargetResolver.resolveWithin( + targetPlugin.parentFile ?: return@forEach, + sourceSidecar.name, + ) ?: return@forEach if (!expectedTarget.isFile) add(sourceSidecar.name) } } @@ -300,7 +303,8 @@ object BethesdaPluginManager { .filter { it.isFile && it.extension.lowercase() in pluginExtensions } .mapNotNull { file -> val relative = file.canonicalFile.relativeToOrNull(sourceRoot)?.path ?: return@mapNotNull null - PlannedPluginFile(file, File(target, relative)) + val resolvedTarget = ModTargetResolver.resolveWithin(target, relative) ?: return@mapNotNull null + PlannedPluginFile(file, resolvedTarget) } .toList() } diff --git a/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt b/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt index b8dfa280fe..d61cf8a2f7 100644 --- a/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt +++ b/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt @@ -43,9 +43,9 @@ object ModConflictAnalyzer { } plannedFiles - .groupBy { it.target.safeCanonicalPath() } + .groupBy { WindowsPathIdentity.absoluteKey(it.target) } .filterValues { it.map { file -> file.installId }.distinct().size > 1 } - .map { (targetPath, files) -> + .map { (_, files) -> val sorted = files.sortedWith( compareByDescending { prioritiesByInstallId[it.installId] ?: 0 } .thenByDescending { installById[it.installId]?.updatedAt ?: 0L } @@ -53,8 +53,8 @@ object ModConflictAnalyzer { ) val winner = sorted.first() ModFileConflictReport( - targetPath = targetPath, - targetRelativePath = relativeTargetPath(targetPath, gameRootDir, winePrefix), + targetPath = winner.target.absolutePath, + targetRelativePath = relativeTargetPath(winner.target.absolutePath, gameRootDir, winePrefix), winnerInstallId = winner.installId, participants = sorted.map { file -> val install = installById[file.installId] @@ -87,7 +87,8 @@ object ModConflictAnalyzer { .filter { it.isFile } .mapNotNull { file -> val relative = file.canonicalFile.relativeToOrNull(sourceRoot)?.path ?: return@mapNotNull null - PlannedFile(installId, file, File(target, relative)) + val resolvedTarget = ModTargetResolver.resolveWithin(target, relative) ?: return@mapNotNull null + PlannedFile(installId, file, resolvedTarget) } .toList() } @@ -109,7 +110,4 @@ object ModConflictAnalyzer { val fileCanonical = canonicalFile fileCanonical == rootCanonical || fileCanonical.path.startsWith(rootCanonical.path + File.separator) }.getOrDefault(false) - - private fun File.safeCanonicalPath(): String = - runCatching { canonicalFile.absolutePath }.getOrDefault(absolutePath) } diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index cdff3548d4..c800793d09 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -31,6 +31,7 @@ data class ModPlannedEntry( val installId: String, val source: File, val target: File, + val normalizedTargetKey: String = WindowsPathIdentity.absoluteKey(target), ) object ModMaterializer { @@ -42,10 +43,10 @@ object ModMaterializer { manifests: List, ): List { if (conflicts.isEmpty() || manifests.isEmpty()) return conflicts - val manifestsByTarget = manifests.groupBy { File(it.targetPath).absolutePath } + val manifestsByTarget = manifests.groupBy { WindowsPathIdentity.absoluteKey(File(it.targetPath)) } return conflicts.filter { conflict -> val target = File(conflict.targetPath) - val matchingManifests = manifestsByTarget[target.absolutePath].orEmpty() + val matchingManifests = manifestsByTarget[WindowsPathIdentity.absoluteKey(target)].orEmpty() matchingManifests.none { manifest -> targetMatchesApprovedState(target, manifest) } } } @@ -234,7 +235,7 @@ object ModMaterializer { val skipped = mutableListOf() val handledTargets = mutableSetOf() manifests.sortedByDescending { it.targetPath.length }.forEach { manifest -> - if (!handledTargets.add(manifest.targetPath)) return@forEach + if (!handledTargets.add(WindowsPathIdentity.absoluteKey(File(manifest.targetPath)))) return@forEach val target = File(manifest.targetPath) if (manifest.backupPath.isBlank()) return@forEach val backup = File(manifest.backupPath) @@ -341,16 +342,22 @@ object ModMaterializer { val effectiveSource = stripPrefix(source, recipe.stripPrefixSegments) return when { - effectiveSource.isFile -> listOf(ModPlannedEntry(install.installId, effectiveSource, File(targetDir, effectiveSource.name))) + effectiveSource.isFile -> listOf(plannedEntry(install.installId, effectiveSource, targetDir, effectiveSource.name)) recipe.includeSourceDirectory && effectiveSource != extractedRoot -> - listOf(ModPlannedEntry(install.installId, effectiveSource, File(targetDir, effectiveSource.name))) + listOf(plannedEntry(install.installId, effectiveSource, targetDir, effectiveSource.name)) else -> effectiveSource.listFiles() ?.filter { !it.name.startsWith(".") } - ?.map { ModPlannedEntry(install.installId, it, File(targetDir, it.name)) } + ?.map { plannedEntry(install.installId, it, targetDir, it.name) } ?: emptyList() } } + private fun plannedEntry(installId: String, source: File, targetRoot: File, relative: String): ModPlannedEntry { + val target = ModTargetResolver.resolveWithin(targetRoot, relative) + ?: throw IOException("Target path is invalid or case-ambiguous: $relative") + return ModPlannedEntry(installId, source, target) + } + private fun resolveSource(extractedRoot: File, normalizedSource: String): File { if (normalizedSource.isBlank()) return extractedRoot if (normalizedSource.split('/').any { it == ".." }) { @@ -461,7 +468,7 @@ object ModMaterializer { source.walkTopDown() .filter { it.isFile } .forEach { sourceFile -> - val targetFile = File(target, sourceFile.relativeTo(source).path) + val targetFile = safeChildTarget(target, sourceFile.relativeTo(source).path) removeCopiedFileIfUnchanged(targetFile, sourceFile, skipped, reportChangedFiles, ignoredChangedTargets) } if (allowOwnedDirectoryDelete || removeLegacySentinel) { @@ -480,10 +487,14 @@ object ModMaterializer { ignoredChangedTargets: Set = emptySet(), ) { if (!target.exists() || !target.isFile || !source.isFile) return - if (target.absolutePath in ignoredChangedTargets) return + val targetKey = WindowsPathIdentity.absoluteKey(target) + val ignoredKeys = ignoredChangedTargets.asSequence() + .map { WindowsPathIdentity.absoluteKey(File(it)) } + .toSet() + if (targetKey in ignoredKeys) return if (sha256(target) == sha256(source)) { target.delete() - } else if (reportChangedFiles && target.absolutePath !in ignoredChangedTargets) { + } else if (reportChangedFiles && targetKey !in ignoredKeys) { skipped += target.absolutePath } } @@ -501,8 +512,19 @@ object ModMaterializer { private fun copyWithoutOverwrite(target: File, source: File, installId: String): Boolean { if (target.exists() || Files.isSymbolicLink(target.toPath())) return false target.parentFile?.mkdirs() - copyEntry(source, target, overwrite = false) - if (target.isDirectory) File(target, COPY_SENTINEL).writeText(installId) + if (source.isDirectory) { + target.mkdirs() + source.walkTopDown() + .filter { it.isFile } + .forEach { sourceFile -> + val targetFile = safeChildTarget(target, sourceFile.relativeTo(source).path) + ensureRealParentDirectories(targetFile, stopAt = target) + sourceFile.copyTo(targetFile, overwrite = false) + } + File(target, COPY_SENTINEL).writeText(installId) + } else { + source.copyTo(target, overwrite = false) + } return true } @@ -557,7 +579,8 @@ object ModMaterializer { allowOverwrite: Boolean, targetsWrittenThisApply: MutableSet, ): CopyBackupResult { - if (!allowOverwrite && source.isFile && targetNeedsOverwrite(target, source) && target.absolutePath !in targetsWrittenThisApply) { + val targetKey = WindowsPathIdentity.absoluteKey(target) + if (!allowOverwrite && source.isFile && targetNeedsOverwrite(target, source) && targetKey !in targetsWrittenThisApply) { throw IOException("Overwrite was not confirmed for ${target.absolutePath}") } if (!allowOverwrite && source.isDirectory && Files.isSymbolicLink(target.toPath())) { @@ -575,7 +598,8 @@ object ModMaterializer { .forEach { file -> val relative = file.relativeTo(source).path val targetFile = safeChildTarget(target, relative) - val sameApplyTarget = targetFile.absolutePath in targetsWrittenThisApply + val currentTargetKey = WindowsPathIdentity.absoluteKey(targetFile) + val sameApplyTarget = currentTargetKey in targetsWrittenThisApply if (!allowOverwrite && !sameApplyTarget && targetNeedsOverwrite(targetFile, file)) { throw IOException("Overwrite was not confirmed for ${targetFile.absolutePath}") } @@ -591,12 +615,12 @@ object ModMaterializer { deleteTargetSymlinkIfPresent(targetFile) ensureRealParentDirectories(targetFile, stopAt = target) file.copyTo(targetFile, overwrite = true) - targetsWrittenThisApply += targetFile.absolutePath + targetsWrittenThisApply += currentTargetKey created++ manifests.replaceLastForTarget(targetFile, install) } } else { - val sameApplyTarget = target.absolutePath in targetsWrittenThisApply + val sameApplyTarget = targetKey in targetsWrittenThisApply val backup = if (sameApplyTarget) BackupIfNeededResult() else backupIfNeeded(install, target, source, backupRoot) if (backup.manifest != null) { if (backup.backedUp) { @@ -611,7 +635,7 @@ object ModMaterializer { deleteTargetSymlinkIfPresent(target) ensureRealParentDirectories(target, stopAt = target.parentFile) source.copyTo(target, overwrite = true) - targetsWrittenThisApply += target.absolutePath + targetsWrittenThisApply += targetKey created++ manifests.replaceLastForTarget(target, install) } @@ -619,7 +643,8 @@ object ModMaterializer { } private fun MutableList.replaceLastForTarget(target: File, install: ModInstall) { - val index = indexOfLast { it.targetPath == target.absolutePath } + val targetKey = WindowsPathIdentity.absoluteKey(target) + val index = indexOfLast { WindowsPathIdentity.absoluteKey(File(it.targetPath)) == targetKey } if (index < 0 || !target.isFile) return val current = this[index] this[index] = current.copy( @@ -768,23 +793,8 @@ object ModMaterializer { } private fun safeChildTarget(root: File, relative: String): File { - val rootCanonical = root.canonicalFile - val rootPath = rootCanonical.toPath().toAbsolutePath().normalize() - val targetPath = rootPath.resolve(relative).normalize() - if (targetPath != rootPath && !targetPath.startsWith(rootPath)) { - throw IOException("Target path escapes destination directory: $relative") - } - return targetPath.toFile() - } - - private fun copyEntry(source: File, target: File, overwrite: Boolean) { - if (source.isDirectory) { - if (!source.copyRecursively(target, overwrite = overwrite)) { - throw IOException("Failed to copy ${source.absolutePath}") - } - } else { - source.copyTo(target, overwrite = overwrite) - } + return ModTargetResolver.resolveWithin(root, relative) + ?: throw IOException("Target path escapes or is ambiguous in destination directory: $relative") } private fun sha256(file: File): String { diff --git a/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt b/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt index f9cf58b5c5..126562ee68 100644 --- a/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt +++ b/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt @@ -13,6 +13,13 @@ object ModTargetResolver { fun normalizeRelativePath(path: String): String = path.trim().replace('\\', '/').trim('/') + fun normalizedTargetKey(targetRoot: String, targetRelativePath: String): String? = + if (targetRoot == ModTargetRoot.CUSTOM_ABSOLUTE.name) { + WindowsPathIdentity.absoluteKey(File(targetRelativePath.trim().replace('\\', '/'))) + } else { + WindowsPathIdentity.targetKey(targetRoot, targetRelativePath) + } + fun roots(gameRootDir: File?, winePrefix: String): List { val result = mutableListOf() if (gameRootDir?.isDirectory == true) { @@ -50,13 +57,17 @@ object ModTargetResolver { } } val root = roots(gameRootDir, winePrefix).firstOrNull { it.type == rootType }?.dir ?: return null + if (WindowsPathIdentity.relativeSegments(targetRelativePath) == null) return null val cleanRelative = normalizeRelativePath(targetRelativePath) val rootCanonical = root.safeCanonicalFile() ?: return null - val target = if (cleanRelative.isBlank()) { - rootCanonical - } else { - File(rootCanonical, cleanRelative).safeCanonicalFile() ?: return null - } + val target = WindowsTargetNamespace(rootCanonical).resolve(cleanRelative).takeIf { it.isValid }?.file ?: return null + return target.takeIf { it.isInsideOrEqual(rootCanonical) } + } + + fun resolveWithin(root: File, relativePath: String): File? { + val rootCanonical = root.safeCanonicalFile() ?: return null + val resolution = WindowsTargetNamespace(rootCanonical).resolve(relativePath) + val target = resolution.takeIf { it.isValid }?.file ?: return null return target.takeIf { it.isInsideOrEqual(rootCanonical) } } diff --git a/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt new file mode 100644 index 0000000000..27f53ab800 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt @@ -0,0 +1,111 @@ +package app.gamenative.mods + +import java.io.File +import java.util.Locale + +data class WindowsTargetResolution( + val file: File?, + val normalizedRelativeKey: String?, + val caseMerges: List = emptyList(), + val ambiguousSegments: List = emptyList(), +) { + val isValid: Boolean + get() = file != null && normalizedRelativeKey != null && ambiguousSegments.isEmpty() +} + +class WindowsTargetNamespace( + root: File, +) { + private val root = root.canonicalFile + private val listingCache = mutableMapOf>>() + + fun resolve(relativePath: String): WindowsTargetResolution { + val segments = WindowsPathIdentity.relativeSegments(relativePath) + ?: return WindowsTargetResolution(null, null) + var current = root + val caseMerges = mutableListOf() + val ambiguities = mutableListOf() + + segments.forEachIndexed { index, requested -> + val matches = childrenByWindowsName(current)[WindowsPathIdentity.segmentKey(requested)].orEmpty() + when { + matches.size > 1 -> { + ambiguities += segments.take(index + 1).joinToString("/") + return@forEachIndexed + } + matches.size == 1 -> { + val existing = matches.single() + if (existing.name != requested) { + caseMerges += "${segments.take(index).joinToString("/")}/$requested -> ${existing.name}" + .trimStart('/') + } + current = existing + } + else -> current = File(current, requested) + } + } + + return WindowsTargetResolution( + file = current.takeIf { ambiguities.isEmpty() }, + normalizedRelativeKey = segments.joinToString("/") { WindowsPathIdentity.segmentKey(it) }, + caseMerges = caseMerges, + ambiguousSegments = ambiguities, + ) + } + + fun invalidate() { + listingCache.clear() + } + + private fun childrenByWindowsName(dir: File): Map> { + val key = runCatching { dir.canonicalPath }.getOrDefault(dir.absolutePath) + return listingCache.getOrPut(key) { + if (!dir.isDirectory) { + emptyMap() + } else { + dir.listFiles().orEmpty().groupBy { WindowsPathIdentity.segmentKey(it.name) } + } + } + } +} + +object WindowsPathIdentity { + private val reservedNames = buildSet { + addAll(listOf("con", "prn", "aux", "nul")) + (1..9).forEach { index -> + add("com$index") + add("lpt$index") + } + } + + fun normalizedRelativeKey(path: String): String? = + relativeSegments(path)?.joinToString("/", transform = ::segmentKey) + + fun targetKey(targetRoot: String, relativePath: String): String? = + normalizedRelativeKey(relativePath)?.let { "$targetRoot:${it}" } + + fun absoluteKey(file: File): String = + file.absoluteFile.normalize().path + .replace(File.separatorChar, '/') + .split('/') + .joinToString("/", transform = ::segmentKey) + + internal fun segmentKey(segment: String): String = + segment.trimEnd(' ', '.').lowercase(Locale.ROOT) + + internal fun relativeSegments(path: String): List? { + val normalized = path.trim().replace('\\', '/') + if (normalized.startsWith('/') || normalized.startsWith("//")) return null + if (Regex("^[A-Za-z]:").containsMatchIn(normalized)) return null + val segments = normalized.split('/').filter(String::isNotBlank) + if (segments.any { it == "." || it == ".." }) return null + if (segments.any(::isUnsafeWindowsSegment)) return null + return segments + } + + private fun isUnsafeWindowsSegment(segment: String): Boolean { + val key = segmentKey(segment) + if (key.isBlank() || key.substringBefore('.') in reservedNames) return true + return segment.any { it.code < 32 || it in setOf('<', '>', ':', '"', '|', '?', '*') } + } +} diff --git a/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt b/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt index 953655b5a4..30e6ef85c7 100644 --- a/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt @@ -60,6 +60,31 @@ class ModConflictAnalyzerTest { assertEquals(true, report.participants.first().wins) } + @Test + fun analyze_treatsCaseVariantWindowsTargetsAsOneConflict() = runBlocking { + val first = install("first", "First", "first") + val second = install("second", "Second", "second") + File(first.extractedPath, "Data/Scripts/A.pex").apply { + parentFile?.mkdirs() + writeText("first") + } + File(second.extractedPath, "Data/scripts/a.pex").apply { + parentFile?.mkdirs() + writeText("second") + } + + val reports = ModConflictAnalyzer.analyze( + installs = listOf(first, second), + recipesByInstallId = mapOf(first.installId to listOf(recipe(first.installId)), second.installId to listOf(recipe(second.installId))), + prioritiesByInstallId = emptyMap(), + gameRootDir = gameDir, + winePrefix = "", + ) + + assertEquals(1, reports.size) + assertEquals(setOf("first", "second"), reports.single().participants.map { it.installId }.toSet()) + } + private fun install(id: String, name: String, folder: String): ModInstall { val extracted = File(tempDir, folder).apply { mkdirs() } return ModInstall( diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index 30081fbf69..fe41432cff 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -100,6 +100,44 @@ class ModMaterializerTest { assertEquals(1, result.skipped) } + @Test + fun overwriteCopy_mergesIncomingDirectoryIntoExistingWindowsCasing() = runBlocking { + File(extracted, "Data/scripts/example.pex").apply { + parentFile?.mkdirs() + writeText("compiled") + } + val existingScripts = File(gameDir, "Data/Scripts").apply { mkdirs() } + val install = install() + val placement = recipe( + sourceSubpath = "Data", + targetRelativePath = "Data", + mode = ModPlacementMode.OVERWRITE_COPY, + ) + + val result = ModMaterializer.apply( + install = install, + recipes = listOf(placement), + gameRootDir = gameDir, + winePrefix = "", + backupRoot = backupDir, + allowOverwrite = true, + ) + + assertTrue(result.errors.isEmpty()) + assertEquals("compiled", File(existingScripts, "example.pex").readText()) + assertEquals( + listOf("Scripts"), + File(gameDir, "Data").listFiles().orEmpty() + .filter { it.name.equals("scripts", ignoreCase = true) } + .map { it.name }, + ) + + assertTrue( + ModMaterializer.removeAppliedFiles(install, listOf(placement), gameDir, "").isEmpty(), + ) + assertFalse(File(existingScripts, "example.pex").exists()) + } + @Test fun scanConflicts_overwriteCopyIgnoresSameExistingFileAndNewFilesInExistingDirectory() = runBlocking { File(extracted, "Data/same.ini").apply { @@ -721,11 +759,15 @@ class ModMaterializerTest { extractedPath = extracted.absolutePath, ) - private fun recipe(mode: ModPlacementMode) = ModPlacementRecipe( + private fun recipe( + mode: ModPlacementMode, + sourceSubpath: String = "", + targetRelativePath: String = "", + ) = ModPlacementRecipe( installId = "install", - sourceSubpath = "", + sourceSubpath = sourceSubpath, targetRoot = ModTargetRoot.GAME_DIR.name, - targetRelativePath = "", + targetRelativePath = targetRelativePath, mode = mode.name, ) } diff --git a/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt b/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt index 199d52280d..2dc78ea28e 100644 --- a/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt @@ -5,6 +5,7 @@ import org.junit.After import org.junit.Assert.assertEquals import org.junit.Assert.assertNull import org.junit.Assert.assertTrue +import org.junit.Assume.assumeTrue import org.junit.Before import org.junit.Test import java.io.File @@ -87,6 +88,38 @@ class ModTargetResolverTest { assertEquals(File(gameDir, "Data/Textures").canonicalFile, resolved) } + @Test + fun resolve_reusesExistingDirectoryCasing() { + val scripts = File(gameDir, "Data/Scripts").apply { mkdirs() } + + val resolved = ModTargetResolver.resolve( + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "data/scripts", + gameRootDir = gameDir, + winePrefix = winePrefix.absolutePath, + ) + + assertEquals(scripts.canonicalFile, resolved) + } + + @Test + fun resolve_blocksAmbiguousExistingCaseVariants() { + File(gameDir, "Data/Scripts").mkdirs() + File(gameDir, "Data/scripts").mkdirs() + assumeTrue( + File(gameDir, "Data").listFiles().orEmpty().count { it.name.equals("scripts", ignoreCase = true) } == 2, + ) + + val resolved = ModTargetResolver.resolve( + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "Data/SCRIPTS", + gameRootDir = gameDir, + winePrefix = winePrefix.absolutePath, + ) + + assertNull(resolved) + } + @Test fun resolve_normalizesWindowsSeparatorsInCustomAbsolutePath() { val inside = File(gameDir, "Data/Textures").apply { mkdirs() } From 4ee50259d17a20323a1398b3ef0bf8ae0911d2cb Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 12:00:27 -0500 Subject: [PATCH 11/60] feat: build complete automatic install plans --- .../mods/AutomaticPlacementPlanner.kt | 246 ++++++++++++++++++ .../app/gamenative/mods/ModArchiveIndex.kt | 155 +++++++++++ .../app/gamenative/mods/ModPlacementPreset.kt | 1 + .../dialog/NexusModsDialogHelpers.kt | 14 +- .../dialog/NexusModsPlacementSections.kt | 26 +- .../mods/AutomaticPlacementPlannerTest.kt | 64 +++++ 6 files changed, 502 insertions(+), 4 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt create mode 100644 app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt create mode 100644 app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt new file mode 100644 index 0000000000..d9243652e5 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -0,0 +1,246 @@ +package app.gamenative.mods + +import app.gamenative.data.ModPlacementMode +import app.gamenative.data.ModTargetRoot +import java.util.Locale + +data class AutomaticPlacementCandidate( + val id: String, + val label: String, + val description: String, + val drafts: List, + val plan: ModInstallPlan, + val score: Int, + val evidence: List, +) + +data class AutomaticPlacementResult( + val candidates: List, + val recommended: AutomaticPlacementCandidate?, +) + +object AutomaticPlacementPlanner { + private val bethesdaContentDirectories = setOf( + "meshes", + "textures", + "scripts", + "interface", + "sound", + "sounds", + "strings", + "skse", + "f4se", + "sfse", + "seq", + "video", + "music", + "lodsettings", + "calientetools", + "nemesis_engine", + ) + private val bethesdaDataExtensions = setOf("esp", "esm", "esl", "bsa", "ba2") + + fun plan(gameName: String, entries: List): AutomaticPlacementResult { + val index = ModArchiveIndex.build(entries) + val legacy = ModPlacementPresetDetector.detect(gameName, entries).map { preset -> + candidateFromDrafts( + id = "legacy:${preset.id}", + label = preset.label, + description = preset.description, + drafts = preset.drafts, + index = index, + origin = PlacementOrigin.LEGACY_PRESET, + evidence = listOf("Existing placement preset ${preset.id}"), + ) + } + val generated = buildList { + bethesdaCandidate(gameName, index)?.let(::add) + } + val ranked = (generated + legacy) + .distinctBy { candidate -> candidate.plan.digest } + .sortedWith( + compareByDescending { it.plan.isComplete } + .thenByDescending { it.score } + .thenBy { it.id }, + ) + val baseline = legacy.firstOrNull() + val bestGenerated = generated.maxWithOrNull(compareBy { it.score }.thenBy { it.id }) + val recommended = when { + bestGenerated == null -> baseline + baseline == null -> bestGenerated + PlacementPlanRegressionPolicy.canReplace(baseline.plan, bestGenerated.plan) && + preservesExistingDestinations(baseline.plan, bestGenerated.plan) -> bestGenerated + else -> baseline + } + return AutomaticPlacementResult(ranked, recommended) + } + + fun inferIncludeSourceDirectory( + selectedPaths: Collection, + entries: List, + targetRelativePath: String, + ): Boolean { + val index = ModArchiveIndex.build(entries) + val selectedDirectories = selectedPaths.filter(index::isDirectory) + if (selectedDirectories.isEmpty()) return false + val targetName = normalizeArchiveDisplayPath(targetRelativePath).substringAfterLast('/') + return selectedDirectories.any { source -> + !source.substringAfterLast('/').equals(targetName, ignoreCase = true) + } + } + + private fun bethesdaCandidate(gameName: String, index: ModArchiveIndex): AutomaticPlacementCandidate? { + val game = BethesdaPluginManager.detectGame(gameName) ?: return null + if (index.hasFomod) return null + val dataNodes = index.nodes.filter { node -> node.displayPath.substringAfterLast('/').equals("Data", ignoreCase = true) } + val bestData = dataNodes.maxWithOrNull( + compareBy { it.descendantFileCount } + .thenByDescending { it.displayPath.count { char -> char == '/' } } + .thenBy { it.normalizedKey }, + ) + val drafts = if (bestData != null) { + listOf( + ModPlacementPresetDraft( + sourceSubpath = bestData.displayPath, + targetRelativePath = game.dataDirName, + mode = ModPlacementMode.OVERWRITE_COPY.name, + includeSourceDirectory = false, + ), + ) + } else { + val sources = index.files.mapNotNull(::bethesdaSourceForFile).distinctBy { it.lowercase(Locale.ROOT) } + if (sources.isEmpty()) return null + listOf( + ModPlacementPresetDraft( + sourceSubpath = ModPlacementSources.encode(sources), + targetRelativePath = game.dataDirName, + mode = ModPlacementMode.OVERWRITE_COPY.name, + includeSourceDirectory = true, + ), + ) + } + val evidence = buildList { + if (bestData != null) add("Found ${bestData.displayPath} as a Data container") + val anchors = index.nodes.flatMapTo(mutableSetOf()) { it.semanticAnchors }.sorted() + if (anchors.isNotEmpty()) add("Recognized Data content: ${anchors.joinToString()}") + val loose = index.files.count { it.displayPath.substringAfterLast('.').lowercase(Locale.ROOT) in bethesdaDataExtensions } + if (loose > 0) add("Found $loose Bethesda plugin/archive file(s)") + } + return candidateFromDrafts( + id = "rules:bethesda-data-v1", + label = "Complete Bethesda Data plan", + description = "Maps recognized Data content and loose plugins while preserving content folders.", + drafts = drafts, + index = index, + origin = PlacementOrigin.GAME_RULE, + evidence = evidence, + ) + } + + private fun bethesdaSourceForFile(file: IndexedArchiveFile): String? { + if (file.role != ArchiveContentRole.INSTALLABLE) return null + val segments = file.displayPath.split('/') + val anchorIndex = segments.indexOfFirst { it.lowercase(Locale.ROOT) in bethesdaContentDirectories } + if (anchorIndex >= 0) return segments.take(anchorIndex + 1).joinToString("/") + if (file.displayPath.substringAfterLast('.', "").lowercase(Locale.ROOT) in bethesdaDataExtensions) { + return file.displayPath + } + return null + } + + private fun candidateFromDrafts( + id: String, + label: String, + description: String, + drafts: List, + index: ModArchiveIndex, + origin: PlacementOrigin, + evidence: List, + ): AutomaticPlacementCandidate { + val placedBySource = linkedMapOf() + drafts.forEach { draft -> + ModPlacementSources.decode(draft.sourceSubpath).ifEmpty { listOf("") }.forEach { source -> + val sourceIsDirectory = source.isBlank() || index.isDirectory(source) + index.filesUnder(source).forEach { file -> + val relative = when { + source.isBlank() -> file.displayPath + !sourceIsDirectory -> file.displayPath.substringAfterLast('/') + else -> file.displayPath.removePrefixCaseInsensitive("$source/") + } + val targetPath = listOfNotNull( + draft.targetRelativePath.takeIf(String::isNotBlank), + source.substringAfterLast('/').takeIf { sourceIsDirectory && source.isNotBlank() && draft.includeSourceDirectory }, + relative.takeIf(String::isNotBlank), + ).joinToString("/") + val targetKey = WindowsPathIdentity.targetKey(ModTargetRoot.GAME_DIR.name, targetPath) + placedBySource[file.normalizedKey] = PlannedModFile( + sourceRelativePath = file.displayPath, + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = targetPath, + normalizedTargetKey = targetKey, + status = if (targetKey == null) PlannedFileStatus.UNSUPPORTED else PlannedFileStatus.PLACED, + origin = origin, + sizeBytes = file.sizeBytes, + reason = evidence.firstOrNull() ?: description, + evidence = evidence, + risk = if (file.role == ArchiveContentRole.RISKY_ROOT) PlacementRisk.UNSAFE else PlacementRisk.SAFE, + ) + } + } + } + val classified = index.files.map { file -> + placedBySource[file.normalizedKey] ?: when (file.role) { + ArchiveContentRole.DOCUMENTATION, + ArchiveContentRole.METADATA, + ArchiveContentRole.INSTALLER_SUPPORT -> PlannedModFile( + sourceRelativePath = file.displayPath, + status = PlannedFileStatus.INTENTIONALLY_IGNORED, + origin = origin, + sizeBytes = file.sizeBytes, + reason = "Known non-installable ${file.role.name.lowercase(Locale.ROOT).replace('_', ' ')}", + ) + else -> PlannedModFile( + sourceRelativePath = file.displayPath, + status = PlannedFileStatus.UNSUPPORTED, + origin = origin, + sizeBytes = file.sizeBytes, + reason = "No supported destination was proven", + risk = if (file.role == ArchiveContentRole.RISKY_ROOT) PlacementRisk.UNSAFE else PlacementRisk.REVIEW, + ) + } + }.toMutableList() + val duplicateTargets = classified.filter { it.status == PlannedFileStatus.PLACED } + .groupBy { it.normalizedTargetKey } + .filterKeys { it != null } + .filterValues { files -> files.map { it.sourceRelativePath.lowercase(Locale.ROOT) }.distinct().size > 1 } + if (duplicateTargets.isNotEmpty()) { + duplicateTargets.values.flatten().forEach { duplicate -> + val indexOfFile = classified.indexOf(duplicate) + classified[indexOfFile] = duplicate.copy( + status = PlannedFileStatus.CONFLICTED, + reason = "Multiple archive files target one Windows path", + risk = PlacementRisk.REVIEW, + ) + } + } + val blockers = buildList { + if (index.caseCollisions.isNotEmpty()) add("Archive contains case-colliding file paths") + if (classified.any { it.status == PlannedFileStatus.UNSUPPORTED }) add("Some installable files have no proven destination") + if (duplicateTargets.isNotEmpty()) add("Multiple files target the same Windows path") + if (classified.any { it.risk == PlacementRisk.UNSAFE }) add("Risky game-root installer content requires review") + } + val plan = ModInstallPlan(classified, blockingIssues = blockers) + val score = (plan.coverage * 1_000).toInt() + evidence.size * 25 - blockers.size * 250 + return AutomaticPlacementCandidate(id, label, description, drafts, plan, score, evidence) + } + + private fun preservesExistingDestinations(baseline: ModInstallPlan, candidate: ModInstallPlan): Boolean { + val candidateTargets = candidate.files.associate { it.sourceRelativePath.lowercase(Locale.ROOT) to it.normalizedTargetKey } + return baseline.files.filter { it.status == PlannedFileStatus.PLACED }.all { old -> + candidateTargets[old.sourceRelativePath.lowercase(Locale.ROOT)] == old.normalizedTargetKey + } + } + + private fun String.removePrefixCaseInsensitive(prefix: String): String = + if (startsWith(prefix, ignoreCase = true)) substring(prefix.length) else this +} diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt new file mode 100644 index 0000000000..92a31dfd9a --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -0,0 +1,155 @@ +package app.gamenative.mods + +import java.util.Locale + +enum class ArchiveContentRole { + INSTALLABLE, + DOCUMENTATION, + METADATA, + INSTALLER_SUPPORT, + RISKY_ROOT, + INVALID, +} + +data class IndexedArchiveFile( + val displayPath: String, + val normalizedKey: String, + val sizeBytes: Long, + val role: ArchiveContentRole, +) + +data class ArchiveTreeNode( + val displayPath: String, + val normalizedKey: String, + val descendantFileCount: Int, + val descendantBytes: Long, + val semanticAnchors: Set, + val optionStyleWrapper: Boolean, +) + +data class ModArchiveIndex( + val files: List, + val nodes: List, + val caseCollisions: Map>, +) { + val hasFomod: Boolean + get() = files.any { it.normalizedKey.endsWith("fomod/moduleconfig.xml") } + + fun filesUnder(sourcePath: String): List { + val key = normalizedArchiveKey(sourcePath) ?: return emptyList() + if (key.isBlank()) return files + return files.filter { it.normalizedKey == key || it.normalizedKey.startsWith("$key/") } + } + + fun isDirectory(sourcePath: String): Boolean { + val key = normalizedArchiveKey(sourcePath) ?: return false + return nodes.any { it.normalizedKey == key } || files.any { it.normalizedKey.startsWith("$key/") } + } + + companion object { + private val semanticAnchors = setOf( + "meshes", + "textures", + "scripts", + "interface", + "sound", + "sounds", + "strings", + "skse", + "f4se", + "sfse", + "seq", + "video", + "music", + "lodsettings", + ) + + fun build(entries: List): ModArchiveIndex { + val indexedFiles = entries.asSequence() + .filterNot { it.directory } + .map { entry -> + val display = normalizeArchiveDisplayPath(entry.path) + val key = normalizedArchiveKey(entry.path) + IndexedArchiveFile( + displayPath = display.ifBlank { entry.path }, + normalizedKey = key.orEmpty(), + sizeBytes = entry.sizeBytes.coerceAtLeast(0L), + role = if (key == null) ArchiveContentRole.INVALID else classify(display), + ) + } + .sortedWith(compareBy { it.normalizedKey }.thenBy { it.displayPath }) + .toList() + val directoryPaths = buildSet { + entries.filter { it.directory }.forEach { entry -> + normalizeArchiveDisplayPath(entry.path).takeIf(String::isNotBlank)?.let(::add) + } + indexedFiles.forEach { file -> + val segments = file.displayPath.split('/') + (1 until segments.size).forEach { count -> add(segments.take(count).joinToString("/")) } + } + } + val nodes = directoryPaths.mapNotNull { path -> + val key = normalizedArchiveKey(path) ?: return@mapNotNull null + val descendants = indexedFiles.filter { it.normalizedKey.startsWith("$key/") } + ArchiveTreeNode( + displayPath = path, + normalizedKey = key, + descendantFileCount = descendants.size, + descendantBytes = descendants.sumOf { it.sizeBytes }, + semanticAnchors = descendants.flatMapTo(mutableSetOf()) { descendant -> + descendant.normalizedKey.split('/').filter { it in semanticAnchors } + }, + optionStyleWrapper = looksLikeOptionWrapper(path.substringAfterLast('/')), + ) + }.sortedBy { it.normalizedKey } + return ModArchiveIndex( + files = indexedFiles, + nodes = nodes, + caseCollisions = indexedFiles.groupBy { it.normalizedKey } + .filterValues { variants -> variants.map { it.displayPath }.distinct().size > 1 } + .mapValues { (_, variants) -> variants.map { it.displayPath }.distinct().sorted() }, + ) + } + + private fun classify(path: String): ArchiveContentRole { + val normalized = path.lowercase(Locale.ROOT) + val name = normalized.substringAfterLast('/') + if (normalized.startsWith("__macosx/") || name in setOf(".ds_store", "thumbs.db", "desktop.ini")) { + return ArchiveContentRole.METADATA + } + if (normalized.contains("/fomod/") || normalized.startsWith("fomod/")) { + return ArchiveContentRole.INSTALLER_SUPPORT + } + if ( + name.startsWith("readme") || + name.startsWith("changelog") || + name.startsWith("license") || + name.endsWith(".md") || + name.endsWith(".pdf") + ) { + return ArchiveContentRole.DOCUMENTATION + } + if (!normalized.contains('/') && listOf(".exe", ".bat", ".cmd", ".ps1", ".msi").any(name::endsWith)) { + return ArchiveContentRole.RISKY_ROOT + } + return ArchiveContentRole.INSTALLABLE + } + + private fun looksLikeOptionWrapper(name: String): Boolean { + val normalized = name.lowercase(Locale.ROOT) + return Regex("^\\d{1,2}[ _.-]").containsMatchIn(normalized) || + listOf("optional", "option", "variant", "choose", "pick one").any(normalized::contains) + } + } +} + +internal fun normalizeArchiveDisplayPath(path: String): String = + path.trim().replace('\\', '/').split('/').filter { it.isNotBlank() && it != "." }.joinToString("/") + +internal fun normalizedArchiveKey(path: String): String? { + val normalized = path.trim().replace('\\', '/') + if (normalized.startsWith('/') || Regex("^[A-Za-z]:").containsMatchIn(normalized)) return null + val segments = normalized.split('/').filter(String::isNotBlank) + if (segments.any { it == "." || it == ".." }) return null + return segments.joinToString("/") { it.lowercase(Locale.ROOT) } +} diff --git a/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt b/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt index 13f7553853..eaf8d2fa1b 100644 --- a/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt +++ b/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt @@ -24,6 +24,7 @@ object ModPlacementPresetDetector { "scripts", "interface", "sound", + "sounds", "seq", "skse", "f4se", diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt index a785ba4b4e..0047e2a16c 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt @@ -19,6 +19,7 @@ import app.gamenative.data.ModProfile import app.gamenative.data.ModTargetRoot import app.gamenative.mods.BethesdaPluginManager import app.gamenative.mods.BethesdaPluginDependencyIssue +import app.gamenative.mods.AutomaticPlacementPlanner import app.gamenative.mods.ModArchiveEntry import app.gamenative.mods.ModDownloadInfo import app.gamenative.mods.ModImportProgress @@ -218,8 +219,17 @@ internal fun automaticDraftsFor( entries: List, fallback: RecipeDraft, ): List { - val preset = placementPresetOptions(gameName, entries, fallback).firstOrNull() - if (preset != null) return preset.drafts + val recommendation = AutomaticPlacementPlanner.plan(gameName, entries).recommended + if (recommendation != null) { + return recommendation.drafts.map { draft -> + fallback.copy( + sourceSubpath = draft.sourceSubpath, + targetRelativePath = draft.targetRelativePath, + mode = draft.mode, + includeSourceDirectory = draft.includeSourceDirectory, + ) + } + } val bethesdaGame = BethesdaPluginManager.detectGame(gameName) if (bethesdaGame != null) { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index d25f7bba27..058cfd0b73 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -68,6 +68,7 @@ import app.gamenative.data.ModInstall import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementMode import app.gamenative.data.ModTargetRoot +import app.gamenative.mods.AutomaticPlacementPlanner import app.gamenative.mods.FomodInstaller import app.gamenative.mods.ModArchiveEntry import app.gamenative.mods.ModPlacementPreset @@ -553,7 +554,19 @@ private fun PlacementDraftEditor( if (showManualPaths) { NoExtractOutlinedTextField( value = sourceManualText(draft.sourceSubpath), - onValueChange = { onUpdate(draft.copy(sourceSubpath = ModPlacementSources.encode(it.lines()))) }, + onValueChange = { value -> + val sources = value.lines().filter(String::isNotBlank) + onUpdate( + draft.copy( + sourceSubpath = ModPlacementSources.encode(sources), + includeSourceDirectory = AutomaticPlacementPlanner.inferIncludeSourceDirectory( + sources, + entries, + draft.targetRelativePath, + ), + ), + ) + }, modifier = Modifier.fillMaxWidth(), label = { Text(stringResource(R.string.nexus_source_folders_files_label)) }, placeholder = { Text(stringResource(R.string.nexus_source_paths_placeholder)) }, @@ -589,7 +602,16 @@ private fun PlacementDraftEditor( .filter { it.isNotBlank() } .toSet(), onSelectMultiple = { paths -> - onUpdate(draft.copy(sourceSubpath = ModPlacementSources.encode(paths))) + onUpdate( + draft.copy( + sourceSubpath = ModPlacementSources.encode(paths), + includeSourceDirectory = AutomaticPlacementPlanner.inferIncludeSourceDirectory( + paths, + entries, + draft.targetRelativePath, + ), + ), + ) showSourcePicker = false }, onDismiss = { showSourcePicker = false }, diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt new file mode 100644 index 0000000000..e142b712d9 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -0,0 +1,64 @@ +package app.gamenative.mods + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class AutomaticPlacementPlannerTest { + @Test + fun bethesdaPlan_placesMixedLooseContentWithoutFlatteningDirectories() { + val entries = archive("Sounds/theme.xwm", "Scripts/menu.pex", "Example.esp", "readme.txt") + + val candidate = AutomaticPlacementPlanner.plan("Skyrim Special Edition", entries).recommended!! + + assertTrue(candidate.plan.isComplete) + assertEquals( + setOf("Data/Sounds/theme.xwm", "Data/Scripts/menu.pex", "Data/Example.esp"), + candidate.plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet(), + ) + assertEquals(PlannedFileStatus.INTENTIONALLY_IGNORED, candidate.plan.files.single { it.sourceRelativePath == "readme.txt" }.status) + } + + @Test + fun bethesdaPlan_stripsOneWrapperAndDataContainer() { + val candidate = AutomaticPlacementPlanner.plan( + "Fallout 4", + archive("Cool Mod/Data/meshes/rifle.nif", "Cool Mod/Data/textures/rifle.dds"), + ).recommended!! + + assertEquals( + setOf("Data/meshes/rifle.nif", "Data/textures/rifle.dds"), + candidate.plan.files.mapNotNull { it.targetRelativePath }.toSet(), + ) + assertTrue(candidate.plan.isComplete) + } + + @Test + fun automaticPlan_blocksUnexplainedInstallableFiles() { + val candidate = AutomaticPlacementPlanner.plan( + "Skyrim Special Edition", + archive("Sounds/theme.xwm", "Mystery/config.bin"), + ).recommended!! + + assertFalse(candidate.plan.isComplete) + assertEquals(PlannedFileStatus.UNSUPPORTED, candidate.plan.files.single { it.sourceRelativePath == "Mystery/config.bin" }.status) + assertTrue(candidate.plan.blockingIssues.isNotEmpty()) + } + + @Test + fun planningIsStableAcrossArchiveOrderAndManualFolderInferencePreservesContentFolder() { + val first = archive("Sounds/theme.xwm", "Scripts/menu.pex", "Example.esp") + val second = first.reversed() + + assertEquals( + AutomaticPlacementPlanner.plan("Skyrim Special Edition", first).recommended!!.plan.digest, + AutomaticPlacementPlanner.plan("Skyrim Special Edition", second).recommended!!.plan.digest, + ) + assertTrue(AutomaticPlacementPlanner.inferIncludeSourceDirectory(listOf("Sounds"), first, "Data")) + assertFalse(AutomaticPlacementPlanner.inferIncludeSourceDirectory(listOf("Data"), archive("Data/file.txt"), "Data")) + } + + private fun archive(vararg paths: String): List = + paths.map { ModArchiveEntry(it, directory = false, sizeBytes = 1L) } +} From 04d91aa81c862f742aacd0994ad1ed6af1340602 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 12:06:29 -0500 Subject: [PATCH 12/60] feat: make FOMOD output complete and deterministic --- .../app.gamenative.db.PluviaDatabase/26.json | 1880 +++++++++++++++++ .../java/app/gamenative/data/ModInstall.kt | 3 + .../java/app/gamenative/db/PluviaDatabase.kt | 2 +- .../gamenative/db/migration/RoomMigration.kt | 12 + .../java/app/gamenative/di/DatabaseModule.kt | 4 +- .../gamenative/mods/FomodInstallPlanner.kt | 183 ++ .../app/gamenative/mods/FomodInstaller.kt | 31 +- .../app/gamenative/mods/ModMaterializer.kt | 9 +- .../app/gamenative/mods/NexusModManager.kt | 3 + .../ui/component/dialog/NexusModsDialog.kt | 1 + .../dialog/NexusModsDialogHelpers.kt | 2 + .../dialog/NexusModsFomodSections.kt | 9 +- .../app/gamenative/mods/FomodInstallerTest.kt | 105 +- 13 files changed, 2231 insertions(+), 13 deletions(-) create mode 100644 app/schemas/app.gamenative.db.PluviaDatabase/26.json create mode 100644 app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt diff --git a/app/schemas/app.gamenative.db.PluviaDatabase/26.json b/app/schemas/app.gamenative.db.PluviaDatabase/26.json new file mode 100644 index 0000000000..194316bef6 --- /dev/null +++ b/app/schemas/app.gamenative.db.PluviaDatabase/26.json @@ -0,0 +1,1880 @@ +{ + "formatVersion": 1, + "database": { + "version": 26, + "identityHash": "7e163d4af9b2107253274fe6d3f84665", + "entities": [ + { + "tableName": "app_info", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `is_downloaded` INTEGER NOT NULL, `downloaded_depots` TEXT NOT NULL, `dlc_depots` TEXT NOT NULL, `branch` TEXT NOT NULL DEFAULT 'public', `recovered_install_size_bytes` INTEGER NOT NULL DEFAULT 0, `custom_install_path` TEXT NOT NULL DEFAULT '', PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "isDownloaded", + "columnName": "is_downloaded", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "downloadedDepots", + "columnName": "downloaded_depots", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "dlcDepots", + "columnName": "dlc_depots", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "branch", + "columnName": "branch", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "'public'" + }, + { + "fieldPath": "recoveredInstallSizeBytes", + "columnName": "recovered_install_size_bytes", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "customInstallPath", + "columnName": "custom_install_path", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + } + }, + { + "tableName": "cached_license", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `license_json` TEXT NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "licenseJson", + "columnName": "license_json", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + } + }, + { + "tableName": "app_change_numbers", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appId` INTEGER, `changeNumber` INTEGER, PRIMARY KEY(`appId`))", + "fields": [ + { + "fieldPath": "appId", + "columnName": "appId", + "affinity": "INTEGER" + }, + { + "fieldPath": "changeNumber", + "columnName": "changeNumber", + "affinity": "INTEGER" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "appId" + ] + } + }, + { + "tableName": "encrypted_app_ticket", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`app_id` INTEGER NOT NULL, `result` INTEGER NOT NULL, `ticket_version_no` INTEGER NOT NULL, `crc_encrypted_ticket` INTEGER NOT NULL, `cb_encrypted_user_data` INTEGER NOT NULL, `cb_encrypted_app_ownership_ticket` INTEGER NOT NULL, `encrypted_ticket` BLOB NOT NULL, `timestamp` INTEGER NOT NULL, PRIMARY KEY(`app_id`))", + "fields": [ + { + "fieldPath": "appId", + "columnName": "app_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "result", + "columnName": "result", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ticketVersionNo", + "columnName": "ticket_version_no", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "crcEncryptedTicket", + "columnName": "crc_encrypted_ticket", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "cbEncryptedUserData", + "columnName": "cb_encrypted_user_data", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "cbEncryptedAppOwnershipTicket", + "columnName": "cb_encrypted_app_ownership_ticket", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "encryptedTicket", + "columnName": "encrypted_ticket", + "affinity": "BLOB", + "notNull": true + }, + { + "fieldPath": "timestamp", + "columnName": "timestamp", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "app_id" + ] + } + }, + { + "tableName": "app_file_change_lists", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appId` INTEGER, `userFileInfo` TEXT NOT NULL, PRIMARY KEY(`appId`))", + "fields": [ + { + "fieldPath": "appId", + "columnName": "appId", + "affinity": "INTEGER" + }, + { + "fieldPath": "userFileInfo", + "columnName": "userFileInfo", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "appId" + ] + } + }, + { + "tableName": "library_play_history", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`app_id` TEXT NOT NULL, `last_played` INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(`app_id`))", + "fields": [ + { + "fieldPath": "appId", + "columnName": "app_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "lastPlayed", + "columnName": "last_played", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "app_id" + ] + } + }, + { + "tableName": "steam_app", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `package_id` INTEGER NOT NULL, `owner_account_id` TEXT NOT NULL, `license_flags` INTEGER NOT NULL, `received_pics` INTEGER NOT NULL, `last_change_number` INTEGER NOT NULL, `ufs_parse_version` INTEGER NOT NULL DEFAULT 0, `depots` TEXT NOT NULL, `branches` TEXT NOT NULL, `name` TEXT NOT NULL, `type` INTEGER NOT NULL, `os_list` INTEGER NOT NULL, `release_state` INTEGER NOT NULL, `release_date` INTEGER NOT NULL, `metacritic_score` INTEGER NOT NULL, `metacritic_full_url` TEXT NOT NULL, `logo_hash` TEXT NOT NULL, `logo_small_hash` TEXT NOT NULL, `icon_hash` TEXT NOT NULL, `client_icon_hash` TEXT NOT NULL, `client_tga_hash` TEXT NOT NULL, `small_capsule` TEXT NOT NULL, `header_image` TEXT NOT NULL, `library_assets` TEXT NOT NULL, `primary_genre` INTEGER NOT NULL, `review_score` INTEGER NOT NULL, `review_percentage` INTEGER NOT NULL, `controller_support` INTEGER NOT NULL, `demo_of_app_id` INTEGER NOT NULL, `developer` TEXT NOT NULL, `publisher` TEXT NOT NULL, `homepage_url` TEXT NOT NULL, `game_manual_url` TEXT NOT NULL, `load_all_before_launch` INTEGER NOT NULL, `dlc_app_ids` TEXT NOT NULL, `is_free_app` INTEGER NOT NULL, `dlc_for_app_id` INTEGER NOT NULL, `must_own_app_to_purchase` INTEGER NOT NULL, `dlc_available_on_store` INTEGER NOT NULL, `optional_dlc` INTEGER NOT NULL, `game_dir` TEXT NOT NULL, `install_script` TEXT NOT NULL, `no_servers` INTEGER NOT NULL, `order` INTEGER NOT NULL, `primary_cache` INTEGER NOT NULL, `valid_os_list` INTEGER NOT NULL, `third_party_cd_key` INTEGER NOT NULL, `visible_only_when_installed` INTEGER NOT NULL, `visible_only_when_subscribed` INTEGER NOT NULL, `launch_eula_url` TEXT NOT NULL, `require_default_install_folder` INTEGER NOT NULL, `content_type` INTEGER NOT NULL, `install_dir` TEXT NOT NULL, `use_launch_cmd_line` INTEGER NOT NULL, `launch_without_workshop_updates` INTEGER NOT NULL, `use_mms` INTEGER NOT NULL, `install_script_signature` TEXT NOT NULL, `install_script_override` INTEGER NOT NULL, `config` TEXT NOT NULL, `ufs` TEXT NOT NULL, `workshop_mods` INTEGER NOT NULL DEFAULT 0, `enabled_workshop_item_ids` TEXT NOT NULL DEFAULT '', `workshop_download_pending` INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "packageId", + "columnName": "package_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ownerAccountId", + "columnName": "owner_account_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "licenseFlags", + "columnName": "license_flags", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "receivedPICS", + "columnName": "received_pics", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "lastChangeNumber", + "columnName": "last_change_number", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ufsParseVersion", + "columnName": "ufs_parse_version", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "depots", + "columnName": "depots", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "branches", + "columnName": "branches", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "name", + "columnName": "name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "type", + "columnName": "type", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "osList", + "columnName": "os_list", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "releaseState", + "columnName": "release_state", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "releaseDate", + "columnName": "release_date", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "metacriticScore", + "columnName": "metacritic_score", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "metacriticFullUrl", + "columnName": "metacritic_full_url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "logoHash", + "columnName": "logo_hash", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "logoSmallHash", + "columnName": "logo_small_hash", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "iconHash", + "columnName": "icon_hash", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "clientIconHash", + "columnName": "client_icon_hash", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "clientTgaHash", + "columnName": "client_tga_hash", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "smallCapsule", + "columnName": "small_capsule", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "headerImage", + "columnName": "header_image", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "libraryAssets", + "columnName": "library_assets", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "primaryGenre", + "columnName": "primary_genre", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "reviewScore", + "columnName": "review_score", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "reviewPercentage", + "columnName": "review_percentage", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "controllerSupport", + "columnName": "controller_support", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "demoOfAppId", + "columnName": "demo_of_app_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "developer", + "columnName": "developer", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publisher", + "columnName": "publisher", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "homepageUrl", + "columnName": "homepage_url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "gameManualUrl", + "columnName": "game_manual_url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "loadAllBeforeLaunch", + "columnName": "load_all_before_launch", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "dlcAppIds", + "columnName": "dlc_app_ids", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isFreeApp", + "columnName": "is_free_app", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "dlcForAppId", + "columnName": "dlc_for_app_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "mustOwnAppToPurchase", + "columnName": "must_own_app_to_purchase", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "dlcAvailableOnStore", + "columnName": "dlc_available_on_store", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "optionalDlc", + "columnName": "optional_dlc", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "gameDir", + "columnName": "game_dir", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "installScript", + "columnName": "install_script", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "noServers", + "columnName": "no_servers", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "order", + "columnName": "order", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "primaryCache", + "columnName": "primary_cache", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "validOSList", + "columnName": "valid_os_list", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "thirdPartyCdKey", + "columnName": "third_party_cd_key", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "visibleOnlyWhenInstalled", + "columnName": "visible_only_when_installed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "visibleOnlyWhenSubscribed", + "columnName": "visible_only_when_subscribed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "launchEulaUrl", + "columnName": "launch_eula_url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "requireDefaultInstallFolder", + "columnName": "require_default_install_folder", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "contentType", + "columnName": "content_type", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installDir", + "columnName": "install_dir", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "useLaunchCmdLine", + "columnName": "use_launch_cmd_line", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "launchWithoutWorkshopUpdates", + "columnName": "launch_without_workshop_updates", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "useMms", + "columnName": "use_mms", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installScriptSignature", + "columnName": "install_script_signature", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "installScriptOverride", + "columnName": "install_script_override", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "config", + "columnName": "config", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "ufs", + "columnName": "ufs", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "workshopMods", + "columnName": "workshop_mods", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "enabledWorkshopItemIds", + "columnName": "enabled_workshop_item_ids", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "workshopDownloadPending", + "columnName": "workshop_download_pending", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + } + }, + { + "tableName": "steam_file_hash_cache", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appId` INTEGER NOT NULL, `absPath` TEXT NOT NULL, `sizeBytes` INTEGER NOT NULL, `mtimeMillis` INTEGER NOT NULL, `sha` BLOB NOT NULL, PRIMARY KEY(`appId`, `absPath`))", + "fields": [ + { + "fieldPath": "appId", + "columnName": "appId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "absPath", + "columnName": "absPath", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "sizeBytes", + "columnName": "sizeBytes", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "mtimeMillis", + "columnName": "mtimeMillis", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "sha", + "columnName": "sha", + "affinity": "BLOB", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "appId", + "absPath" + ] + } + }, + { + "tableName": "steam_license", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`packageId` INTEGER NOT NULL, `last_change_number` INTEGER NOT NULL, `time_created` INTEGER NOT NULL, `time_next_process` INTEGER NOT NULL, `minute_limit` INTEGER NOT NULL, `minutes_used` INTEGER NOT NULL, `payment_method` INTEGER NOT NULL, `license_flags` INTEGER NOT NULL, `purchase_code` TEXT NOT NULL, `license_type` INTEGER NOT NULL, `territory_code` INTEGER NOT NULL, `access_token` INTEGER NOT NULL, `owner_account_id` TEXT NOT NULL, `master_package_id` INTEGER NOT NULL, `app_ids` TEXT NOT NULL, `depot_ids` TEXT NOT NULL, PRIMARY KEY(`packageId`))", + "fields": [ + { + "fieldPath": "packageId", + "columnName": "packageId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "lastChangeNumber", + "columnName": "last_change_number", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "timeCreated", + "columnName": "time_created", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "timeNextProcess", + "columnName": "time_next_process", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "minuteLimit", + "columnName": "minute_limit", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "minutesUsed", + "columnName": "minutes_used", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "paymentMethod", + "columnName": "payment_method", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "licenseFlags", + "columnName": "license_flags", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "purchaseCode", + "columnName": "purchase_code", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "licenseType", + "columnName": "license_type", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "territoryCode", + "columnName": "territory_code", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "accessToken", + "columnName": "access_token", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "ownerAccountId", + "columnName": "owner_account_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "masterPackageID", + "columnName": "master_package_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "appIds", + "columnName": "app_ids", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "depotIds", + "columnName": "depot_ids", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "packageId" + ] + } + }, + { + "tableName": "gog_games", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `title` TEXT NOT NULL, `slug` TEXT NOT NULL, `download_size` INTEGER NOT NULL, `install_size` INTEGER NOT NULL, `is_installed` INTEGER NOT NULL, `install_path` TEXT NOT NULL, `image_url` TEXT NOT NULL, `icon_url` TEXT NOT NULL, `background_url` TEXT NOT NULL DEFAULT '', `vertical_cover_url` TEXT NOT NULL DEFAULT '', `description` TEXT NOT NULL, `release_date` TEXT NOT NULL, `developer` TEXT NOT NULL, `publisher` TEXT NOT NULL, `genres` TEXT NOT NULL, `languages` TEXT NOT NULL, `last_played` INTEGER NOT NULL, `play_time` INTEGER NOT NULL, `type` INTEGER NOT NULL, `exclude` INTEGER NOT NULL DEFAULT 0, PRIMARY KEY(`id`))", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "title", + "columnName": "title", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "slug", + "columnName": "slug", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "downloadSize", + "columnName": "download_size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installSize", + "columnName": "install_size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "isInstalled", + "columnName": "is_installed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installPath", + "columnName": "install_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "imageUrl", + "columnName": "image_url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "iconUrl", + "columnName": "icon_url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "backgroundUrl", + "columnName": "background_url", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "verticalCoverUrl", + "columnName": "vertical_cover_url", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "description", + "columnName": "description", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "releaseDate", + "columnName": "release_date", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "developer", + "columnName": "developer", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publisher", + "columnName": "publisher", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "genres", + "columnName": "genres", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "languages", + "columnName": "languages", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "lastPlayed", + "columnName": "last_played", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "playTime", + "columnName": "play_time", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "type", + "columnName": "type", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "exclude", + "columnName": "exclude", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "id" + ] + } + }, + { + "tableName": "epic_games", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `catalog_id` TEXT NOT NULL, `app_name` TEXT NOT NULL, `title` TEXT NOT NULL, `namespace` TEXT NOT NULL, `developer` TEXT NOT NULL, `publisher` TEXT NOT NULL, `is_installed` INTEGER NOT NULL, `install_path` TEXT NOT NULL, `platform` TEXT NOT NULL, `version` TEXT NOT NULL, `executable` TEXT NOT NULL, `install_size` INTEGER NOT NULL, `download_size` INTEGER NOT NULL, `art_cover` TEXT NOT NULL, `art_square` TEXT NOT NULL, `art_logo` TEXT NOT NULL, `art_portrait` TEXT NOT NULL, `can_run_offline` INTEGER NOT NULL, `requires_ot` INTEGER NOT NULL, `cloud_save_enabled` INTEGER NOT NULL, `save_folder` TEXT NOT NULL, `third_party_managed_app` TEXT NOT NULL, `is_ea_managed` INTEGER NOT NULL, `is_dlc` INTEGER NOT NULL, `base_game_app_name` TEXT NOT NULL, `description` TEXT NOT NULL, `release_date` TEXT NOT NULL, `genres` TEXT NOT NULL, `tags` TEXT NOT NULL, `last_played` INTEGER NOT NULL, `play_time` INTEGER NOT NULL, `type` INTEGER NOT NULL, `eos_catalog_item_id` TEXT NOT NULL, `eos_app_id` TEXT NOT NULL)", + "fields": [ + { + "fieldPath": "id", + "columnName": "id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "catalogId", + "columnName": "catalog_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "appName", + "columnName": "app_name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "title", + "columnName": "title", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "namespace", + "columnName": "namespace", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "developer", + "columnName": "developer", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "publisher", + "columnName": "publisher", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isInstalled", + "columnName": "is_installed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installPath", + "columnName": "install_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "platform", + "columnName": "platform", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "version", + "columnName": "version", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "executable", + "columnName": "executable", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "installSize", + "columnName": "install_size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "downloadSize", + "columnName": "download_size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "artCover", + "columnName": "art_cover", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "artSquare", + "columnName": "art_square", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "artLogo", + "columnName": "art_logo", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "artPortrait", + "columnName": "art_portrait", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "canRunOffline", + "columnName": "can_run_offline", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "requiresOT", + "columnName": "requires_ot", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "cloudSaveEnabled", + "columnName": "cloud_save_enabled", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "saveFolder", + "columnName": "save_folder", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "thirdPartyManagedApp", + "columnName": "third_party_managed_app", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isEAManaged", + "columnName": "is_ea_managed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "isDLC", + "columnName": "is_dlc", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "baseGameAppName", + "columnName": "base_game_app_name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "description", + "columnName": "description", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "releaseDate", + "columnName": "release_date", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "genres", + "columnName": "genres", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "tags", + "columnName": "tags", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "lastPlayed", + "columnName": "last_played", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "playTime", + "columnName": "play_time", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "type", + "columnName": "type", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "eosCatalogItemId", + "columnName": "eos_catalog_item_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "eosAppId", + "columnName": "eos_app_id", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "id" + ] + } + }, + { + "tableName": "amazon_games", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`app_id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `product_id` TEXT NOT NULL, `entitlement_id` TEXT NOT NULL DEFAULT '', `title` TEXT NOT NULL, `is_installed` INTEGER NOT NULL, `install_path` TEXT NOT NULL, `art_url` TEXT NOT NULL, `hero_url` TEXT NOT NULL DEFAULT '', `purchased_date` TEXT NOT NULL, `developer` TEXT NOT NULL DEFAULT '', `publisher` TEXT NOT NULL DEFAULT '', `release_date` TEXT NOT NULL DEFAULT '', `download_size` INTEGER NOT NULL DEFAULT 0, `install_size` INTEGER NOT NULL DEFAULT 0, `version_id` TEXT NOT NULL DEFAULT '', `product_sku` TEXT NOT NULL DEFAULT '', `last_played` INTEGER NOT NULL DEFAULT 0, `play_time_minutes` INTEGER NOT NULL DEFAULT 0, `product_json` TEXT NOT NULL)", + "fields": [ + { + "fieldPath": "appId", + "columnName": "app_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "productId", + "columnName": "product_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "entitlementId", + "columnName": "entitlement_id", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "title", + "columnName": "title", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "isInstalled", + "columnName": "is_installed", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installPath", + "columnName": "install_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "artUrl", + "columnName": "art_url", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "heroUrl", + "columnName": "hero_url", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "purchasedDate", + "columnName": "purchased_date", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "developer", + "columnName": "developer", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "publisher", + "columnName": "publisher", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "releaseDate", + "columnName": "release_date", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "downloadSize", + "columnName": "download_size", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "installSize", + "columnName": "install_size", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "versionId", + "columnName": "version_id", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "productSku", + "columnName": "product_sku", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "''" + }, + { + "fieldPath": "lastPlayed", + "columnName": "last_played", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "playTimeMinutes", + "columnName": "play_time_minutes", + "affinity": "INTEGER", + "notNull": true, + "defaultValue": "0" + }, + { + "fieldPath": "productJson", + "columnName": "product_json", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "app_id" + ] + }, + "indices": [ + { + "name": "index_amazon_games_product_id", + "unique": false, + "columnNames": [ + "product_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_amazon_games_product_id` ON `${TABLE_NAME}` (`product_id`)" + } + ] + }, + { + "tableName": "downloading_app_info", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appId` INTEGER NOT NULL, `dlcAppIds` TEXT NOT NULL, `branch` TEXT NOT NULL DEFAULT 'public', PRIMARY KEY(`appId`))", + "fields": [ + { + "fieldPath": "appId", + "columnName": "appId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "dlcAppIds", + "columnName": "dlcAppIds", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "branch", + "columnName": "branch", + "affinity": "TEXT", + "notNull": true, + "defaultValue": "'public'" + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "appId" + ] + } + }, + { + "tableName": "steam_unlocked_branch", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appId` INTEGER NOT NULL, `branchName` TEXT NOT NULL, `password` TEXT NOT NULL, PRIMARY KEY(`appId`, `branchName`))", + "fields": [ + { + "fieldPath": "appId", + "columnName": "appId", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "branchName", + "columnName": "branchName", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "password", + "columnName": "password", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "appId", + "branchName" + ] + } + }, + { + "tableName": "mod_install", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`install_id` TEXT NOT NULL, `app_id` TEXT NOT NULL, `source` TEXT NOT NULL, `nexus_game_domain` TEXT, `nexus_mod_id` INTEGER, `nexus_file_id` INTEGER, `mod_name` TEXT NOT NULL, `file_name` TEXT NOT NULL, `version` TEXT NOT NULL, `size_bytes` INTEGER NOT NULL, `archive_path` TEXT NOT NULL, `extracted_path` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `status` TEXT NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, `downloaded_at` INTEGER NOT NULL, `metadata_json` TEXT NOT NULL, `archive_sha256` TEXT NOT NULL, PRIMARY KEY(`install_id`))", + "fields": [ + { + "fieldPath": "installId", + "columnName": "install_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "appId", + "columnName": "app_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "source", + "columnName": "source", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "nexusGameDomain", + "columnName": "nexus_game_domain", + "affinity": "TEXT" + }, + { + "fieldPath": "nexusModId", + "columnName": "nexus_mod_id", + "affinity": "INTEGER" + }, + { + "fieldPath": "nexusFileId", + "columnName": "nexus_file_id", + "affinity": "INTEGER" + }, + { + "fieldPath": "modName", + "columnName": "mod_name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "fileName", + "columnName": "file_name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "version", + "columnName": "version", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "sizeBytes", + "columnName": "size_bytes", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "archivePath", + "columnName": "archive_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "extractedPath", + "columnName": "extracted_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "enabled", + "columnName": "enabled", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "status", + "columnName": "status", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "downloadedAt", + "columnName": "downloaded_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "metadataJson", + "columnName": "metadata_json", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "archiveSha256", + "columnName": "archive_sha256", + "affinity": "TEXT", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "install_id" + ] + }, + "indices": [ + { + "name": "index_mod_install_app_id", + "unique": false, + "columnNames": [ + "app_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_install_app_id` ON `${TABLE_NAME}` (`app_id`)" + }, + { + "name": "index_mod_install_app_id_source_archive_sha256", + "unique": false, + "columnNames": [ + "app_id", + "source", + "archive_sha256" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_install_app_id_source_archive_sha256` ON `${TABLE_NAME}` (`app_id`, `source`, `archive_sha256`)" + }, + { + "name": "index_mod_install_app_id_source_nexus_game_domain_nexus_mod_id_nexus_file_id", + "unique": true, + "columnNames": [ + "app_id", + "source", + "nexus_game_domain", + "nexus_mod_id", + "nexus_file_id" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_mod_install_app_id_source_nexus_game_domain_nexus_mod_id_nexus_file_id` ON `${TABLE_NAME}` (`app_id`, `source`, `nexus_game_domain`, `nexus_mod_id`, `nexus_file_id`)" + } + ] + }, + { + "tableName": "mod_profile", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`profile_id` TEXT NOT NULL, `app_id` TEXT NOT NULL, `name` TEXT NOT NULL, `active` INTEGER NOT NULL, `created_at` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`profile_id`))", + "fields": [ + { + "fieldPath": "profileId", + "columnName": "profile_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "appId", + "columnName": "app_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "name", + "columnName": "name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "active", + "columnName": "active", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "createdAt", + "columnName": "created_at", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "profile_id" + ] + }, + "indices": [ + { + "name": "index_mod_profile_app_id", + "unique": false, + "columnNames": [ + "app_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_profile_app_id` ON `${TABLE_NAME}` (`app_id`)" + }, + { + "name": "index_mod_profile_app_id_name", + "unique": true, + "columnNames": [ + "app_id", + "name" + ], + "orders": [], + "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_mod_profile_app_id_name` ON `${TABLE_NAME}` (`app_id`, `name`)" + } + ] + }, + { + "tableName": "mod_profile_install_state", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`profile_id` TEXT NOT NULL, `install_id` TEXT NOT NULL, `app_id` TEXT NOT NULL, `enabled` INTEGER NOT NULL, `priority` INTEGER NOT NULL, `updated_at` INTEGER NOT NULL, PRIMARY KEY(`profile_id`, `install_id`), FOREIGN KEY(`profile_id`) REFERENCES `mod_profile`(`profile_id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`install_id`) REFERENCES `mod_install`(`install_id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "profileId", + "columnName": "profile_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "installId", + "columnName": "install_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "appId", + "columnName": "app_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "enabled", + "columnName": "enabled", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "priority", + "columnName": "priority", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "updatedAt", + "columnName": "updated_at", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": false, + "columnNames": [ + "profile_id", + "install_id" + ] + }, + "indices": [ + { + "name": "index_mod_profile_install_state_app_id", + "unique": false, + "columnNames": [ + "app_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_profile_install_state_app_id` ON `${TABLE_NAME}` (`app_id`)" + }, + { + "name": "index_mod_profile_install_state_install_id", + "unique": false, + "columnNames": [ + "install_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_profile_install_state_install_id` ON `${TABLE_NAME}` (`install_id`)" + }, + { + "name": "index_mod_profile_install_state_app_id_profile_id_priority", + "unique": false, + "columnNames": [ + "app_id", + "profile_id", + "priority" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_profile_install_state_app_id_profile_id_priority` ON `${TABLE_NAME}` (`app_id`, `profile_id`, `priority`)" + } + ], + "foreignKeys": [ + { + "table": "mod_profile", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "profile_id" + ], + "referencedColumns": [ + "profile_id" + ] + }, + { + "table": "mod_install", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "install_id" + ], + "referencedColumns": [ + "install_id" + ] + } + ] + }, + { + "tableName": "mod_placement_recipe", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`recipe_id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `install_id` TEXT NOT NULL, `source_subpath` TEXT NOT NULL, `target_root` TEXT NOT NULL, `target_relative_path` TEXT NOT NULL, `target_file_name` TEXT NOT NULL, `mode` TEXT NOT NULL, `strip_prefix_segments` INTEGER NOT NULL, `include_source_directory` INTEGER NOT NULL, `enabled` INTEGER NOT NULL, FOREIGN KEY(`install_id`) REFERENCES `mod_install`(`install_id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "recipeId", + "columnName": "recipe_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installId", + "columnName": "install_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "sourceSubpath", + "columnName": "source_subpath", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "targetRoot", + "columnName": "target_root", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "targetRelativePath", + "columnName": "target_relative_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "targetFileName", + "columnName": "target_file_name", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "mode", + "columnName": "mode", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "stripPrefixSegments", + "columnName": "strip_prefix_segments", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "includeSourceDirectory", + "columnName": "include_source_directory", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "enabled", + "columnName": "enabled", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "recipe_id" + ] + }, + "indices": [ + { + "name": "index_mod_placement_recipe_install_id", + "unique": false, + "columnNames": [ + "install_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_placement_recipe_install_id` ON `${TABLE_NAME}` (`install_id`)" + } + ], + "foreignKeys": [ + { + "table": "mod_install", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "install_id" + ], + "referencedColumns": [ + "install_id" + ] + } + ] + }, + { + "tableName": "mod_overwrite_manifest", + "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`manifest_id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `install_id` TEXT NOT NULL, `target_path` TEXT NOT NULL, `backup_path` TEXT NOT NULL, `original_hash` TEXT NOT NULL, `original_size` INTEGER NOT NULL, `original_mtime` INTEGER NOT NULL, `installed_hash` TEXT NOT NULL, `installed_size` INTEGER NOT NULL, `installed_mtime` INTEGER NOT NULL, `timestamp` INTEGER NOT NULL, FOREIGN KEY(`install_id`) REFERENCES `mod_install`(`install_id`) ON UPDATE NO ACTION ON DELETE CASCADE )", + "fields": [ + { + "fieldPath": "manifestId", + "columnName": "manifest_id", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installId", + "columnName": "install_id", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "targetPath", + "columnName": "target_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "backupPath", + "columnName": "backup_path", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "originalHash", + "columnName": "original_hash", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "originalSize", + "columnName": "original_size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "originalMtime", + "columnName": "original_mtime", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installedHash", + "columnName": "installed_hash", + "affinity": "TEXT", + "notNull": true + }, + { + "fieldPath": "installedSize", + "columnName": "installed_size", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "installedMtime", + "columnName": "installed_mtime", + "affinity": "INTEGER", + "notNull": true + }, + { + "fieldPath": "timestamp", + "columnName": "timestamp", + "affinity": "INTEGER", + "notNull": true + } + ], + "primaryKey": { + "autoGenerate": true, + "columnNames": [ + "manifest_id" + ] + }, + "indices": [ + { + "name": "index_mod_overwrite_manifest_install_id", + "unique": false, + "columnNames": [ + "install_id" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_overwrite_manifest_install_id` ON `${TABLE_NAME}` (`install_id`)" + }, + { + "name": "index_mod_overwrite_manifest_target_path", + "unique": false, + "columnNames": [ + "target_path" + ], + "orders": [], + "createSql": "CREATE INDEX IF NOT EXISTS `index_mod_overwrite_manifest_target_path` ON `${TABLE_NAME}` (`target_path`)" + } + ], + "foreignKeys": [ + { + "table": "mod_install", + "onDelete": "CASCADE", + "onUpdate": "NO ACTION", + "columns": [ + "install_id" + ], + "referencedColumns": [ + "install_id" + ] + } + ] + } + ], + "setupQueries": [ + "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)", + "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '7e163d4af9b2107253274fe6d3f84665')" + ] + } +} \ No newline at end of file diff --git a/app/src/main/java/app/gamenative/data/ModInstall.kt b/app/src/main/java/app/gamenative/data/ModInstall.kt index 08e32c391c..bedee8c485 100644 --- a/app/src/main/java/app/gamenative/data/ModInstall.kt +++ b/app/src/main/java/app/gamenative/data/ModInstall.kt @@ -223,6 +223,9 @@ data class ModPlacementRecipe( @ColumnInfo(name = "target_relative_path") val targetRelativePath: String = "", + @ColumnInfo(name = "target_file_name") + val targetFileName: String = "", + @ColumnInfo(name = "mode") val mode: String = ModPlacementMode.SYMLINK.name, diff --git a/app/src/main/java/app/gamenative/db/PluviaDatabase.kt b/app/src/main/java/app/gamenative/db/PluviaDatabase.kt index b803248c9f..abf83e96e9 100644 --- a/app/src/main/java/app/gamenative/db/PluviaDatabase.kt +++ b/app/src/main/java/app/gamenative/db/PluviaDatabase.kt @@ -69,7 +69,7 @@ const val DATABASE_NAME = "pluvia.db" ModPlacementRecipe::class, ModOverwriteManifest::class, ], - version = 25, + version = 26, // For db migration, visit https://developer.android.com/training/data-storage/room/migrating-db-versions for more information exportSchema = true, // It is better to handle db changes carefully, as GN is getting much more users. autoMigrations = [ diff --git a/app/src/main/java/app/gamenative/db/migration/RoomMigration.kt b/app/src/main/java/app/gamenative/db/migration/RoomMigration.kt index ff24584a5c..681668a97b 100644 --- a/app/src/main/java/app/gamenative/db/migration/RoomMigration.kt +++ b/app/src/main/java/app/gamenative/db/migration/RoomMigration.kt @@ -27,6 +27,18 @@ internal val ROOM_MIGRATION_V24_to_V25 = object : Migration(24, 25) { } } +internal val ROOM_MIGRATION_V25_to_V26 = object : Migration(25, 26) { + override fun migrate(connection: SQLiteConnection) { + connection.execSQL( + "ALTER TABLE `mod_placement_recipe` ADD COLUMN `target_file_name` TEXT NOT NULL DEFAULT ''", + ) + connection.execSQL( + "CREATE INDEX IF NOT EXISTS `index_mod_install_app_id_source_archive_sha256` " + + "ON `mod_install` (`app_id`, `source`, `archive_sha256`)", + ) + } +} + private fun migrateManagedModSourcesToV25(connection: SQLiteConnection) { connection.execSQL( """ diff --git a/app/src/main/java/app/gamenative/di/DatabaseModule.kt b/app/src/main/java/app/gamenative/di/DatabaseModule.kt index b0d71cedec..840e4a5712 100644 --- a/app/src/main/java/app/gamenative/di/DatabaseModule.kt +++ b/app/src/main/java/app/gamenative/di/DatabaseModule.kt @@ -14,6 +14,7 @@ import app.gamenative.db.dao.ModDao import app.gamenative.db.dao.SteamUnlockedBranchDao import app.gamenative.db.migration.ROOM_MIGRATION_V23_to_V24 import app.gamenative.db.migration.ROOM_MIGRATION_V24_to_V25 +import app.gamenative.db.migration.ROOM_MIGRATION_V25_to_V26 import app.gamenative.db.migration.ROOM_MIGRATION_V7_to_V8 import dagger.Module import dagger.Provides @@ -36,8 +37,9 @@ class DatabaseModule { ROOM_MIGRATION_V7_to_V8, ROOM_MIGRATION_V23_to_V24, ROOM_MIGRATION_V24_to_V25, + ROOM_MIGRATION_V25_to_V26, ) - .fallbackToDestructiveMigration(true) + .fallbackToDestructiveMigrationFrom(true, 16) .build() } diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt new file mode 100644 index 0000000000..5c3e929f79 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -0,0 +1,183 @@ +package app.gamenative.mods + +import app.gamenative.data.ModTargetRoot +import java.io.File +import java.util.Locale + +data class FomodExpectedMapping( + val mapping: FomodFileMapping, + val origin: PlacementOrigin, + val ordinal: Int, +) + +data class FomodSelectionEvaluation( + val mappings: List, + val flags: Map, + val blockingIssues: List, +) + +object FomodSelectionEvaluator { + fun evaluate(installer: FomodInstaller, selectedPluginKeys: Set): FomodSelectionEvaluation { + val selectedPlugins = FomodRecipeGenerator.selectedPluginsForKeys(installer, selectedPluginKeys) + val flags = linkedMapOf() + selectedPlugins.forEach { plugin -> plugin.conditionFlags.forEach { (name, value) -> flags[name] = value } } + var ordinal = 0 + val expected = buildList { + installer.requiredFiles.forEach { mapping -> + add(FomodExpectedMapping(mapping, PlacementOrigin.FOMOD_REQUIRED, ordinal++)) + } + selectedPlugins.forEach { plugin -> + plugin.files.forEach { mapping -> + add(FomodExpectedMapping(mapping, PlacementOrigin.FOMOD_OPTION, ordinal++)) + } + } + installer.conditionalFileInstalls.forEach { conditional -> + if (conditional.dependencies.unsupportedCount() == 0 && conditional.dependencies.matches(flags)) { + conditional.files.forEach { mapping -> + add(FomodExpectedMapping(mapping, PlacementOrigin.FOMOD_CONDITIONAL, ordinal++)) + } + } + } + } + val blockers = buildList { + addAll(installer.unsupportedWarnings) + if (installer.conditionalFileInstalls.any { it.dependencies.unsupportedCount() > 0 }) { + add("A selected FOMOD conditional uses unsupported dependencies") + } + if ( + installer.steps.flatMap { it.groups }.flatMap { it.plugins }.flatMap { it.typePatterns } + .any { it.dependencies.unsupportedCount() > 0 } + ) { + add("FOMOD option availability depends on unsupported game facts") + } + } + return FomodSelectionEvaluation(expected, flags, blockers.distinct()) + } +} + +object FomodPlanExpander { + fun expand( + installer: FomodInstaller, + evaluation: FomodSelectionEvaluation, + extractedRoot: File, + targetRoot: String = ModTargetRoot.GAME_DIR.name, + targetRelativePath: String = "Data", + ): ModInstallPlan { + val root = extractedRoot.canonicalFile + val expanded = mutableListOf() + val missing = mutableListOf() + + evaluation.mappings.forEach { expected -> + val sourcePath = joinPath(installer.basePath, expected.mapping.source) + val source = resolveCaseInsensitive(root, sourcePath) + when { + source == null || !source.exists() -> missing += expected.missingFile(sourcePath) + expected.mapping.directory && !source.isDirectory -> missing += expected.missingFile(sourcePath) + !expected.mapping.directory && !source.isFile -> missing += expected.missingFile(sourcePath) + expected.mapping.directory -> { + val sourceRoot = source.canonicalFile + source.walkTopDown() + .filter { it.isFile } + .sortedBy { file -> file.relativeTo(sourceRoot).path.lowercase(Locale.ROOT) } + .forEach { file -> + val relative = file.canonicalFile.relativeTo(sourceRoot).path.replace(File.separatorChar, '/') + val destination = joinPath(targetRelativePath, expected.mapping.destination, relative) + expanded += expected.expanded(file, root, targetRoot, destination) + } + } + else -> { + val destination = if (expected.mapping.destination.isBlank()) { + joinPath(targetRelativePath, source.name) + } else { + joinPath(targetRelativePath, expected.mapping.destination) + } + expanded += expected.expanded(source, root, targetRoot, destination) + } + } + } + + val planned = expanded.map { it.file }.toMutableList() + expanded.groupBy { it.file.normalizedTargetKey }.filterKeys { it != null }.values.forEach { contenders -> + if (contenders.size < 2) return@forEach + val winner = contenders.maxWithOrNull( + compareBy { it.file.priority }.thenBy { it.ordinal }, + ) ?: return@forEach + contenders.filter { it !== winner }.forEach { loser -> + val index = planned.indexOf(loser.file) + planned[index] = loser.file.copy( + status = PlannedFileStatus.INTENTIONALLY_IGNORED, + reason = "Superseded by a higher-priority FOMOD mapping", + ) + } + } + planned += missing + val blockers = buildList { + addAll(evaluation.blockingIssues) + if (missing.isNotEmpty()) add("${missing.size} selected FOMOD mapping(s) have missing or mismatched sources") + if (planned.any { it.status == PlannedFileStatus.UNSUPPORTED }) add("Some selected FOMOD destinations are invalid") + } + return ModInstallPlan( + files = planned.sortedWith( + compareBy { it.normalizedTargetKey.orEmpty() } + .thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) } + .thenByDescending { it.priority }, + ), + blockingIssues = blockers.distinct(), + ) + } + + private data class ExpandedFomodFile( + val file: PlannedModFile, + val ordinal: Int, + ) + + private fun FomodExpectedMapping.expanded( + source: File, + extractedRoot: File, + targetRoot: String, + destination: String, + ): ExpandedFomodFile { + val targetKey = WindowsPathIdentity.targetKey(targetRoot, destination) + return ExpandedFomodFile( + file = PlannedModFile( + sourceRelativePath = source.canonicalFile.relativeTo(extractedRoot).path.replace(File.separatorChar, '/'), + targetRoot = targetRoot, + targetRelativePath = destination, + normalizedTargetKey = targetKey, + status = if (targetKey == null) PlannedFileStatus.UNSUPPORTED else PlannedFileStatus.PLACED, + origin = origin, + priority = mapping.priority, + sizeBytes = source.length(), + reason = "Selected FOMOD ${origin.name.lowercase(Locale.ROOT).replace('_', ' ')} mapping", + risk = if (targetKey == null) PlacementRisk.REVIEW else PlacementRisk.SAFE, + ), + ordinal = ordinal, + ) + } + + private fun FomodExpectedMapping.missingFile(sourcePath: String): PlannedModFile = PlannedModFile( + sourceRelativePath = sourcePath, + status = PlannedFileStatus.MISSING, + origin = origin, + priority = mapping.priority, + reason = "Selected FOMOD source is missing or has the wrong file type", + risk = PlacementRisk.REVIEW, + ) + + private fun resolveCaseInsensitive(root: File, relativePath: String): File? { + val segments = normalizedArchiveKey(relativePath)?.split('/').orEmpty() + val displaySegments = normalizeArchiveDisplayPath(relativePath).split('/').filter(String::isNotBlank) + if (segments.size != displaySegments.size) return null + var current = root + displaySegments.forEach { segment -> + val matches = current.listFiles().orEmpty().filter { it.name.equals(segment, ignoreCase = true) } + if (matches.size != 1) return null + current = matches.single() + } + val candidate = runCatching { current.canonicalFile }.getOrNull() ?: return null + return candidate.takeIf { it == root || it.path.startsWith(root.path + File.separator) } + } + + private fun joinPath(vararg paths: String): String = + paths.map(::normalizeArchiveDisplayPath).filter(String::isNotBlank).joinToString("/") +} diff --git a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt index b389f9e5e3..631013bc31 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt @@ -110,6 +110,8 @@ fun FomodPlugin.effectiveType(flags: Map): FomodPluginType = data class FomodRecipeGenerationResult( val recipes: List, val unsupportedMappings: List, + val plan: ModInstallPlan? = null, + val blockingIssues: List = emptyList(), ) object FomodInstallerDetector { @@ -373,7 +375,30 @@ object FomodRecipeGenerator { targetRoot: String = ModTargetRoot.GAME_DIR.name, targetRelativePath: String = "Data", mode: String = ModPlacementMode.OVERWRITE_COPY.name, + extractedRoot: File? = null, ): FomodRecipeGenerationResult { + if (extractedRoot != null) { + val evaluation = FomodSelectionEvaluator.evaluate(installer, selectedPluginKeys) + val plan = FomodPlanExpander.expand(installer, evaluation, extractedRoot, targetRoot, targetRelativePath) + val recipes = plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { file -> + val destination = file.targetRelativePath.orEmpty() + ModPlacementRecipe( + installId = installId, + sourceSubpath = file.sourceRelativePath, + targetRoot = file.targetRoot ?: targetRoot, + targetRelativePath = destination.substringBeforeLast('/', missingDelimiterValue = ""), + targetFileName = destination.substringAfterLast('/'), + mode = mode, + includeSourceDirectory = false, + ) + } + return FomodRecipeGenerationResult( + recipes = recipes.distinctBy { Triple(it.sourceSubpath, it.targetRoot, it.targetRelativePath + "/" + it.targetFileName) }, + unsupportedMappings = emptyList(), + plan = plan, + blockingIssues = plan.blockingIssues, + ) + } val selectedPlugins = selectedPluginsForKeys(installer, selectedPluginKeys) val selectedFiles = selectedFiles(installer, selectedPlugins) @@ -462,17 +487,13 @@ object FomodRecipeGenerator { return@forEach } - val sourceName = mapping.source.substringAfterLast('/') val destinationName = destination.substringAfterLast('/') - if (!sourceName.equals(destinationName, ignoreCase = true)) { - unsupported += mapping - return@forEach - } recipes += ModPlacementRecipe( installId = installId, sourceSubpath = joinPath(basePath, mapping.source), targetRoot = targetRoot, targetRelativePath = joinPath(targetRelativePath, destination.substringBeforeLast('/', missingDelimiterValue = "")), + targetFileName = destinationName, mode = mode, includeSourceDirectory = false, ) diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index c800793d09..0438725432 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -342,7 +342,14 @@ object ModMaterializer { val effectiveSource = stripPrefix(source, recipe.stripPrefixSegments) return when { - effectiveSource.isFile -> listOf(plannedEntry(install.installId, effectiveSource, targetDir, effectiveSource.name)) + effectiveSource.isFile -> listOf( + plannedEntry( + install.installId, + effectiveSource, + targetDir, + recipe.targetFileName.ifBlank { effectiveSource.name }, + ), + ) recipe.includeSourceDirectory && effectiveSource != extractedRoot -> listOf(plannedEntry(install.installId, effectiveSource, targetDir, effectiveSource.name)) else -> effectiveSource.listFiles() diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index 02a5bbd119..24ac17b966 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -621,6 +621,7 @@ object NexusModManager { sourceSubpath = recipe.optString("sourceSubpath"), targetRoot = recipe.optString("targetRoot", ModTargetRoot.GAME_DIR.name), targetRelativePath = recipe.optString("targetRelativePath"), + targetFileName = recipe.optString("targetFileName"), mode = recipe.optString("mode", ModPlacementMode.SYMLINK.name), stripPrefixSegments = recipe.optInt("stripPrefixSegments", 0), includeSourceDirectory = recipe.optBoolean("includeSourceDirectory", false), @@ -646,6 +647,7 @@ object NexusModManager { .put("sourceSubpath", recipe.sourceSubpath) .put("targetRoot", recipe.targetRoot) .put("targetRelativePath", recipe.targetRelativePath) + .put("targetFileName", recipe.targetFileName) .put("mode", recipe.mode) .put("stripPrefixSegments", recipe.stripPrefixSegments) .put("includeSourceDirectory", recipe.includeSourceDirectory) @@ -667,6 +669,7 @@ object NexusModManager { recipe.sourceSubpath, recipe.targetRoot, normalizedRecipeTarget(recipe).lowercase(), + recipe.targetFileName.lowercase(), recipe.mode, recipe.stripPrefixSegments.toString(), recipe.includeSourceDirectory.toString(), diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 028be7691c..6ba8a8687e 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -154,6 +154,7 @@ internal data class RecipeDraft( val sourceSubpath: String = "", val targetRoot: String = ModTargetRoot.GAME_DIR.name, val targetRelativePath: String = "", + val targetFileName: String = "", val mode: String = ModPlacementMode.SYMLINK.name, val stripPrefixSegments: Int = 0, val includeSourceDirectory: Boolean = false, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt index 0047e2a16c..73fed0c93f 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt @@ -184,6 +184,7 @@ internal fun ModPlacementRecipe.toDraft(): RecipeDraft = sourceSubpath = sourceSubpath, targetRoot = targetRoot, targetRelativePath = targetRelativePath, + targetFileName = targetFileName, mode = mode, stripPrefixSegments = stripPrefixSegments, includeSourceDirectory = includeSourceDirectory, @@ -195,6 +196,7 @@ internal fun RecipeDraft.toRecipe(installId: String): ModPlacementRecipe = sourceSubpath = ModPlacementSources.encode(ModPlacementSources.decode(sourceSubpath)), targetRoot = targetRoot, targetRelativePath = normalizedTargetPath(), + targetFileName = targetFileName, mode = mode, stripPrefixSegments = stripPrefixSegments, includeSourceDirectory = includeSourceDirectory, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index 3c23e6ba3c..ef83e9995f 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -66,7 +66,8 @@ internal fun FomodSummarySection( Text(stringResource(R.string.nexus_fomod_installer), style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.primary, modifier = Modifier.weight(1f)) OutlinedButton( onClick = onConfigure, - enabled = installer.steps.isNotEmpty() && installer.unsupportedWarnings.none { it.contains("C# FOMOD", ignoreCase = true) }, + enabled = (installer.steps.isNotEmpty() || installer.requiredFiles.isNotEmpty()) && + installer.unsupportedWarnings.isEmpty(), ) { Text(stringResource(R.string.nexus_configure)) } @@ -288,10 +289,13 @@ internal fun FomodWizardDialog( targetRoot = baseDraft.targetRoot, targetRelativePath = baseDraft.targetRelativePath.ifBlank { "Data" }, mode = ModPlacementMode.OVERWRITE_COPY.name, + extractedRoot = extractedRoot, ) pendingResult = PendingFomodResult( drafts = result.recipes.map { it.toDraft() }, - unsupportedCount = result.unsupportedMappings.size, + unsupportedCount = result.plan?.let { plan -> + plan.unresolvedCount + plan.blockingIssues.size + } ?: (result.unsupportedMappings.size + result.blockingIssues.size), selectedOptions = fomodSelectedOptionLabels(installer, selectedKeys, fallbackStepNames), conditionalRuleCount = installer.conditionalFileInstalls.size, ) @@ -369,6 +373,7 @@ internal fun FomodWizardDialog( pendingResult = null onApply(result.drafts, result.unsupportedCount) }, + enabled = result.unsupportedCount == 0, ) { Text(stringResource(R.string.nexus_fomod_apply_choices)) } diff --git a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt index e31d15f55e..80c79e044a 100644 --- a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt @@ -1,7 +1,9 @@ package app.gamenative.mods import app.gamenative.data.ModPlacementMode +import app.gamenative.data.ModInstall import app.gamenative.data.ModTargetRoot +import kotlinx.coroutines.runBlocking import org.junit.After import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue @@ -171,7 +173,7 @@ class FomodInstallerTest { } @Test - fun generate_reportsRenamedFileMappingsAsUnsupported() { + fun generate_preservesRenamedFileDestination() { val installer = FomodInstaller( moduleName = "Example", requiredFiles = listOf(FomodFileMapping("Plugins/Source.esp", "Renamed.esp", 0, directory = false)), @@ -184,8 +186,8 @@ class FomodInstallerTest { selectedPluginNames = emptySet(), ) - assertEquals(0, result.recipes.size) - assertEquals("Renamed.esp", result.unsupportedMappings.single().destination) + assertTrue(result.unsupportedMappings.isEmpty()) + assertEquals("Renamed.esp", result.recipes.single().targetFileName) } @Test @@ -386,6 +388,103 @@ class FomodInstallerTest { assertEquals(listOf("PatchA"), result.recipes.map { it.sourceSubpath }) } + @Test + fun mcmHelperShape_plansAndAppliesEverySelectedFile() = runBlocking { + val moduleConfig = writeModuleConfig( + """ + + MCM Helper fixture + + + + + + + + + + + + + + + + + + + + + + """.trimIndent(), + ) + listOf( + "Required/config.json", + "Required/settings.ini", + "Required/readme.txt", + "Required/SKI_ConfigMenu.psc", + "SkyrimSE/SKSE/Plugins/MCMHelper.dll", + "SkyrimSE/SKSE/Plugins/MCMHelper.pdb", + "SkyrimVR/SKSE/Plugins/MCMHelper.dll", + "Plugins/MCMHelper.esl", + "Plugins/MCMHelper.esp", + "BSA/MCMHelper.bsa", + "Loose/MCM/Config/SkyUI_SE/loose.json", + ).forEach { path -> + File(tempDir, path).apply { + parentFile?.mkdirs() + writeText(path) + } + } + val installer = FomodParser.parse(moduleConfig, tempDir) + val result = FomodRecipeGenerator.generateForPluginKeys( + installId = "mcm", + installer = installer, + selectedPluginKeys = setOf("0:0:0", "0:1:0", "0:2:0"), + extractedRoot = tempDir, + ) + val expected = setOf( + "Data/MCM/Config/SkyUI_SE/config.json", + "Data/MCM/Config/SkyUI_SE/settings.ini", + "Data/MCM/Settings/readme.txt", + "Data/Source/Scripts/SKI_ConfigMenu.psc", + "Data/SKSE/Plugins/MCMHelper.dll", + "Data/SKSE/Plugins/MCMHelper.pdb", + "Data/MCMHelper.esl", + "Data/MCMHelper.bsa", + ) + + assertTrue(result.plan!!.isComplete) + assertEquals( + expected, + result.plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet(), + ) + + val game = File(tempDir, "game").apply { mkdirs() } + val install = ModInstall( + installId = "mcm", + appId = "game", + modName = "MCM Helper fixture", + fileName = "fixture.zip", + archivePath = "", + extractedPath = tempDir.absolutePath, + ) + val applied = ModMaterializer.apply( + install, + result.recipes, + game, + "", + File(tempDir, "backups"), + allowOverwrite = true, + ) + assertTrue(applied.errors.isEmpty()) + assertEquals( + expected, + game.walkTopDown().filter { it.isFile } + .map { it.relativeTo(game).path.replace(File.separatorChar, '/') } + .toSet(), + ) + } + private fun writeModuleConfig(xml: String): File { val file = File(tempDir, "fomod/ModuleConfig.xml") file.parentFile?.mkdirs() From 942f1a2841fdeaa982eb79b0649a2d2c17bbabfc Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 12:11:17 -0500 Subject: [PATCH 13/60] feat: add install plan review and diagnostics --- .../app/gamenative/mods/ModTargetResolver.kt | 22 ++++ .../ui/component/dialog/NexusModsDialog.kt | 37 ++++++ .../dialog/NexusModsPlacementSections.kt | 107 +++++++++++++++++- app/src/main/res/values/strings.xml | 8 ++ .../gamenative/mods/ModTargetResolverTest.kt | 23 ++++ 5 files changed, 195 insertions(+), 2 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt b/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt index 126562ee68..bea597a72f 100644 --- a/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt +++ b/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt @@ -9,6 +9,11 @@ data class ResolvedModTargetRoot( val dir: File, ) +data class ModTargetPlanInspection( + val caseMerges: List, + val ambiguousPaths: List, +) + object ModTargetResolver { fun normalizeRelativePath(path: String): String = path.trim().replace('\\', '/').trim('/') @@ -71,6 +76,23 @@ object ModTargetResolver { return target.takeIf { it.isInsideOrEqual(rootCanonical) } } + fun inspectPlan( + plan: ModInstallPlan, + resolvedRoots: List, + ): ModTargetPlanInspection { + val caseMerges = mutableSetOf() + val ambiguities = mutableSetOf() + val namespaces = resolvedRoots.associate { it.type.name to WindowsTargetNamespace(it.dir) } + plan.files.filter { it.status == PlannedFileStatus.PLACED }.forEach { file -> + val relative = file.targetRelativePath ?: return@forEach + val namespace = namespaces[file.targetRoot] ?: return@forEach + val resolution = namespace.resolve(relative) + caseMerges += resolution.caseMerges + if (resolution.ambiguousSegments.isNotEmpty()) ambiguities += relative + } + return ModTargetPlanInspection(caseMerges.sorted(), ambiguities.sorted()) + } + private fun File.safeCanonicalFile(): File? = runCatching { canonicalFile }.getOrNull() diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 6ba8a8687e..99030ae82b 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -65,6 +65,7 @@ import androidx.compose.ui.unit.dp import androidx.compose.ui.window.Dialog import androidx.compose.ui.window.DialogProperties import androidx.core.net.toUri +import androidx.core.content.FileProvider import app.gamenative.R import app.gamenative.data.LibraryItem import app.gamenative.data.ModInstall @@ -82,6 +83,7 @@ import app.gamenative.mods.BethesdaPluginAssetIssue import app.gamenative.mods.BethesdaPluginDependencyIssue import app.gamenative.mods.BethesdaPluginManager import app.gamenative.mods.AuthorizedNexusWebsiteDownload +import app.gamenative.mods.AutomaticPlacementPlanner import app.gamenative.mods.BrowserFirstNexusWebsiteDownload import app.gamenative.mods.FomodInstaller import app.gamenative.mods.FomodAutoSelector @@ -101,6 +103,7 @@ import app.gamenative.mods.ModFileConflictReport import app.gamenative.mods.ModHealthReport import app.gamenative.mods.ModHealthSeverity import app.gamenative.mods.ModImportProgress +import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.ModMaterializer import app.gamenative.mods.ModPathDetector import app.gamenative.mods.ModPlacementConflict @@ -2878,6 +2881,17 @@ fun NexusModsDialog( SnackbarManager.show(context.getString(R.string.nexus_choose_destination_inside)) return } + if (placementChoice == PlacementChoice.AUTOMATIC) { + val automaticPlan = AutomaticPlacementPlanner.plan(libraryItem.name, archiveEntries).recommended?.plan + val inspection = automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } + if ( + automaticPlan?.isComplete != true || + inspection?.ambiguousPaths?.isNotEmpty() == true + ) { + SnackbarManager.show(context.getString(R.string.nexus_plan_blocked)) + return + } + } if ( selectedFomodInstaller != null && placementChoice != PlacementChoice.CUSTOM && @@ -2929,6 +2943,24 @@ fun NexusModsDialog( } } + fun exportPlacementPlan(install: ModInstall, plan: ModInstallPlan) { + scope.launch { + val file = withContext(Dispatchers.IO) { + val outputDir = File(context.cacheDir, "mod-diagnostics").apply { mkdirs() } + File(outputDir, "placement-${install.installId.replace(Regex("[^A-Za-z0-9._-]"), "_")}.txt").apply { + writeText(plan.sanitizedManifest()) + } + } + val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file) + val intent = Intent(Intent.ACTION_SEND).apply { + type = "text/plain" + putExtra(Intent.EXTRA_STREAM, uri) + addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION) + } + context.startActivity(Intent.createChooser(intent, context.getString(R.string.nexus_plan_export))) + } + } + val issueCount = conflictReports.size + bethesdaPluginIssues.size + bethesdaPluginAssetIssues.size + (healthReport?.issues?.size ?: 0) fun selectInstallForPlacement(install: ModInstall) { @@ -3168,6 +3200,9 @@ fun NexusModsDialog( ManageModsTab.PLACEMENT -> { selectedInstall?.let { install -> val presetOptions = placementPresetOptions(libraryItem.name, archiveEntries, defaultDraft) + val automaticPlacement = remember(libraryItem.name, archiveEntries) { + AutomaticPlacementPlanner.plan(libraryItem.name, archiveEntries) + } PlacementSection( install = install, entries = archiveEntries, @@ -3175,6 +3210,7 @@ fun NexusModsDialog( roots = roots, drafts = recipeDrafts, presetOptions = presetOptions, + automaticPlacement = automaticPlacement, placementChoice = placementChoice, canUseLastPlacement = lastPlacementDrafts.isNotEmpty(), onPlacementChoiceChange = { choice -> @@ -3228,6 +3264,7 @@ fun NexusModsDialog( } }, applyStatusMessage = placementApplyStatusMessage, + onExportPlan = { plan -> exportPlacementPlan(install, plan) }, onSaveAndApply = ::saveAndApply, ) } ?: EmptyWorkflowSection(stringResource(R.string.nexus_no_mod_selected), stringResource(R.string.nexus_select_mod_from_mods_tab)) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 058cfd0b73..825074e28f 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -69,11 +69,14 @@ import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementMode import app.gamenative.data.ModTargetRoot import app.gamenative.mods.AutomaticPlacementPlanner +import app.gamenative.mods.AutomaticPlacementResult import app.gamenative.mods.FomodInstaller import app.gamenative.mods.ModArchiveEntry +import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.ModPlacementPreset import app.gamenative.mods.ModPlacementSources import app.gamenative.mods.ModTargetResolver +import app.gamenative.mods.PlannedFileStatus import app.gamenative.mods.ResolvedModTargetRoot import app.gamenative.ui.component.NoExtractOutlinedTextField import app.gamenative.utils.StorageUtils @@ -113,6 +116,7 @@ internal fun PlacementSection( roots: List, drafts: List, presetOptions: List, + automaticPlacement: AutomaticPlacementResult, placementChoice: PlacementChoice, canUseLastPlacement: Boolean, onPlacementChoiceChange: (PlacementChoice) -> Unit, @@ -123,11 +127,18 @@ internal fun PlacementSection( onRemoveDraft: (Int) -> Unit, onFomodRecipes: (List, Int) -> Unit, applyStatusMessage: String?, + onExportPlan: (ModInstallPlan) -> Unit, onSaveAndApply: () -> Unit, ) { var showArchiveBrowser by remember(install.installId, entries) { mutableStateOf(false) } var showFomodWizard by remember(install.installId, fomodInstaller) { mutableStateOf(false) } val destinationsValid = drafts.all { draft -> roots.any { it.type.name == draft.targetRoot } } + val automaticPlan = automaticPlacement.recommended?.plan + val targetInspection = remember(automaticPlan, roots) { + automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } + } + val automaticBlocked = placementChoice == PlacementChoice.AUTOMATIC && + (automaticPlan?.isComplete != true || targetInspection?.ambiguousPaths?.isNotEmpty() == true) Surface( modifier = Modifier.fillMaxWidth(), @@ -185,6 +196,22 @@ internal fun PlacementSection( }, ) + if (placementChoice == PlacementChoice.AUTOMATIC && automaticPlan != null) { + PlacementPlanReview( + automaticPlacement = automaticPlacement, + plan = automaticPlan, + caseMerges = targetInspection?.caseMerges.orEmpty(), + ambiguousPaths = targetInspection?.ambiguousPaths.orEmpty(), + onExport = { onExportPlan(automaticPlan) }, + ) + } else if (placementChoice == PlacementChoice.AUTOMATIC) { + Text( + stringResource(R.string.nexus_plan_blocked), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } + if (placementChoice == PlacementChoice.PRESET && presetOptions.isNotEmpty()) { PresetSelectionSection( presets = presetOptions, @@ -244,7 +271,7 @@ internal fun PlacementSection( } Button( onClick = onSaveAndApply, - enabled = roots.isNotEmpty() && destinationsValid, + enabled = roots.isNotEmpty() && destinationsValid && !automaticBlocked, modifier = Modifier.fillMaxWidth(), ) { Icon(Icons.Default.Save, contentDescription = null, modifier = Modifier.size(18.dp)) @@ -261,7 +288,10 @@ internal fun PlacementSection( Text(stringResource(R.string.nexus_add_location)) } } - Button(onClick = onSaveAndApply, enabled = roots.isNotEmpty() && destinationsValid) { + Button( + onClick = onSaveAndApply, + enabled = roots.isNotEmpty() && destinationsValid && !automaticBlocked, + ) { Icon(Icons.Default.Save, contentDescription = null, modifier = Modifier.size(18.dp)) Spacer(Modifier.size(8.dp)) Text(stringResource(R.string.nexus_apply_mod)) @@ -297,6 +327,79 @@ internal fun PlacementSection( } } +@Composable +private fun PlacementPlanReview( + automaticPlacement: AutomaticPlacementResult, + plan: ModInstallPlan, + caseMerges: List, + ambiguousPaths: List, + onExport: () -> Unit, +) { + Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { + Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { + Text(stringResource(R.string.nexus_plan_review_title), style = MaterialTheme.typography.labelLarge) + Text( + stringResource( + R.string.nexus_plan_coverage, + plan.placedCount, + plan.selectedCount, + plan.ignoredCount, + plan.unresolvedCount, + ), + style = MaterialTheme.typography.bodySmall, + ) + automaticPlacement.recommended?.evidence.orEmpty().forEach { evidence -> + Text("• $evidence", style = MaterialTheme.typography.bodySmall) + } + if (automaticPlacement.candidates.size > 1) { + Text(stringResource(R.string.nexus_plan_ranked), style = MaterialTheme.typography.labelMedium) + automaticPlacement.candidates.take(3).forEachIndexed { index, candidate -> + Text( + stringResource( + R.string.nexus_plan_score, + index + 1, + candidate.label, + (candidate.plan.coverage * 100).toInt(), + ), + style = MaterialTheme.typography.bodySmall, + ) + } + } + caseMerges.take(5).forEach { merge -> + Text(stringResource(R.string.nexus_plan_case_merge, merge), style = MaterialTheme.typography.bodySmall) + } + plan.files.filter { + it.status == PlannedFileStatus.UNSUPPORTED || + it.status == PlannedFileStatus.MISSING || + it.status == PlannedFileStatus.CONFLICTED + }.take(8).forEach { file -> + Text( + "${file.sourceRelativePath}: ${file.reason}", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } + ambiguousPaths.take(5).forEach { path -> + Text( + "$path: ${stringResource(R.string.nexus_plan_ambiguous_case)}", + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } + if (!plan.isComplete || ambiguousPaths.isNotEmpty()) { + Text( + stringResource(R.string.nexus_plan_blocked), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } + TextButton(onClick = onExport) { + Text(stringResource(R.string.nexus_plan_export)) + } + } + } +} + @Composable private fun PresetSelectionSection( presets: List, diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index dead7a0b3c..29961a3f33 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2047,6 +2047,14 @@ Storage is too low to apply mod order. Free at least %1$s more. Applying mod order Refreshing install health + Placement review + %1$d of %2$d files planned • %3$d ignored • %4$d need review + Ranked suggestions + %1$d. %2$s — %3$d%% coverage + Case merge: %1$s + ambiguous case variants already exist + Automatic apply is blocked until every installable file has a proven destination. + Share diagnostic Mod order applied%1$s%2$s Mod order applied with %1$d error(s)%2$s%3$s Failed to apply mod order diff --git a/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt b/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt index 2dc78ea28e..e37721a48d 100644 --- a/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt @@ -102,6 +102,29 @@ class ModTargetResolverTest { assertEquals(scripts.canonicalFile, resolved) } + @Test + fun inspectPlan_reportsCaseMergeWithoutChangingThePlan() { + File(gameDir, "Data/Scripts").mkdirs() + val plan = ModInstallPlan( + files = listOf( + PlannedModFile( + sourceRelativePath = "scripts/example.pex", + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "Data/scripts/example.pex", + normalizedTargetKey = "GAME_DIR:data/scripts/example.pex", + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.GAME_RULE, + reason = "fixture", + ), + ), + ) + + val inspection = ModTargetResolver.inspectPlan(plan, ModTargetResolver.roots(gameDir, winePrefix.absolutePath)) + + assertTrue(inspection.caseMerges.any { it.contains("scripts -> Scripts") }) + assertTrue(inspection.ambiguousPaths.isEmpty()) + } + @Test fun resolve_blocksAmbiguousExistingCaseVariants() { File(gameDir, "Data/Scripts").mkdirs() From 4cc5368afb1ae675d5b2d9a0505afac056cca93d Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 12:34:16 -0500 Subject: [PATCH 14/60] feat: add durable mod file ownership --- .../app/gamenative/mods/ModMaterializer.kt | 208 ++++++++--- .../gamenative/mods/ModOwnershipManifest.kt | 350 ++++++++++++++++++ .../app/gamenative/mods/NexusModManager.kt | 109 +++--- .../ui/component/dialog/NexusModsDialog.kt | 23 +- .../gamenative/mods/ModMaterializerTest.kt | 28 ++ .../mods/ModOwnershipManifestTest.kt | 88 +++++ 6 files changed, 703 insertions(+), 103 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt create mode 100644 app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index 0438725432..bfd9b783ce 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -25,15 +25,42 @@ data class ModPlacementResult( val backedUp: Int, val errors: Map, val manifests: List, + val warnings: List = emptyList(), ) data class ModPlannedEntry( val installId: String, val source: File, val target: File, + val mode: ModPlacementMode = ModPlacementMode.SYMLINK, + val targetRoot: String = "", + val sourceRelativePath: String = "", + val targetRelativePath: String = "", val normalizedTargetKey: String = WindowsPathIdentity.absoluteKey(target), ) +data class ModPlannedFile( + val installId: String, + val source: File, + val target: File, + val mode: ModPlacementMode, + val targetRoot: String, + val sourceRelativePath: String, + val targetRelativePath: String, + val normalizedTargetKey: String = WindowsPathIdentity.absoluteKey(target), + val targetExistedBefore: Boolean = target.exists() || Files.isSymbolicLink(target.toPath()), + val targetHashBefore: String = "", +) + +data class ModMaterializationPlan( + val installId: String, + val operations: List, + val files: List, + val errors: Map = emptyMap(), +) { + val isComplete: Boolean get() = errors.isEmpty() +} + object ModMaterializer { private const val COPY_SENTINEL = ".gamenative_mod_install" private const val APPLY_FREE_SPACE_RESERVE_BYTES = 512L * 1024L * 1024L @@ -57,11 +84,10 @@ object ModMaterializer { gameRootDir: File?, winePrefix: String, ): List = withContext(Dispatchers.IO) { + val plan = materializationPlan(install, recipes, gameRootDir, winePrefix) buildList { - recipes.filter { it.enabled }.forEach { recipe -> - val mode = runCatching { ModPlacementMode.valueOf(recipe.mode) }.getOrDefault(ModPlacementMode.SYMLINK) - plannedEntries(install, recipe, gameRootDir, winePrefix).forEach { entry -> - when (mode) { + plan.operations.forEach { entry -> + when (entry.mode) { ModPlacementMode.OVERWRITE_COPY -> addAll(overwriteConflicts(entry)) else -> { if (entry.target.exists() || Files.isSymbolicLink(entry.target.toPath())) { @@ -79,7 +105,6 @@ object ModMaterializer { } } } - } } } } @@ -134,26 +159,30 @@ object ModMaterializer { winePrefix: String, backupRoot: File, allowOverwrite: Boolean, + ): ModPlacementResult { + val plan = withContext(Dispatchers.IO) { + materializationPlan(install, recipes, gameRootDir, winePrefix) + } + return apply(install, plan, backupRoot, allowOverwrite) + } + + suspend fun apply( + install: ModInstall, + plan: ModMaterializationPlan, + backupRoot: File, + allowOverwrite: Boolean, ): ModPlacementResult = withContext(Dispatchers.IO) { var created = 0 var skipped = 0 var backedUp = 0 - val errors = linkedMapOf() + val errors = linkedMapOf().apply { putAll(plan.errors) } val manifests = mutableListOf() val targetsWrittenThisApply = mutableSetOf() backupRoot.mkdirs() - recipes.filter { it.enabled }.forEach { recipe -> - val mode = runCatching { ModPlacementMode.valueOf(recipe.mode) }.getOrDefault(ModPlacementMode.SYMLINK) - val entries = runCatching { plannedEntries(install, recipe, gameRootDir, winePrefix) } - .getOrElse { e -> - errors[recipe.sourceSubpath.ifBlank { recipe.targetRelativePath.ifBlank { install.modName } }] = - e.message ?: e::class.simpleName.orEmpty() - emptyList() - } - entries.forEach { entry -> + plan.operations.forEach { entry -> try { - when (mode) { + when (entry.mode) { ModPlacementMode.SYMLINK -> { val result = ensureSymlink(entry.target, entry.source) if (result) created++ else skipped++ @@ -179,7 +208,6 @@ object ModMaterializer { } catch (e: Exception) { errors[entry.target.absolutePath] = "${e::class.simpleName}: ${e.message}" } - } } ModPlacementResult(created, skipped, backedUp, errors, manifests) @@ -193,19 +221,12 @@ object ModMaterializer { ): ModPlacementResult = withContext(Dispatchers.IO) { var created = 0 var skipped = 0 - val errors = linkedMapOf() + val plan = materializationPlan(install, recipes, gameRootDir, winePrefix) + val errors = linkedMapOf().apply { putAll(plan.errors) } - recipes.filter { it.enabled }.forEach { recipe -> - val mode = runCatching { ModPlacementMode.valueOf(recipe.mode) }.getOrDefault(ModPlacementMode.SYMLINK) - val entries = runCatching { plannedEntries(install, recipe, gameRootDir, winePrefix) } - .getOrElse { e -> - errors[recipe.sourceSubpath.ifBlank { recipe.targetRelativePath.ifBlank { install.modName } }] = - e.message ?: e::class.simpleName.orEmpty() - emptyList() - } - entries.forEach { entry -> + plan.operations.forEach { entry -> try { - when (mode) { + when (entry.mode) { ModPlacementMode.SYMLINK -> { if (entry.target.exists() || Files.isSymbolicLink(entry.target.toPath())) { skipped++ @@ -225,7 +246,6 @@ object ModMaterializer { } catch (e: Exception) { errors[entry.target.absolutePath] = "${e::class.simpleName}: ${e.message}" } - } } ModPlacementResult(created, skipped, backedUp = 0, errors = errors, manifests = emptyList()) @@ -263,11 +283,10 @@ object ModMaterializer { restoredOverwriteTargets: Set = emptySet(), ): List = withContext(Dispatchers.IO) { val skipped = mutableListOf() - recipes.filter { it.enabled }.forEach { recipe -> - val mode = runCatching { ModPlacementMode.valueOf(recipe.mode) }.getOrDefault(ModPlacementMode.SYMLINK) + val plan = materializationPlan(install, recipes, gameRootDir, winePrefix) + plan.operations.forEach { entry -> runCatching { - plannedEntries(install, recipe, gameRootDir, winePrefix).forEach { entry -> - when (mode) { + when (entry.mode) { ModPlacementMode.SYMLINK -> removeSymlink(entry.target, entry.source, skipped) ModPlacementMode.COPY -> removeCopiedEntry( target = entry.target, @@ -288,21 +307,50 @@ object ModMaterializer { removeLegacySentinel = true, ) } - } - }.onFailure { skipped += "${recipe.targetRoot}:${recipe.targetRelativePath}" } + }.onFailure { skipped += "${entry.targetRoot}:${entry.targetRelativePath}" } } + skipped += plan.errors.keys skipped.distinct() } - fun plannedEntries( + fun materializationPlan( install: ModInstall, recipes: List, gameRootDir: File?, winePrefix: String, - ): List = - recipes.filter { it.enabled }.flatMap { recipe -> - plannedEntries(install, recipe, gameRootDir, winePrefix) + ): ModMaterializationPlan { + val operations = mutableListOf() + val errors = linkedMapOf() + recipes.filter { it.enabled }.forEach { recipe -> + runCatching { plannedEntries(install, recipe, gameRootDir, winePrefix) } + .onSuccess(operations::addAll) + .onFailure { error -> + val key = recipe.sourceSubpath.ifBlank { recipe.targetRelativePath.ifBlank { install.modName } } + errors[key] = error.message ?: error::class.simpleName.orEmpty() + } } + val expandedFiles = operations.flatMap(::expandPlannedFiles) + val files = expandedFiles.groupBy { it.normalizedTargetKey }.flatMap { (targetKey, values) -> + val distinctSources = values.map { it.source.canonicalPath }.distinct() + when { + distinctSources.size <= 1 -> listOf(values.last()) + values.all { it.mode == ModPlacementMode.OVERWRITE_COPY } -> listOf(values.last()) + else -> { + errors[targetKey] = "Multiple selected files target the same Windows path: " + + values.joinToString { it.sourceRelativePath } + values + } + } + }.sortedWith(compareBy { it.normalizedTargetKey }.thenBy { it.sourceRelativePath.lowercase() }) + return ModMaterializationPlan(install.installId, operations, files, errors) + } + + fun plannedEntries( + install: ModInstall, + recipes: List, + gameRootDir: File?, + winePrefix: String, + ): List = materializationPlan(install, recipes, gameRootDir, winePrefix).operations private fun plannedEntries( install: ModInstall, @@ -339,6 +387,7 @@ object ModMaterializer { gameRootDir = gameRootDir, winePrefix = winePrefix, ) ?: throw IOException("Target root is unavailable: ${recipe.targetRoot}") + val mode = runCatching { ModPlacementMode.valueOf(recipe.mode) }.getOrDefault(ModPlacementMode.SYMLINK) val effectiveSource = stripPrefix(source, recipe.stripPrefixSegments) return when { @@ -348,21 +397,94 @@ object ModMaterializer { effectiveSource, targetDir, recipe.targetFileName.ifBlank { effectiveSource.name }, + mode, + recipe.targetRoot, + extractedRoot, + recipe.targetRelativePath, ), ) recipe.includeSourceDirectory && effectiveSource != extractedRoot -> - listOf(plannedEntry(install.installId, effectiveSource, targetDir, effectiveSource.name)) + listOf( + plannedEntry( + install.installId, + effectiveSource, + targetDir, + effectiveSource.name, + mode, + recipe.targetRoot, + extractedRoot, + recipe.targetRelativePath, + ), + ) else -> effectiveSource.listFiles() ?.filter { !it.name.startsWith(".") } - ?.map { plannedEntry(install.installId, it, targetDir, it.name) } + ?.map { + plannedEntry( + install.installId, + it, + targetDir, + it.name, + mode, + recipe.targetRoot, + extractedRoot, + recipe.targetRelativePath, + ) + } ?: emptyList() } } - private fun plannedEntry(installId: String, source: File, targetRoot: File, relative: String): ModPlannedEntry { + private fun plannedEntry( + installId: String, + source: File, + targetRoot: File, + relative: String, + mode: ModPlacementMode, + targetRootName: String, + extractedRoot: File, + targetBaseRelative: String, + ): ModPlannedEntry { val target = ModTargetResolver.resolveWithin(targetRoot, relative) ?: throw IOException("Target path is invalid or case-ambiguous: $relative") - return ModPlannedEntry(installId, source, target) + return ModPlannedEntry( + installId = installId, + source = source, + target = target, + mode = mode, + targetRoot = targetRootName, + sourceRelativePath = source.relativeTo(extractedRoot).path.replace(File.separatorChar, '/'), + targetRelativePath = listOf(targetBaseRelative, relative) + .filter(String::isNotBlank) + .joinToString("/") + .replace(File.separatorChar, '/'), + ) + } + + private fun expandPlannedFiles(entry: ModPlannedEntry): List { + val files = if (entry.source.isFile) sequenceOf(entry.source) else entry.source.walkTopDown().filter { it.isFile } + return files.map { sourceFile -> + val nested = if (entry.source.isFile) "" else sourceFile.relativeTo(entry.source).path + val targetFile = if (nested.isBlank()) entry.target else safeChildTarget(entry.target, nested) + ModPlannedFile( + installId = entry.installId, + source = sourceFile, + target = targetFile, + mode = entry.mode, + targetRoot = entry.targetRoot, + sourceRelativePath = sourceFile.path.removePrefix(entry.source.path) + .trimStart(File.separatorChar) + .let { nestedSource -> + listOf(entry.sourceRelativePath, nestedSource) + .filter(String::isNotBlank) + .joinToString("/") + .replace(File.separatorChar, '/') + }, + targetRelativePath = listOf(entry.targetRelativePath, nested.replace(File.separatorChar, '/')) + .filter(String::isNotBlank) + .joinToString("/"), + targetHashBefore = if (targetFile.isFile && !Files.isSymbolicLink(targetFile.toPath())) sha256(targetFile) else "", + ) + }.toList() } private fun resolveSource(extractedRoot: File, normalizedSource: String): File { diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt new file mode 100644 index 0000000000..2c7de36970 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -0,0 +1,350 @@ +package app.gamenative.mods + +import app.gamenative.data.ModOverwriteManifest +import com.github.luben.zstd.Zstd +import com.github.luben.zstd.ZstdInputStream +import kotlinx.serialization.Serializable +import kotlinx.serialization.decodeFromString +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json +import java.io.File +import java.io.FileInputStream +import java.io.FileOutputStream +import java.nio.file.Files +import java.security.MessageDigest + +@Serializable +enum class ModOwnershipState { + ACTIVE, + DISABLED, + RECOVERY_REQUIRED, +} + +@Serializable +enum class ModOwnedFileDisposition { + CREATED, + MERGED, + OVERWROTE, + BACKED_UP, + SHARED, + STALE_PRESERVED, +} + +@Serializable +data class ModOwnedFile( + val sourceRelativePath: String, + val targetRoot: String, + val targetRelativePath: String, + val targetPath: String, + val normalizedTargetKey: String, + val mode: String, + val installedHash: String, + val installedSize: Long, + val installedMtime: Long, + val disposition: ModOwnedFileDisposition, + val priority: Int = 0, + val active: Boolean = true, +) + +@Serializable +data class ModOwnedOperation( + val sourcePath: String, + val targetPath: String, + val normalizedTargetKey: String, + val mode: String, +) + +@Serializable +data class ModOwnershipManifest( + val version: Int = 1, + val installId: String, + val appId: String, + val profileId: String = "", + val planDigest: String, + val state: ModOwnershipState = ModOwnershipState.ACTIVE, + val files: List, + val operations: List = emptyList(), + val createdAt: Long = System.currentTimeMillis(), +) + +data class ModOverlayContribution( + val installId: String, + val priority: Int, + val file: ModOwnedFile, +) + +data class ModOverlayTarget( + val normalizedTargetKey: String, + val contributors: List, + val winner: ModOverlayContribution, + val identicalContents: Boolean, + val hasCaseCollision: Boolean, +) + +data class ModProfileOverlay( + val targets: Map, + val conflicts: List, +) + +object ModProfileOverlayPlanner { + fun build( + manifests: List, + enabledPriorities: Map, + ): ModProfileOverlay { + val targets = manifests.asSequence() + .filter { it.state == ModOwnershipState.ACTIVE && it.installId in enabledPriorities } + .flatMap { manifest -> + manifest.files.asSequence() + .filter { it.active } + .map { file -> ModOverlayContribution(manifest.installId, enabledPriorities.getValue(manifest.installId), file) } + } + .groupBy { it.file.normalizedTargetKey } + .mapValues { (key, contributions) -> + val ordered = contributions.sortedWith(compareBy { it.priority }.thenBy { it.installId }) + val paths = ordered.map { it.file.targetPath.replace('\\', '/') }.distinct() + ModOverlayTarget( + normalizedTargetKey = key, + contributors = ordered, + winner = ordered.last(), + identicalContents = ordered.map { it.file.installedHash }.filter(String::isNotBlank).distinct().size <= 1, + hasCaseCollision = paths.map(String::lowercase).distinct().size < paths.size, + ) + } + .toSortedMap() + return ModProfileOverlay(targets, targets.values.filter { it.contributors.size > 1 && !it.identicalContents }) + } +} + +object ModOwnershipStore { + private val json = Json { ignoreUnknownKeys = true } + + fun read(root: File, installId: String): ModOwnershipManifest? = + readFile(currentFile(root, installId)) ?: readFile(previousFile(root, installId)) + + fun readAll(root: File): List = + ownershipDir(root).listFiles() + .orEmpty() + .filter { it.isFile && it.name.endsWith(".json.zst") && !it.name.endsWith(".previous.json.zst") } + .mapNotNull(::readFile) + + fun writePending(root: File, manifest: ModOwnershipManifest) { + val current = currentFile(root, manifest.installId) + val previous = previousFile(root, manifest.installId) + val temp = File(current.parentFile, "${current.name}.tmp") + current.parentFile?.mkdirs() + val payload = Zstd.compress(json.encodeToString(manifest).toByteArray(Charsets.UTF_8), 3) + FileOutputStream(temp).use { output -> + output.write(payload) + output.fd.sync() + } + if (current.isFile) { + previous.delete() + moveReplacing(current, previous) + } + moveReplacing(temp, current) + } + + fun commit(root: File, installId: String) { + previousFile(root, installId).delete() + } + + fun delete(root: File, installId: String) { + currentFile(root, installId).delete() + previousFile(root, installId).delete() + File(currentFile(root, installId).parentFile, "${currentFile(root, installId).name}.tmp").delete() + } + + fun create( + appId: String, + plan: ModMaterializationPlan, + overwriteManifests: List, + profileId: String = "", + priority: Int = 0, + preservedStale: List = emptyList(), + ): ModOwnershipManifest { + val overwriteByTarget = overwriteManifests.associateBy { WindowsPathIdentity.absoluteKey(File(it.targetPath)) } + val files = plan.files.map { planned -> + val target = planned.target + val overwrite = overwriteByTarget[planned.normalizedTargetKey] + val installedHash = when { + target.isFile -> sha256(target) + planned.source.isFile -> sha256(planned.source) + else -> "" + } + val disposition = when { + overwrite?.backupPath?.isNotBlank() == true -> ModOwnedFileDisposition.BACKED_UP + planned.targetExistedBefore && planned.targetHashBefore == installedHash -> ModOwnedFileDisposition.SHARED + planned.mode.name == "OVERWRITE_COPY" && planned.targetExistedBefore -> ModOwnedFileDisposition.OVERWROTE + planned.targetExistedBefore -> ModOwnedFileDisposition.MERGED + else -> ModOwnedFileDisposition.CREATED + } + ModOwnedFile( + sourceRelativePath = planned.sourceRelativePath, + targetRoot = planned.targetRoot, + targetRelativePath = planned.targetRelativePath, + targetPath = target.absolutePath, + normalizedTargetKey = planned.normalizedTargetKey, + mode = planned.mode.name, + installedHash = installedHash, + installedSize = if (target.isFile) target.length() else planned.source.length(), + installedMtime = if (target.exists()) target.lastModified() else planned.source.lastModified(), + disposition = disposition, + priority = priority, + ) + } + return ModOwnershipManifest( + installId = plan.installId, + appId = appId, + profileId = profileId, + planDigest = planDigest(plan), + files = (files + preservedStale).distinctBy { it.normalizedTargetKey to it.active }, + operations = plan.operations.map { operation -> + ModOwnedOperation( + sourcePath = operation.source.absolutePath, + targetPath = operation.target.absolutePath, + normalizedTargetKey = operation.normalizedTargetKey, + mode = operation.mode.name, + ) + }, + ) + } + + private fun ownershipDir(root: File): File = File(root, "ownership") + + private fun currentFile(root: File, installId: String): File = + File(ownershipDir(root), "${safeName(installId)}.json.zst") + + private fun previousFile(root: File, installId: String): File = + File(ownershipDir(root), "${safeName(installId)}.previous.json.zst") + + private fun safeName(value: String): String = value.replace(Regex("[^A-Za-z0-9._-]"), "_") + + private fun readFile(file: File): ModOwnershipManifest? { + if (!file.isFile) return null + return runCatching { + ZstdInputStream(FileInputStream(file)).bufferedReader().use { reader -> + json.decodeFromString(reader.readText()) + } + }.getOrNull() + } + + private fun moveReplacing(source: File, target: File) { + runCatching { + Files.move( + source.toPath(), + target.toPath(), + java.nio.file.StandardCopyOption.ATOMIC_MOVE, + java.nio.file.StandardCopyOption.REPLACE_EXISTING, + ) + }.getOrElse { + source.copyTo(target, overwrite = true) + source.delete() + } + } + + private fun planDigest(plan: ModMaterializationPlan): String { + val canonical = plan.files.joinToString("\n") { file -> + "${file.sourceRelativePath}|${file.targetRoot}|${file.targetRelativePath}|${file.normalizedTargetKey}|${file.mode}" + } + return MessageDigest.getInstance("SHA-256") + .digest(canonical.toByteArray(Charsets.UTF_8)) + .joinToString("") { "%02x".format(it) } + } + + internal fun sha256(file: File): String { + if (!file.isFile) return "" + val digest = MessageDigest.getInstance("SHA-256") + FileInputStream(file).use { input -> + val buffer = ByteArray(DEFAULT_BUFFER_SIZE) + while (true) { + val read = input.read(buffer) + if (read <= 0) break + digest.update(buffer, 0, read) + } + } + return digest.digest().joinToString("") { "%02x".format(it) } + } +} + +data class ModOwnershipCleanupResult( + val removed: Int, + val restored: Int, + val preserved: List, +) { + val skippedPaths: List get() = preserved.map { it.targetPath }.distinct() +} + +object ModOwnershipReconciler { + suspend fun removeOwnedFiles( + manifest: ModOwnershipManifest, + overwriteManifests: List, + targetKeys: Set = manifest.files.filter { it.active }.mapTo(mutableSetOf()) { it.normalizedTargetKey }, + restoreBackups: Boolean = true, + ): ModOwnershipCleanupResult { + val selected = manifest.files.filter { it.active && it.normalizedTargetKey in targetKeys } + val overwriteByKey = overwriteManifests.associateBy { WindowsPathIdentity.absoluteKey(File(it.targetPath)) } + val restoreCandidates = if (restoreBackups) selected.mapNotNull { overwriteByKey[it.normalizedTargetKey] } else emptyList() + val restoreSkipped = ModMaterializer.restoreBackups(restoreCandidates) + .mapTo(mutableSetOf()) { WindowsPathIdentity.absoluteKey(File(it)) } + val restoredKeys = restoreCandidates.asSequence() + .filter { it.backupPath.isNotBlank() && it.normalizedKey() !in restoreSkipped } + .mapTo(mutableSetOf()) { it.normalizedKey() } + var removed = 0 + val preserved = mutableListOf() + + val symlinkOperations = manifest.operations.filter { operation -> + val operationPath = operation.targetPath + File.separator + val ownedUnderOperation = manifest.files.filter { owned -> + owned.mode == "SYMLINK" && + (owned.normalizedTargetKey == operation.normalizedTargetKey || owned.targetPath.startsWith(operationPath)) + } + operation.mode == "SYMLINK" && ownedUnderOperation.isNotEmpty() && + ownedUnderOperation.all { it.normalizedTargetKey in targetKeys } + } + symlinkOperations.forEach { operation -> + val target = File(operation.targetPath) + val source = File(operation.sourcePath) + val link = target.toPath() + val pointsToSource = runCatching { + val raw = Files.readSymbolicLink(link) + val resolved = if (raw.isAbsolute) raw else link.parent.resolve(raw) + resolved.normalize().toFile().canonicalFile == source.canonicalFile + }.getOrDefault(false) + if (Files.isSymbolicLink(link) && pointsToSource) { + Files.deleteIfExists(link) + removed++ + } else { + preserved += selected.filter { owned -> + owned.mode == "SYMLINK" && + (owned.normalizedTargetKey == operation.normalizedTargetKey || owned.targetPath.startsWith(operation.targetPath + File.separator)) + } + } + } + + selected.filter { it.mode != "SYMLINK" }.forEach { owned -> + val overwrite = overwriteByKey[owned.normalizedTargetKey] + when { + owned.normalizedTargetKey in restoredKeys -> Unit + overwrite != null && !restoreBackups -> preserved += owned.preserved() + overwrite?.backupPath?.isBlank() == true -> Unit + owned.disposition == ModOwnedFileDisposition.SHARED -> Unit + owned.normalizedTargetKey in restoreSkipped -> preserved += owned.preserved() + else -> { + val target = File(owned.targetPath) + val currentHash = ModOwnershipStore.sha256(target) + if (target.isFile && currentHash.isNotBlank() && currentHash == owned.installedHash) { + if (target.delete()) removed++ else preserved += owned.preserved() + } else if (target.exists() || Files.isSymbolicLink(target.toPath())) { + preserved += owned.preserved() + } + } + } + } + return ModOwnershipCleanupResult(removed, restoredKeys.size, preserved.distinctBy { it.normalizedTargetKey }) + } + + private fun ModOwnedFile.preserved(): ModOwnedFile = + copy(active = false, disposition = ModOwnedFileDisposition.STALE_PRESERVED) + + private fun ModOverwriteManifest.normalizedKey(): String = WindowsPathIdentity.absoluteKey(File(targetPath)) +} diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index 24ac17b966..c59f01f3a1 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -513,16 +513,20 @@ object NexusModManager { allowOverwrite: Boolean, saveLastPlacement: Boolean = true, preserveStatusOnError: Boolean = false, + profileId: String = "", + priority: Int = 0, ): ModPlacementResult = withContext(Dispatchers.IO) { val dao = dao(context) - val existingBackupPaths = dao.getOverwriteManifests(install.installId) + val existingManifests = dao.getOverwriteManifests(install.installId) + val existingBackupPaths = existingManifests .mapNotNull { it.backupPath.takeIf(String::isNotBlank) } .toSet() + val ownershipRoot = cacheRoot(context, install.appId) + val previousOwnership = ModOwnershipStore.read(ownershipRoot, install.installId) + val plan = ModMaterializer.materializationPlan(install, recipes, gameRootDir, winePrefix) val result = ModMaterializer.apply( install = install, - recipes = recipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, + plan = plan, backupRoot = backupRoot(context, install.appId), allowOverwrite = allowOverwrite, ) @@ -530,14 +534,47 @@ object NexusModManager { if (result.manifests.isNotEmpty()) { dao.replaceOverwriteManifestsForTargets(install.installId, result.manifests) } + val newTargetKeys = plan.files.mapTo(mutableSetOf()) { it.normalizedTargetKey } + val staleKeys = previousOwnership?.files + .orEmpty() + .filter { it.active && it.normalizedTargetKey !in newTargetKeys } + .mapTo(mutableSetOf()) { it.normalizedTargetKey } + val staleCleanup = if (previousOwnership != null && staleKeys.isNotEmpty()) { + ModOwnershipReconciler.removeOwnedFiles( + manifest = previousOwnership, + overwriteManifests = existingManifests, + targetKeys = staleKeys, + ) + } else { + ModOwnershipCleanupResult(0, 0, emptyList()) + } + val safelyReconciledTargets = staleKeys - staleCleanup.preserved.mapTo(mutableSetOf()) { it.normalizedTargetKey } + if (safelyReconciledTargets.isNotEmpty()) { + val staleManifestTargets = existingManifests + .filter { WindowsPathIdentity.absoluteKey(File(it.targetPath)) in safelyReconciledTargets } + .map { it.targetPath } + if (staleManifestTargets.isNotEmpty()) { + dao.deleteOverwriteManifestsForTargets(install.installId, staleManifestTargets) + } + } + val ownership = ModOwnershipStore.create( + appId = install.appId, + plan = plan, + overwriteManifests = existingManifests + result.manifests, + profileId = profileId, + priority = priority, + preservedStale = staleCleanup.preserved, + ) + ModOwnershipStore.writePending(ownershipRoot, ownership) + ModOwnershipStore.commit(ownershipRoot, install.installId) if (install.status != ModInstallStatus.APPLIED.name) { dao.updateInstallStatus(install.installId, ModInstallStatus.APPLIED.name) } if (saveLastPlacement) saveLastPlacementForApp(install.appId, recipes) + return@withContext result.copy(warnings = staleCleanup.skippedPaths) } else if (!preserveStatusOnError && install.status != ModInstallStatus.ERROR.name) { dao.updateInstallStatus(install.installId, ModInstallStatus.ERROR.name) } - if (result.errors.isEmpty()) return@withContext result val restoreSkipped = ModMaterializer.restoreBackups(result.manifests) val restoredTargets = result.manifests @@ -580,35 +617,6 @@ object NexusModManager { winePrefix = winePrefix, ) - suspend fun cleanupBeforeRecipeReplacement( - context: Context, - install: ModInstall, - oldRecipes: List, - newRecipes: List, - gameRootDir: File?, - winePrefix: String, - ): List = withContext(Dispatchers.IO) { - if (oldRecipes.isEmpty() || samePlacementRecipes(oldRecipes, newRecipes)) return@withContext emptyList() - val dao = dao(context) - val manifests = dao.getOverwriteManifests(install.installId) - val restoreSkipped = ModMaterializer.restoreBackups(manifests) - val restoredTargets = manifests - .map { it.targetPath } - .filterNot { it in restoreSkipped } - .toSet() - val removeSkipped = ModMaterializer.removeAppliedFiles( - install = install, - recipes = oldRecipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - restoredOverwriteTargets = restoredTargets, - ) - if (restoredTargets.isNotEmpty()) { - dao.deleteOverwriteManifestsForTargets(install.installId, restoredTargets.toList()) - } - restoreSkipped + removeSkipped - } - fun lastPlacementRecipesForApp(appId: String, installId: String): List { val root = runCatching { JSONObject(PrefManager.nexusLastPlacementJson) }.getOrElse { JSONObject() } val recipes = root.optJSONArray(appId) ?: return emptyList() @@ -695,22 +703,30 @@ object NexusModManager { dao.updateInstallEnabled(install.installId, false, ModInstallStatus.DISABLED.name) return@withContext emptyList() } - val recipes = dao.getRecipesForInstall(install.installId) val manifests = dao.getOverwriteManifests(install.installId) - val skipped = if (restoreBackups) { - ModMaterializer.restoreBackups(manifests) - } else { - emptyList() + val ownershipRoot = cacheRoot(context, install.appId) + val ownership = ModOwnershipStore.read(ownershipRoot, install.installId) + if (ownership == null) { + dao.updateInstallEnabled(install.installId, false, ModInstallStatus.DISABLED.name) + return@withContext listOf("Ownership adoption is required before deployed files can be removed safely") } - val removalSkipped = ModMaterializer.removeAppliedFiles( - install = install, - recipes = recipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - restoredOverwriteTargets = manifests.map { it.targetPath }.toSet(), + val cleanup = ModOwnershipReconciler.removeOwnedFiles(ownership, manifests, restoreBackups = restoreBackups) + ModOwnershipStore.writePending( + ownershipRoot, + ownership.copy( + state = ModOwnershipState.DISABLED, + files = ownership.files.map { file -> + if (file.normalizedTargetKey in cleanup.preserved.map { it.normalizedTargetKey }.toSet()) { + cleanup.preserved.first { it.normalizedTargetKey == file.normalizedTargetKey } + } else { + file.copy(active = false) + } + }, + ), ) + ModOwnershipStore.commit(ownershipRoot, install.installId) dao.updateInstallEnabled(install.installId, false, ModInstallStatus.DISABLED.name) - skipped + removalSkipped + cleanup.skippedPaths } suspend fun deleteInstall( @@ -724,6 +740,7 @@ object NexusModManager { val dao = dao(context) dao.deleteOverwriteManifests(install.installId) dao.deleteInstall(install.installId) + ModOwnershipStore.delete(cacheRoot(context, install.appId), install.installId) if (install.archivePath.isNotBlank()) { val archiveFile = File(install.archivePath) archiveFile.delete() diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 99030ae82b..d01691b178 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -341,6 +341,7 @@ private data class ModDiagnosticsSnapshot( ) private data class ProfileOrderPlan( + val profileId: String, val stateByInstallId: Map, val disabledInstalls: List, val configuredInstalls: List, @@ -1514,6 +1515,7 @@ fun NexusModsDialog( install.installId in missingTargetRepairInstallIds } ProfileOrderPlan( + profileId = profile.profileId, stateByInstallId = stateByInstallId, disabledInstalls = disabledInstalls, configuredInstalls = configuredInstalls, @@ -1628,6 +1630,8 @@ fun NexusModsDialog( allowOverwrite = effectiveAllowOverwrite, saveLastPlacement = false, preserveStatusOnError = true, + profileId = plan.profileId, + priority = plan.stateByInstallId[install.installId]?.priority ?: 0, ) } errors += result.errors.size @@ -2801,17 +2805,7 @@ fun NexusModsDialog( allowOverwrite: Boolean, ) { loadingMessage = context.getString(R.string.nexus_applying_mod_files) - val (cleanupSkipped, result) = withContext(Dispatchers.IO) { - val oldRecipes = dao.getRecipesForInstall(install.installId) - val skipped = NexusModManager.cleanupBeforeRecipeReplacement( - context = context, - install = install, - oldRecipes = oldRecipes, - newRecipes = recipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - ) - dao.replaceRecipes(install.installId, recipes) + val result = withContext(Dispatchers.IO) { val applied = NexusModManager.applyInstall( context = context, install = install, @@ -2821,16 +2815,17 @@ fun NexusModsDialog( allowOverwrite = allowOverwrite, ) if (applied.errors.isEmpty()) { + dao.replaceRecipes(install.installId, recipes) val profile = activeProfile ?: ModProfileManager.ensureActiveProfile(dao, libraryItem.appId) val state = ModProfileManager.ensureStateForInstall(dao, profile, install.installId) dao.upsertProfileInstallState(state.copy(enabled = true, updatedAt = System.currentTimeMillis())) } - skipped to applied + applied } val message = if (result.errors.isEmpty()) { lastPlacementDrafts = recipes.map { it.toDraft() } - val cleanupSuffix = if (cleanupSkipped.isNotEmpty()) { - context.getString(R.string.nexus_old_files_left_in_place_suffix, cleanupSkipped.size) + val cleanupSuffix = if (result.warnings.isNotEmpty()) { + context.getString(R.string.nexus_old_files_left_in_place_suffix, result.warnings.size) } else { "" } diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index fe41432cff..916c769b19 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -718,6 +718,34 @@ class ModMaterializerTest { assertEquals("linked original", File(linkedDir, "Old.txt").readText()) } + @Test + fun materializationPlan_expandsEveryDirectoryFileOnce() { + File(extracted, "Data/Scripts/A.pex").apply { + parentFile?.mkdirs() + writeText("a") + } + File(extracted, "Data/Textures/B.dds").apply { + parentFile?.mkdirs() + writeText("b") + } + + val plan = ModMaterializer.materializationPlan( + install = install(), + recipes = listOf( + recipe(mode = ModPlacementMode.OVERWRITE_COPY).copy( + sourceSubpath = "Data", + targetRelativePath = "Data", + ), + ), + gameRootDir = gameDir, + winePrefix = "", + ) + + assertTrue(plan.isComplete) + assertEquals(listOf("Data/Scripts/A.pex", "Data/Textures/B.dds"), plan.files.map { it.targetRelativePath }.sorted()) + assertEquals(2, plan.files.map { it.normalizedTargetKey }.distinct().size) + } + @Test fun restoreBackups_replacesMatchingSymlinkWithoutChangingLinkDestination() = runBlocking { File(extracted, "config.ini").writeText("modded") diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt new file mode 100644 index 0000000000..13cdd9b3e9 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -0,0 +1,88 @@ +package app.gamenative.mods + +import app.gamenative.data.ModPlacementMode +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import java.io.File + +class ModOwnershipManifestTest { + @get:Rule + val temporaryFolder = TemporaryFolder() + + @Test + fun sidecarRoundTrip_andOverlayWinner_areDeterministic() { + val root = temporaryFolder.newFolder("cache") + val low = manifest("low", "Data/Scripts/X.pex", "one", priority = 10) + val high = manifest("high", "data/scripts/x.pex", "two", priority = 20) + ModOwnershipStore.writePending(root, low) + ModOwnershipStore.commit(root, low.installId) + + assertEquals(low, ModOwnershipStore.read(root, low.installId)) + val overlay = ModProfileOverlayPlanner.build(listOf(high, low), mapOf("high" to 20, "low" to 10)) + assertEquals("high", overlay.targets.values.single().winner.installId) + assertEquals(1, overlay.conflicts.size) + assertTrue(overlay.targets.values.single().hasCaseCollision) + } + + @Test + fun staleCleanup_removesOnlyUnchangedOwnedFiles() = runBlocking { + val targetRoot = temporaryFolder.newFolder("game") + val unchanged = File(targetRoot, "unchanged.txt").apply { writeText("owned") } + val modified = File(targetRoot, "modified.txt").apply { writeText("changed") } + val ownedHash = ModOwnershipStore.sha256(temporaryFolder.newFile("source.txt").apply { writeText("owned") }) + val manifest = ModOwnershipManifest( + installId = "install", + appId = "game", + planDigest = "digest", + files = listOf(unchanged, modified).map { target -> + ModOwnedFile( + sourceRelativePath = target.name, + targetRoot = "GAME_DIR", + targetRelativePath = target.name, + targetPath = target.absolutePath, + normalizedTargetKey = WindowsPathIdentity.absoluteKey(target), + mode = ModPlacementMode.COPY.name, + installedHash = ownedHash, + installedSize = 5, + installedMtime = 1, + disposition = ModOwnedFileDisposition.CREATED, + ) + }, + ) + + val result = ModOwnershipReconciler.removeOwnedFiles(manifest, emptyList()) + + assertFalse(unchanged.exists()) + assertTrue(modified.exists()) + assertEquals(listOf(modified.absolutePath), result.skippedPaths) + } + + private fun manifest(installId: String, targetPath: String, hash: String, priority: Int): ModOwnershipManifest { + val target = File("C:/Game/$targetPath") + return ModOwnershipManifest( + installId = installId, + appId = "game", + planDigest = "digest-$installId", + files = listOf( + ModOwnedFile( + sourceRelativePath = "x.pex", + targetRoot = "GAME_DIR", + targetRelativePath = targetPath, + targetPath = target.path, + normalizedTargetKey = WindowsPathIdentity.absoluteKey(target), + mode = ModPlacementMode.OVERWRITE_COPY.name, + installedHash = hash, + installedSize = 1, + installedMtime = 1, + disposition = ModOwnedFileDisposition.OVERWROTE, + priority = priority, + ), + ), + ) + } +} From a29a89868d393449c05ae04c5c165898850364bb Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 12:34:44 -0500 Subject: [PATCH 15/60] feat: evaluate installer environment facts --- .../mods/AutomaticPlacementPlanner.kt | 33 ++++- .../app/gamenative/mods/FomodAutoSelector.kt | 4 + .../app/gamenative/mods/FomodEnvironment.kt | 115 ++++++++++++++++++ .../gamenative/mods/FomodInstallPlanner.kt | 30 ++++- .../app/gamenative/mods/FomodInstaller.kt | 101 ++++++++++++--- .../mods/GenericOptionSetDetector.kt | 63 ++++++++++ .../app/gamenative/mods/ModArchiveIndex.kt | 2 +- .../ui/component/dialog/NexusModsDialog.kt | 28 ++++- .../dialog/NexusModsFomodSections.kt | 15 ++- .../dialog/NexusModsPlacementSections.kt | 3 + .../mods/AutomaticPlacementPlannerTest.kt | 28 +++++ .../gamenative/mods/FomodEnvironmentTest.kt | 51 ++++++++ .../app/gamenative/mods/FomodInstallerTest.kt | 6 + 13 files changed, 447 insertions(+), 32 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/FomodEnvironment.kt create mode 100644 app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt create mode 100644 app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index d9243652e5..adf023d513 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -17,6 +17,7 @@ data class AutomaticPlacementCandidate( data class AutomaticPlacementResult( val candidates: List, val recommended: AutomaticPlacementCandidate?, + val optionGroups: List = emptyList(), ) object AutomaticPlacementPlanner { @@ -42,6 +43,7 @@ object AutomaticPlacementPlanner { fun plan(gameName: String, entries: List): AutomaticPlacementResult { val index = ModArchiveIndex.build(entries) + val optionGroups = GenericOptionSetDetector.detect(index) val legacy = ModPlacementPresetDetector.detect(gameName, entries).map { preset -> candidateFromDrafts( id = "legacy:${preset.id}", @@ -65,14 +67,28 @@ object AutomaticPlacementPlanner { ) val baseline = legacy.firstOrNull() val bestGenerated = generated.maxWithOrNull(compareBy { it.score }.thenBy { it.id }) - val recommended = when { + val recommendedBase = when { bestGenerated == null -> baseline baseline == null -> bestGenerated PlacementPlanRegressionPolicy.canReplace(baseline.plan, bestGenerated.plan) && preservesExistingDestinations(baseline.plan, bestGenerated.plan) -> bestGenerated else -> baseline } - return AutomaticPlacementResult(ranked, recommended) + val optionMessage = optionGroups.firstOrNull()?.let { group -> + "Choose one package variant: ${group.choices.joinToString { it.sourceDirectory }}" + } + val reviewed = if (optionMessage == null) { + ranked + } else { + ranked.map { candidate -> + candidate.copy( + plan = candidate.plan.copy(blockingIssues = (candidate.plan.blockingIssues + optionMessage).distinct()), + evidence = candidate.evidence + optionMessage, + ) + } + } + val recommended = recommendedBase?.let { base -> reviewed.firstOrNull { it.id == base.id } } + return AutomaticPlacementResult(reviewed, recommended, optionGroups) } fun inferIncludeSourceDirectory( @@ -106,7 +122,7 @@ object AutomaticPlacementPlanner { mode = ModPlacementMode.OVERWRITE_COPY.name, includeSourceDirectory = false, ), - ) + ) + riskyGameRootDrafts(index) } else { val sources = index.files.mapNotNull(::bethesdaSourceForFile).distinctBy { it.lowercase(Locale.ROOT) } if (sources.isEmpty()) return null @@ -137,6 +153,17 @@ object AutomaticPlacementPlanner { ) } + private fun riskyGameRootDrafts(index: ModArchiveIndex): List = + index.files.filter { it.role == ArchiveContentRole.RISKY_ROOT && '/' !in it.displayPath } + .map { file -> + ModPlacementPresetDraft( + sourceSubpath = file.displayPath, + targetRelativePath = "", + mode = ModPlacementMode.OVERWRITE_COPY.name, + includeSourceDirectory = false, + ) + } + private fun bethesdaSourceForFile(file: IndexedArchiveFile): String? { if (file.role != ArchiveContentRole.INSTALLABLE) return null val segments = file.displayPath.split('/') diff --git a/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt b/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt index 6955184f5d..c9302aa472 100644 --- a/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt +++ b/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt @@ -16,11 +16,14 @@ object FomodAutoSelector { installer: FomodInstaller, targetRoot: String = ModTargetRoot.GAME_DIR.name, targetRelativePath: String = "Data", + environment: FomodEnvironmentSnapshot = FomodEnvironmentSnapshot(), ): FomodAutoSelectionResult? { if (installer.unsupportedWarnings.isNotEmpty()) return null if (installer.steps.any { step -> step.groups.any { group -> group.plugins.any { it.typePatterns.isNotEmpty() } } }) { return null } + if (installer.moduleDependencies.evaluate(emptyMap(), environment) != FomodFactState.TRUE) return null + if (installer.conditionalFileInstalls.any { it.dependencies.evaluate(emptyMap(), environment) == FomodFactState.UNKNOWN }) return null val selectedKeys = linkedSetOf() val selectedLabels = mutableListOf() @@ -65,6 +68,7 @@ object FomodAutoSelector { targetRoot = targetRoot, targetRelativePath = targetRelativePath, mode = ModPlacementMode.OVERWRITE_COPY.name, + environment = environment, ) if (result.unsupportedMappings.isNotEmpty()) return null if (result.recipes.isEmpty()) return null diff --git a/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt new file mode 100644 index 0000000000..f901f62435 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt @@ -0,0 +1,115 @@ +package app.gamenative.mods + +import java.io.File +import java.util.Locale + +data class FomodEnvironmentSnapshot( + val gameName: String = "", + val gameVersion: String? = null, + val fileFacts: Map = emptyMap(), + val presentPlugins: Set = emptySet(), + val activePlugins: Set = emptySet(), +) { + fun evaluate(dependency: FomodFileDependency): FomodFactState { + val key = dependency.file.normalizedFactKey() + val present = fileFacts[key] ?: return FomodFactState.UNKNOWN + val pluginName = dependency.file.substringAfterLast('/').lowercase(Locale.ROOT) + val isPlugin = pluginName.substringAfterLast('.', "") in setOf("esp", "esm", "esl") + val active = pluginName in activePlugins + return requiredState(dependency.state, present, active, isPlugin) + } + + fun evaluate(dependency: FomodPluginDependency): FomodFactState { + val key = dependency.plugin.substringAfterLast('/').lowercase(Locale.ROOT) + val present = when { + key in activePlugins -> true + key in presentPlugins -> true + presentPlugins.isNotEmpty() -> false + else -> return FomodFactState.UNKNOWN + } + return requiredState(dependency.state, present, key in activePlugins, isPlugin = true) + } + + fun evaluate(dependency: FomodGameDependency): FomodFactState { + val current = gameVersion ?: return FomodFactState.UNKNOWN + return if (compareVersions(current, dependency.version) >= 0) FomodFactState.TRUE else FomodFactState.FALSE + } + + private fun requiredState( + state: FomodRequiredFileState, + present: Boolean, + active: Boolean, + isPlugin: Boolean, + ): FomodFactState = + when (state) { + FomodRequiredFileState.ACTIVE -> if (present && (!isPlugin || active)) FomodFactState.TRUE else FomodFactState.FALSE + FomodRequiredFileState.INACTIVE -> if (present && isPlugin && !active) FomodFactState.TRUE else FomodFactState.FALSE + FomodRequiredFileState.MISSING -> if (!present) FomodFactState.TRUE else FomodFactState.FALSE + } + + private fun compareVersions(left: String, right: String): Int { + val leftParts = left.versionParts() + val rightParts = right.versionParts() + repeat(maxOf(leftParts.size, rightParts.size)) { index -> + val comparison = (leftParts.getOrElse(index) { 0 }).compareTo(rightParts.getOrElse(index) { 0 }) + if (comparison != 0) return comparison + } + return 0 + } + + private fun String.versionParts(): List = + split(Regex("[^0-9]+")).filter(String::isNotBlank).mapNotNull(String::toIntOrNull) +} + +object FomodEnvironmentSnapshotBuilder { + fun build( + installer: FomodInstaller, + gameName: String, + gameRootDir: File?, + pluginsFile: File? = null, + gameVersion: String? = null, + ): FomodEnvironmentSnapshot { + val requestedFiles = installer.dependencyExpressions() + .flatMap { it.fileDependencies } + .map { it.file } + .distinctBy { it.normalizedFactKey() } + val requestedPlugins = installer.dependencyExpressions() + .flatMap { it.pluginDependencies } + .map { it.plugin } + .distinctBy { it.lowercase(Locale.ROOT) } + val fileFacts = if (gameRootDir == null) { + emptyMap() + } else { + requestedFiles.associate { requested -> + requested.normalizedFactKey() to resolveRequestedFile(gameRootDir, requested).isFile + } + } + val presentPlugins = (requestedFiles + requestedPlugins).asSequence() + .filter { it.substringAfterLast('.').lowercase(Locale.ROOT) in setOf("esp", "esm", "esl") } + .filter { requested -> + fileFacts[requested.normalizedFactKey()] == true || + (gameRootDir != null && resolveRequestedFile(gameRootDir, requested).isFile) + } + .mapTo(mutableSetOf()) { it.substringAfterLast('/').lowercase(Locale.ROOT) } + val activePlugins = pluginsFile?.takeIf(File::isFile)?.readLines().orEmpty() + .map { it.trim().removePrefix("*").substringBefore('#').trim().lowercase(Locale.ROOT) } + .filterTo(mutableSetOf(), String::isNotBlank) + return FomodEnvironmentSnapshot(gameName, gameVersion, fileFacts, presentPlugins, activePlugins) + } + + private fun resolveRequestedFile(gameRootDir: File?, requested: String): File { + val root = gameRootDir ?: return File("") + val relative = normalizeArchiveDisplayPath(requested) + return listOf(relative, "Data/$relative") + .mapNotNull { candidate -> ModTargetResolver.resolveWithin(root, candidate) } + .firstOrNull { it.exists() } + ?: File(root, relative) + } +} + +private fun FomodInstaller.dependencyExpressions(): List = + listOf(moduleDependencies) + conditionalFileInstalls.map { it.dependencies } + + steps.flatMap { it.groups }.flatMap { it.plugins }.flatMap { it.typePatterns }.map { it.dependencies } + +private fun String.normalizedFactKey(): String = + normalizeArchiveDisplayPath(this).lowercase(Locale.ROOT) diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 5c3e929f79..5499595423 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -17,8 +17,12 @@ data class FomodSelectionEvaluation( ) object FomodSelectionEvaluator { - fun evaluate(installer: FomodInstaller, selectedPluginKeys: Set): FomodSelectionEvaluation { - val selectedPlugins = FomodRecipeGenerator.selectedPluginsForKeys(installer, selectedPluginKeys) + fun evaluate( + installer: FomodInstaller, + selectedPluginKeys: Set, + environment: FomodEnvironmentSnapshot = FomodEnvironmentSnapshot(), + ): FomodSelectionEvaluation { + val selectedPlugins = FomodRecipeGenerator.selectedPluginsForKeys(installer, selectedPluginKeys, environment) val flags = linkedMapOf() selectedPlugins.forEach { plugin -> plugin.conditionFlags.forEach { (name, value) -> flags[name] = value } } var ordinal = 0 @@ -32,7 +36,7 @@ object FomodSelectionEvaluator { } } installer.conditionalFileInstalls.forEach { conditional -> - if (conditional.dependencies.unsupportedCount() == 0 && conditional.dependencies.matches(flags)) { + if (conditional.dependencies.evaluate(flags, environment) == FomodFactState.TRUE) { conditional.files.forEach { mapping -> add(FomodExpectedMapping(mapping, PlacementOrigin.FOMOD_CONDITIONAL, ordinal++)) } @@ -41,6 +45,16 @@ object FomodSelectionEvaluator { } val blockers = buildList { addAll(installer.unsupportedWarnings) + when (installer.moduleDependencies.evaluate(flags, environment)) { + FomodFactState.FALSE -> add("The installed game does not satisfy this FOMOD's requirements") + FomodFactState.UNKNOWN -> if (installer.moduleDependencies.hasFacts()) { + add("FOMOD game requirements could not be determined safely") + } + FomodFactState.TRUE -> Unit + } + if (installer.conditionalFileInstalls.any { it.dependencies.evaluate(flags, environment) == FomodFactState.UNKNOWN }) { + add("A selected FOMOD conditional depends on unknown game facts") + } if (installer.conditionalFileInstalls.any { it.dependencies.unsupportedCount() > 0 }) { add("A selected FOMOD conditional uses unsupported dependencies") } @@ -50,9 +64,19 @@ object FomodSelectionEvaluator { ) { add("FOMOD option availability depends on unsupported game facts") } + if ( + installer.steps.flatMap { it.groups }.flatMap { it.plugins }.flatMap { it.typePatterns } + .any { it.dependencies.evaluate(flags, environment) == FomodFactState.UNKNOWN } + ) { + add("FOMOD option availability depends on unknown game facts") + } } return FomodSelectionEvaluation(expected, flags, blockers.distinct()) } + + private fun FomodDependencyExpression.hasFacts(): Boolean = + flagDependencies.isNotEmpty() || fileDependencies.isNotEmpty() || pluginDependencies.isNotEmpty() || + gameDependencies.isNotEmpty() || childGroups.isNotEmpty() || unsupportedDependencyCount > 0 } object FomodPlanExpander { diff --git a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt index 631013bc31..a5bd2de8d6 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt @@ -15,6 +15,7 @@ data class FomodInstaller( val requiredFiles: List, val steps: List, val conditionalFileInstalls: List = emptyList(), + val moduleDependencies: FomodDependencyExpression = FomodDependencyExpression(), val unsupportedWarnings: List = emptyList(), val basePath: String = "", ) @@ -60,18 +61,40 @@ data class FomodTypePattern( data class FomodDependencyExpression( val operator: FomodDependencyOperator = FomodDependencyOperator.AND, val flagDependencies: List = emptyList(), + val fileDependencies: List = emptyList(), + val pluginDependencies: List = emptyList(), + val gameDependencies: List = emptyList(), val childGroups: List = emptyList(), val unsupportedDependencyCount: Int = 0, ) { - fun matches(flags: Map): Boolean { + fun matches(flags: Map): Boolean = + evaluate(flags, FomodEnvironmentSnapshot()) == FomodFactState.TRUE + + fun evaluate(flags: Map, environment: FomodEnvironmentSnapshot): FomodFactState { val results = flagDependencies.map { dependency -> - flags[dependency.flag]?.equals(dependency.value, ignoreCase = true) == true - } + childGroups.map { it.matches(flags) } + if (flags[dependency.flag]?.equals(dependency.value, ignoreCase = true) == true) { + FomodFactState.TRUE + } else { + FomodFactState.FALSE + } + } + fileDependencies.map(environment::evaluate) + + pluginDependencies.map(environment::evaluate) + + gameDependencies.map(environment::evaluate) + + childGroups.map { it.evaluate(flags, environment) } + + List(unsupportedDependencyCount) { FomodFactState.UNKNOWN } - if (results.isEmpty()) return unsupportedDependencyCount == 0 + if (results.isEmpty()) return FomodFactState.TRUE return when (operator) { - FomodDependencyOperator.AND -> unsupportedDependencyCount == 0 && results.all { it } - FomodDependencyOperator.OR -> results.any { it } + FomodDependencyOperator.AND -> when { + FomodFactState.FALSE in results -> FomodFactState.FALSE + FomodFactState.UNKNOWN in results -> FomodFactState.UNKNOWN + else -> FomodFactState.TRUE + } + FomodDependencyOperator.OR -> when { + FomodFactState.TRUE in results -> FomodFactState.TRUE + FomodFactState.UNKNOWN in results -> FomodFactState.UNKNOWN + else -> FomodFactState.FALSE + } } } @@ -104,8 +127,12 @@ enum class FomodPluginType { COULD_BE_USABLE, } -fun FomodPlugin.effectiveType(flags: Map): FomodPluginType = - typePatterns.firstOrNull { it.dependencies.matches(flags) }?.type ?: type +fun FomodPlugin.effectiveType( + flags: Map, + environment: FomodEnvironmentSnapshot = FomodEnvironmentSnapshot(), +): FomodPluginType = typePatterns.firstOrNull { + it.dependencies.evaluate(flags, environment) == FomodFactState.TRUE +}?.type ?: type data class FomodRecipeGenerationResult( val recipes: List, @@ -114,6 +141,16 @@ data class FomodRecipeGenerationResult( val blockingIssues: List = emptyList(), ) +data class FomodFileDependency(val file: String, val state: FomodRequiredFileState) + +data class FomodPluginDependency(val plugin: String, val state: FomodRequiredFileState) + +data class FomodGameDependency(val version: String) + +enum class FomodRequiredFileState { ACTIVE, INACTIVE, MISSING } + +enum class FomodFactState { TRUE, FALSE, UNKNOWN } + object FomodInstallerDetector { fun moduleConfigFile(extractedRoot: File): File? = extractedRoot.childIgnoreCase("fomod")?.childIgnoreCase("ModuleConfig.xml")?.takeIf { it.isFile } @@ -157,6 +194,7 @@ object FomodParser { ?.childElements("pattern") ?.mapNotNull { parseConditionalPattern(it) } .orEmpty() + val moduleDependencies = parseDependencies(root.firstChildElement("moduleDependencies")) val steps = root.firstChildElement("installSteps") ?.childElements("installStep") ?.map { step -> @@ -178,13 +216,14 @@ object FomodParser { ) } .orEmpty() - unsupported += unsupportedFeatureWarnings(root, conditionalFileInstalls, steps) + unsupported += unsupportedFeatureWarnings(root, moduleDependencies, conditionalFileInstalls, steps) return FomodInstaller( moduleName = root.firstChildElement("moduleName")?.textContent?.trim().orEmpty(), requiredFiles = root.firstChildElement("requiredInstallFiles")?.fileMappings().orEmpty(), steps = steps, conditionalFileInstalls = conditionalFileInstalls, + moduleDependencies = moduleDependencies, unsupportedWarnings = unsupported, basePath = basePath, ) @@ -223,6 +262,9 @@ object FomodParser { private fun parseDependencies(dependencies: Element?): FomodDependencyExpression { if (dependencies == null) return FomodDependencyExpression() val flagDependencies = mutableListOf() + val fileDependencies = mutableListOf() + val pluginDependencies = mutableListOf() + val gameDependencies = mutableListOf() val childGroups = mutableListOf() var unsupportedCount = 0 @@ -233,6 +275,20 @@ object FomodParser { val value = child.attr("value").trim() if (flag.isBlank()) unsupportedCount++ else flagDependencies += FomodFlagDependency(flag, value) } + child.tagName.equals("fileDependency", ignoreCase = true) -> { + val file = child.attr("file").trim().replace('\\', '/') + if (file.isBlank()) unsupportedCount++ else fileDependencies += + FomodFileDependency(file, requiredFileState(child.attr("state"))) + } + child.tagName.equals("pluginDependency", ignoreCase = true) -> { + val plugin = child.attr("plugin").ifBlank { child.attr("file") }.trim() + if (plugin.isBlank()) unsupportedCount++ else pluginDependencies += + FomodPluginDependency(plugin, requiredFileState(child.attr("state"))) + } + child.tagName.equals("gameDependency", ignoreCase = true) -> { + val version = child.attr("version").trim() + if (version.isBlank()) unsupportedCount++ else gameDependencies += FomodGameDependency(version) + } child.tagName.equals("dependencies", ignoreCase = true) -> childGroups += parseDependencies(child) child.tagName.endsWith("Dependency", ignoreCase = true) -> unsupportedCount++ } @@ -241,6 +297,9 @@ object FomodParser { return FomodDependencyExpression( operator = dependencyOperator(dependencies.attr("operator")), flagDependencies = flagDependencies, + fileDependencies = fileDependencies, + pluginDependencies = pluginDependencies, + gameDependencies = gameDependencies, childGroups = childGroups, unsupportedDependencyCount = unsupportedCount, ) @@ -272,6 +331,12 @@ object FomodParser { else -> FomodDependencyOperator.AND } + private fun requiredFileState(value: String): FomodRequiredFileState = when (value.lowercase()) { + "inactive" -> FomodRequiredFileState.INACTIVE + "missing" -> FomodRequiredFileState.MISSING + else -> FomodRequiredFileState.ACTIVE + } + private fun pluginType(typeDescriptor: Element?): FomodPluginType { val direct = typeDescriptor?.firstChildElement("type")?.attr("name") val default = typeDescriptor @@ -376,9 +441,10 @@ object FomodRecipeGenerator { targetRelativePath: String = "Data", mode: String = ModPlacementMode.OVERWRITE_COPY.name, extractedRoot: File? = null, + environment: FomodEnvironmentSnapshot = FomodEnvironmentSnapshot(), ): FomodRecipeGenerationResult { if (extractedRoot != null) { - val evaluation = FomodSelectionEvaluator.evaluate(installer, selectedPluginKeys) + val evaluation = FomodSelectionEvaluator.evaluate(installer, selectedPluginKeys, environment) val plan = FomodPlanExpander.expand(installer, evaluation, extractedRoot, targetRoot, targetRelativePath) val recipes = plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { file -> val destination = file.targetRelativePath.orEmpty() @@ -399,7 +465,7 @@ object FomodRecipeGenerator { blockingIssues = plan.blockingIssues, ) } - val selectedPlugins = selectedPluginsForKeys(installer, selectedPluginKeys) + val selectedPlugins = selectedPluginsForKeys(installer, selectedPluginKeys, environment) val selectedFiles = selectedFiles(installer, selectedPlugins) return generateFromFiles(installId, installer.basePath, selectedFiles, targetRoot, targetRelativePath, mode) @@ -408,6 +474,7 @@ object FomodRecipeGenerator { fun selectedPluginsForKeys( installer: FomodInstaller, selectedPluginKeys: Set, + environment: FomodEnvironmentSnapshot = FomodEnvironmentSnapshot(), ): List { val pluginEntries = installer.steps.flatMapIndexed { stepIndex, step -> step.groups.flatMapIndexed { groupIndex, group -> @@ -426,7 +493,7 @@ object FomodRecipeGenerator { .flatMap { (_, plugin) -> plugin.conditionFlags.entries } .associate { it.key to it.value } val requiredKeys = pluginEntries - .filter { (_, plugin) -> plugin.effectiveType(flags) == FomodPluginType.REQUIRED } + .filter { (_, plugin) -> plugin.effectiveType(flags, environment) == FomodPluginType.REQUIRED } .mapTo(mutableSetOf()) { it.first } val next = includedKeys + requiredKeys if (next == includedKeys) break @@ -438,7 +505,7 @@ object FomodRecipeGenerator { .flatMap { (_, plugin) -> plugin.conditionFlags.entries } .associate { it.key to it.value } return pluginEntries.mapNotNull { (key, plugin) -> - val effectiveType = plugin.effectiveType(finalFlags) + val effectiveType = plugin.effectiveType(finalFlags, environment) if (effectiveType == FomodPluginType.REQUIRED || (key in selectedPluginKeys && effectiveType != FomodPluginType.NOT_USABLE)) { plugin } else { @@ -514,6 +581,7 @@ object FomodRecipeGenerator { private fun unsupportedFeatureWarnings( root: Element, + moduleDependencies: FomodDependencyExpression, conditionalFileInstalls: List, steps: List, ): List = @@ -534,11 +602,8 @@ private fun unsupportedFeatureWarnings( if (unsupportedTypeRules > 0) { add("Some FOMOD option availability rules need manual review") } - if (root.getElementsByTagName("moduleDependencies").length > 0) { - add("FOMOD module dependency rules need manual placement") - } - if (root.getElementsByTagName("fileDependency").length > 0) { - add("Some FOMOD file dependency rules need manual placement") + if (moduleDependencies.unsupportedCount() > 0) { + add("Some FOMOD module requirements need manual review") } }.distinct() diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt new file mode 100644 index 0000000000..cb85cc247c --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -0,0 +1,63 @@ +package app.gamenative.mods + +import java.util.Locale + +data class GenericOptionChoice( + val sourceDirectory: String, + val overlappingTargetCount: Int, +) + +data class GenericOptionGroup( + val choices: List, + val commonSourceDirectories: List, + val reason: String, +) + +object GenericOptionSetDetector { + fun detect(index: ModArchiveIndex): List { + if (index.hasFomod) return emptyList() + val roots = index.nodes.filter { '/' !in it.displayPath && it.descendantFileCount > 0 } + val signatures = roots.associateWith { root -> + index.filesUnder(root.displayPath).mapTo(mutableSetOf()) { file -> + file.normalizedKey.removePrefix("${root.normalizedKey}/") + } + } + val related = roots.associateWith { root -> + roots.filter { other -> + if (root == other) return@filter false + val overlap = signatures.getValue(root).intersect(signatures.getValue(other)).size + val smaller = minOf(signatures.getValue(root).size, signatures.getValue(other).size).coerceAtLeast(1) + overlap > 0 && (overlap.toDouble() / smaller >= 0.6 || root.optionStyleWrapper || other.optionStyleWrapper) + } + } + val visited = mutableSetOf() + val groups = mutableListOf>() + roots.forEach { root -> + if (!visited.add(root.normalizedKey)) return@forEach + val component = mutableListOf(root) + val queue = ArrayDeque(related.getValue(root)) + while (queue.isNotEmpty()) { + val next = queue.removeFirst() + if (!visited.add(next.normalizedKey)) continue + component += next + queue.addAll(related.getValue(next)) + } + if (component.size > 1) groups += component + } + val optionRootKeys = groups.flatten().mapTo(mutableSetOf()) { it.normalizedKey } + val common = roots.filter { it.normalizedKey !in optionRootKeys }.map { it.displayPath }.sorted() + return groups.map { choices -> + GenericOptionGroup( + choices = choices.sortedBy { it.normalizedKey }.map { root -> + val peers = choices.filter { it != root } + GenericOptionChoice( + sourceDirectory = root.displayPath, + overlappingTargetCount = peers.maxOfOrNull { signatures.getValue(root).intersect(signatures.getValue(it)).size } ?: 0, + ) + }, + commonSourceDirectories = common, + reason = "Sibling folders contain competing files for the same normalized targets", + ) + }.sortedBy { it.choices.first().sourceDirectory.lowercase(Locale.ROOT) } + } +} diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index 92a31dfd9a..2e1cd8056e 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -129,7 +129,7 @@ data class ModArchiveIndex( ) { return ArchiveContentRole.DOCUMENTATION } - if (!normalized.contains('/') && listOf(".exe", ".bat", ".cmd", ".ps1", ".msi").any(name::endsWith)) { + if (!normalized.contains('/') && listOf(".dll", ".asi", ".exe", ".ini", ".bat", ".cmd", ".ps1", ".msi").any(name::endsWith)) { return ArchiveContentRole.RISKY_ROOT } return ArchiveContentRole.INSTALLABLE diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index d01691b178..6f106abd5b 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -86,6 +86,8 @@ import app.gamenative.mods.AuthorizedNexusWebsiteDownload import app.gamenative.mods.AutomaticPlacementPlanner import app.gamenative.mods.BrowserFirstNexusWebsiteDownload import app.gamenative.mods.FomodInstaller +import app.gamenative.mods.FomodEnvironmentSnapshot +import app.gamenative.mods.FomodEnvironmentSnapshotBuilder import app.gamenative.mods.FomodAutoSelector import app.gamenative.mods.FomodInstallerDetector import app.gamenative.mods.FomodParser @@ -734,6 +736,7 @@ fun NexusModsDialog( var selectedInstall by remember { mutableStateOf(null) } var archiveEntries by remember { mutableStateOf>(emptyList()) } var selectedFomodInstaller by remember { mutableStateOf(null) } + var fomodEnvironment by remember { mutableStateOf(FomodEnvironmentSnapshot()) } var conflictReports by remember { mutableStateOf>(emptyList()) } var placementNeededInstallIds by remember { mutableStateOf>(emptySet()) } var bethesdaGame by remember(libraryItem.name) { mutableStateOf(BethesdaPluginManager.detectGame(libraryItem.name)) } @@ -1729,17 +1732,31 @@ fun NexusModsDialog( if (install == null || !install.canPlaceFiles()) { archiveEntries = emptyList() selectedFomodInstaller = null + fomodEnvironment = FomodEnvironmentSnapshot() return } scope.launch { - val (entries, fomodInstaller) = withContext(Dispatchers.IO) { + val (entries, fomodInstaller, environment) = withContext(Dispatchers.IO) { val extractedRoot = File(install.extractedPath) val parsedFomod = FomodInstallerDetector.moduleConfigFile(extractedRoot) ?.let { runCatching { FomodParser.parse(it, extractedRoot) }.getOrNull() } - NexusModManager.archiveEntries(install) to parsedFomod + val game = BethesdaPluginManager.detectGame(libraryItem.name) + Triple( + NexusModManager.archiveEntries(install), + parsedFomod, + parsedFomod?.let { installer -> + FomodEnvironmentSnapshotBuilder.build( + installer = installer, + gameName = libraryItem.name, + gameRootDir = gameRootDir, + pluginsFile = game?.let { BethesdaPluginManager.pluginsFile(winePrefix, it) }, + ) + } ?: FomodEnvironmentSnapshot(), + ) } archiveEntries = entries selectedFomodInstaller = fomodInstaller + fomodEnvironment = environment if (placementChoice == PlacementChoice.AUTOMATIC && install.canPlaceFiles()) { recipeDrafts.clear() recipeDrafts += automaticDraftsFor(libraryItem.name, entries, defaultDraft) @@ -2387,6 +2404,12 @@ fun NexusModsDialog( installId = install.installId, installer = installer, targetRelativePath = game.dataDirName, + environment = FomodEnvironmentSnapshotBuilder.build( + installer = installer, + gameName = libraryItem.name, + gameRootDir = gameRootDir, + pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game), + ), ) } } @@ -3202,6 +3225,7 @@ fun NexusModsDialog( install = install, entries = archiveEntries, fomodInstaller = selectedFomodInstaller, + fomodEnvironment = fomodEnvironment, roots = roots, drafts = recipeDrafts, presetOptions = presetOptions, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index ef83e9995f..708d6e182f 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -48,6 +48,7 @@ import androidx.compose.ui.window.DialogProperties import app.gamenative.R import app.gamenative.data.ModPlacementMode import app.gamenative.mods.FomodGroupType +import app.gamenative.mods.FomodEnvironmentSnapshot import app.gamenative.mods.FomodInstaller import app.gamenative.mods.FomodPluginType import app.gamenative.mods.FomodRecipeGenerator @@ -98,6 +99,7 @@ internal fun FomodSummarySection( internal fun FomodWizardDialog( installId: String, installer: FomodInstaller, + environment: FomodEnvironmentSnapshot, extractedRoot: File, baseDraft: RecipeDraft, onApply: (List, Int) -> Unit, @@ -156,7 +158,7 @@ internal fun FomodWizardDialog( val fallbackStepNames = installer.steps.indices.map { index -> stringResource(R.string.nexus_fomod_step, index + 1) } - val invalidGroups = fomodInvalidGroups(installer, selectedByGroup, selectedFlags, fallbackStepNames) + val invalidGroups = fomodInvalidGroups(installer, selectedByGroup, selectedFlags, fallbackStepNames, environment) Dialog( onDismissRequest = onDismiss, @@ -220,7 +222,7 @@ internal fun FomodWizardDialog( group.plugins.forEachIndexed { pluginIndex, plugin -> val pluginKey = FomodRecipeGenerator.pluginKey(stepIndex, groupIndex, pluginIndex) val selected = selectedByGroup[groupKey].orEmpty() - val effectiveType = plugin.effectiveType(selectedFlags) + val effectiveType = plugin.effectiveType(selectedFlags, environment) val checked = effectiveType == FomodPluginType.REQUIRED || (effectiveType != FomodPluginType.NOT_USABLE && pluginKey in selected) val enabled = effectiveType != FomodPluginType.REQUIRED && effectiveType != FomodPluginType.NOT_USABLE Row( @@ -290,13 +292,14 @@ internal fun FomodWizardDialog( targetRelativePath = baseDraft.targetRelativePath.ifBlank { "Data" }, mode = ModPlacementMode.OVERWRITE_COPY.name, extractedRoot = extractedRoot, + environment = environment, ) pendingResult = PendingFomodResult( drafts = result.recipes.map { it.toDraft() }, unsupportedCount = result.plan?.let { plan -> plan.unresolvedCount + plan.blockingIssues.size } ?: (result.unsupportedMappings.size + result.blockingIssues.size), - selectedOptions = fomodSelectedOptionLabels(installer, selectedKeys, fallbackStepNames), + selectedOptions = fomodSelectedOptionLabels(installer, selectedKeys, fallbackStepNames, environment), conditionalRuleCount = installer.conditionalFileInstalls.size, ) }, @@ -433,13 +436,14 @@ private fun fomodInvalidGroups( selectedByGroup: Map>, flags: Map, fallbackStepNames: List, + environment: FomodEnvironmentSnapshot, ): List = buildList { installer.steps.forEachIndexed { stepIndex, step -> step.groups.forEachIndexed { groupIndex, group -> val selected = selectedByGroup["$stepIndex:$groupIndex"].orEmpty() val selectable = group.plugins.mapIndexedNotNull { pluginIndex, plugin -> - if (plugin.effectiveType(flags) == FomodPluginType.NOT_USABLE) null else FomodRecipeGenerator.pluginKey(stepIndex, groupIndex, pluginIndex) + if (plugin.effectiveType(flags, environment) == FomodPluginType.NOT_USABLE) null else FomodRecipeGenerator.pluginKey(stepIndex, groupIndex, pluginIndex) }.toSet() val selectedUsable = selected.intersect(selectable) val invalid = when (group.type) { @@ -477,9 +481,10 @@ private fun fomodSelectedOptionLabels( installer: FomodInstaller, selectedKeys: Set, fallbackStepNames: List, + environment: FomodEnvironmentSnapshot, ): List = buildList { - val selectedPlugins = FomodRecipeGenerator.selectedPluginsForKeys(installer, selectedKeys).toSet() + val selectedPlugins = FomodRecipeGenerator.selectedPluginsForKeys(installer, selectedKeys, environment).toSet() installer.steps.forEachIndexed { stepIndex, step -> step.groups.forEachIndexed { groupIndex, group -> group.plugins.forEachIndexed { pluginIndex, plugin -> diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 825074e28f..213deda80f 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -71,6 +71,7 @@ import app.gamenative.data.ModTargetRoot import app.gamenative.mods.AutomaticPlacementPlanner import app.gamenative.mods.AutomaticPlacementResult import app.gamenative.mods.FomodInstaller +import app.gamenative.mods.FomodEnvironmentSnapshot import app.gamenative.mods.ModArchiveEntry import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.ModPlacementPreset @@ -113,6 +114,7 @@ internal fun PlacementSection( install: ModInstall, entries: List, fomodInstaller: FomodInstaller?, + fomodEnvironment: FomodEnvironmentSnapshot, roots: List, drafts: List, presetOptions: List, @@ -316,6 +318,7 @@ internal fun PlacementSection( FomodWizardDialog( installId = install.installId, installer = fomodInstaller, + environment = fomodEnvironment, extractedRoot = File(install.extractedPath), baseDraft = drafts.firstOrNull() ?: RecipeDraft(), onApply = { generatedDrafts, unsupportedCount -> diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index e142b712d9..87dd7c1636 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -59,6 +59,34 @@ class AutomaticPlacementPlannerTest { assertFalse(AutomaticPlacementPlanner.inferIncludeSourceDirectory(listOf("Data"), archive("Data/file.txt"), "Data")) } + @Test + fun ambiguousStructuralVariants_blockAutomaticChoiceAndKeepCommonFolderVisible() { + val result = AutomaticPlacementPlanner.plan( + "Skyrim Special Edition", + archive("Option A/Data/textures/x.dds", "Option B/Data/textures/x.dds", "Common/Data/scripts/y.pex"), + ) + + assertEquals(setOf("Option A", "Option B"), result.optionGroups.single().choices.map { it.sourceDirectory }.toSet()) + assertEquals(listOf("Common"), result.optionGroups.single().commonSourceDirectories) + assertFalse(result.recommended!!.plan.isComplete) + assertTrue(result.recommended!!.plan.blockingIssues.any { "variant" in it.lowercase() }) + } + + @Test + fun mixedDataAndRootBinary_areSeparatedAndRootBinaryRequiresReview() { + val plan = AutomaticPlacementPlanner.plan( + "Skyrim Special Edition", + archive("Data/Scripts/x.pex", "dinput8.dll"), + ).recommended!!.plan + + assertEquals( + setOf("Data/Scripts/x.pex", "dinput8.dll"), + plan.files.filter { it.status == PlannedFileStatus.PLACED }.mapNotNull { it.targetRelativePath }.toSet(), + ) + assertFalse(plan.isComplete) + assertEquals(PlacementRisk.UNSAFE, plan.files.single { it.sourceRelativePath == "dinput8.dll" }.risk) + } + private fun archive(vararg paths: String): List = paths.map { ModArchiveEntry(it, directory = false, sizeBytes = 1L) } } diff --git a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt new file mode 100644 index 0000000000..32060f8bc7 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt @@ -0,0 +1,51 @@ +package app.gamenative.mods + +import org.junit.Assert.assertEquals +import org.junit.Test + +class FomodEnvironmentTest { + @Test + fun dependencies_preserveUnknownAndEvaluateSupportedFacts() { + val expression = FomodDependencyExpression( + fileDependencies = listOf(FomodFileDependency("Data/Required.dll", FomodRequiredFileState.ACTIVE)), + pluginDependencies = listOf(FomodPluginDependency("Example.esp", FomodRequiredFileState.ACTIVE)), + gameDependencies = listOf(FomodGameDependency("1.6.0")), + ) + + assertEquals(FomodFactState.UNKNOWN, expression.evaluate(emptyMap(), FomodEnvironmentSnapshot())) + assertEquals( + FomodFactState.TRUE, + expression.evaluate( + emptyMap(), + FomodEnvironmentSnapshot( + gameVersion = "1.6.1170", + fileFacts = mapOf("data/required.dll" to true), + presentPlugins = setOf("example.esp"), + activePlugins = setOf("example.esp"), + ), + ), + ) + } + + @Test + fun unknownConditional_blocksInsteadOfGuessing() { + val installer = FomodInstaller( + moduleName = "Dependencies", + requiredFiles = emptyList(), + steps = emptyList(), + conditionalFileInstalls = listOf( + FomodConditionalFileInstall( + FomodDependencyExpression(fileDependencies = listOf(FomodFileDependency("Data/Maybe.dll", FomodRequiredFileState.ACTIVE))), + listOf(FomodFileMapping("Maybe.dll", "Maybe.dll", 0, directory = false)), + ), + ), + ) + + val result = FomodSelectionEvaluator.evaluate(installer, emptySet()) + + assertTrue(result.mappings.isEmpty()) + assertTrue(result.blockingIssues.any { "unknown" in it.lowercase() }) + } + + private fun assertTrue(value: Boolean) = org.junit.Assert.assertTrue(value) +} diff --git a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt index 80c79e044a..6cfd28e55a 100644 --- a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt @@ -31,6 +31,10 @@ class FomodInstallerTest { """ Example Installer + + + + @@ -69,6 +73,8 @@ class FomodInstallerTest { assertEquals(FomodPluginType.RECOMMENDED, plugin.type) assertEquals("2K", plugin.conditionFlags["TextureSize"]) assertEquals(2, plugin.files.size) + assertEquals("Data/Required.dll", installer.moduleDependencies.fileDependencies.single().file) + assertEquals("1.6.0", installer.moduleDependencies.gameDependencies.single().version) } @Test From 242db9fe232bf5a84bd6bfe2f0c1550eb3624c2b Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 12:46:16 -0500 Subject: [PATCH 16/60] feat: journal and verify mod deployment --- .../gamenative/mods/ModDeploymentJournal.kt | 126 ++++++++++++++++++ .../gamenative/mods/ModDeploymentVerifier.kt | 102 ++++++++++++++ .../app/gamenative/mods/ModMaterializer.kt | 12 ++ .../gamenative/mods/ModOwnershipManifest.kt | 16 +-- .../app/gamenative/mods/NexusModManager.kt | 91 ++++++++++++- .../ui/component/dialog/NexusModsDialog.kt | 73 +++++++++- .../mods/ModDeploymentJournalTest.kt | 88 ++++++++++++ 7 files changed, 488 insertions(+), 20 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt create mode 100644 app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt create mode 100644 app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt new file mode 100644 index 0000000000..c625cc4cfd --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt @@ -0,0 +1,126 @@ +package app.gamenative.mods + +import kotlinx.serialization.Serializable +import kotlinx.serialization.decodeFromString +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json +import java.io.File +import java.io.FileOutputStream +import java.nio.file.Files +import java.nio.file.StandardCopyOption +import java.util.UUID + +@Serializable +enum class ModDeploymentCheckpoint { + PLANNED, + PREPARING, + APPLYING, + VERIFYING, + COMMITTED, + ROLLING_BACK, + ROLLED_BACK, + RECOVERY_REQUIRED, +} + +@Serializable +data class ModDeploymentJournal( + val version: Int = 1, + val operationId: String = UUID.randomUUID().toString(), + val installId: String, + val appId: String, + val planDigest: String, + val targetCount: Int, + val checkpoint: ModDeploymentCheckpoint = ModDeploymentCheckpoint.PLANNED, + val detail: String = "", + val startedAt: Long = System.currentTimeMillis(), + val updatedAt: Long = startedAt, +) + +object ModDeploymentJournalStore { + private val json = Json { + ignoreUnknownKeys = true + encodeDefaults = true + } + + fun begin(root: File, installId: String, appId: String, plan: ModMaterializationPlan): ModDeploymentJournal { + val journal = ModDeploymentJournal( + installId = installId, + appId = appId, + planDigest = plan.digest, + targetCount = plan.files.size, + ) + write(root, journal) + return journal + } + + fun checkpoint( + root: File, + journal: ModDeploymentJournal, + checkpoint: ModDeploymentCheckpoint, + detail: String = "", + ): ModDeploymentJournal = journal.copy( + checkpoint = checkpoint, + detail = detail.take(512), + updatedAt = System.currentTimeMillis(), + ).also { write(root, it) } + + fun read(root: File, installId: String): ModDeploymentJournal? = readFile(journalFile(root, installId)) + + fun readAll(root: File): List = + journalDir(root).listFiles().orEmpty().filter { it.isFile && it.extension == "json" }.mapNotNull(::readFile) + + fun reconcile(root: File): List = readAll(root).map { journal -> + when (journal.checkpoint) { + ModDeploymentCheckpoint.PLANNED, + ModDeploymentCheckpoint.PREPARING -> checkpoint( + root, + journal, + ModDeploymentCheckpoint.ROLLED_BACK, + "Recovered before filesystem mutation", + ) + ModDeploymentCheckpoint.VERIFYING -> { + val ownership = ModOwnershipStore.read(root, journal.installId) + if ( + ownership?.planDigest == journal.planDigest && + ModDeploymentVerifier.verify(ownership).issues.isEmpty() + ) { + checkpoint(root, journal, ModDeploymentCheckpoint.COMMITTED, "Recovered verified deployment") + } else { + checkpoint(root, journal, ModDeploymentCheckpoint.RECOVERY_REQUIRED, "Deployment state needs review") + } + } + ModDeploymentCheckpoint.APPLYING, + ModDeploymentCheckpoint.ROLLING_BACK -> checkpoint( + root, + journal, + ModDeploymentCheckpoint.RECOVERY_REQUIRED, + "Filesystem mutation may have been interrupted", + ) + else -> journal + } + } + + private fun write(root: File, journal: ModDeploymentJournal) { + val current = journalFile(root, journal.installId) + val temp = File(current.parentFile, "${current.name}.tmp") + current.parentFile?.mkdirs() + FileOutputStream(temp).use { output -> + output.write(json.encodeToString(journal).toByteArray(Charsets.UTF_8)) + output.fd.sync() + } + runCatching { + Files.move(temp.toPath(), current.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING) + }.getOrElse { + temp.copyTo(current, overwrite = true) + temp.delete() + } + } + + private fun readFile(file: File): ModDeploymentJournal? = + if (!file.isFile) null else runCatching { json.decodeFromString(file.readText()) }.getOrNull() + + private fun journalDir(root: File): File = File(root, "journals") + + private fun journalFile(root: File, installId: String): File = + File(journalDir(root), "${installId.replace(Regex("[^A-Za-z0-9._-]"), "_")}.json") +} diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt new file mode 100644 index 0000000000..2646547999 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt @@ -0,0 +1,102 @@ +package app.gamenative.mods + +import java.io.File +import java.nio.file.Files + +enum class ModVerificationIssueType { + MISSING, + MODIFIED, + WRONG_CASE, + AMBIGUOUS, + STALE, + OWNERSHIP, +} + +data class ModVerificationIssue( + val type: ModVerificationIssueType, + val targetPath: String, + val detail: String, + val installId: String = "", +) + +data class ModDeploymentVerification(val issues: List) { + val successful: Boolean get() = issues.isEmpty() +} + +object ModDeploymentVerifier { + fun verify(plan: ModMaterializationPlan): ModDeploymentVerification = + ModDeploymentVerification( + plan.files.flatMap { file -> + verifyTarget( + target = file.target, + expectedHash = ModOwnershipStore.sha256(file.source), + stale = false, + installId = file.installId, + ) + }, + ) + + fun verify(manifest: ModOwnershipManifest): ModDeploymentVerification = + ModDeploymentVerification( + manifest.files.flatMap { file -> + verifyTarget(File(file.targetPath), file.installedHash, stale = !file.active, installId = manifest.installId) + }, + ) + + fun verify(overlay: ModProfileOverlay): ModDeploymentVerification = + ModDeploymentVerification( + overlay.targets.values.flatMap { target -> + verifyTarget( + target = File(target.winner.file.targetPath), + expectedHash = target.winner.file.installedHash, + stale = false, + installId = target.winner.installId, + ) + if (target.hasCaseCollision) { + listOf( + ModVerificationIssue( + ModVerificationIssueType.AMBIGUOUS, + target.winner.file.targetPath, + "Enabled mods use case-variant target paths", + target.winner.installId, + ), + ) + } else { + emptyList() + } + }, + ) + + private fun verifyTarget( + target: File, + expectedHash: String, + stale: Boolean, + installId: String, + ): List { + val parent = target.parentFile + val caseMatches = parent?.listFiles().orEmpty().filter { it.name.equals(target.name, ignoreCase = true) } + if (caseMatches.size > 1) { + return listOf(issue(ModVerificationIssueType.AMBIGUOUS, target, "Multiple case variants exist", installId)) + } + val actual = when { + target.exists() || Files.isSymbolicLink(target.toPath()) -> target + caseMatches.size == 1 -> caseMatches.single() + stale -> return emptyList() + else -> return listOf(issue(ModVerificationIssueType.MISSING, target, "Required planned file is missing", installId)) + } + if (stale) { + return listOf(issue(ModVerificationIssueType.STALE, actual, "A preserved stale managed file is still present", installId)) + } + val issues = mutableListOf() + if (actual.name != target.name) { + issues += issue(ModVerificationIssueType.WRONG_CASE, actual, "Target exists with unexpected casing", installId) + } + val currentHash = ModOwnershipStore.sha256(actual) + if (!actual.isFile || expectedHash.isBlank() || currentHash != expectedHash) { + issues += issue(ModVerificationIssueType.MODIFIED, actual, "Target content differs from the reviewed plan", installId) + } + return issues + } + + private fun issue(type: ModVerificationIssueType, target: File, detail: String, installId: String) = + ModVerificationIssue(type, target.absolutePath, detail, installId) +} diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index bfd9b783ce..f723af50ba 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -59,6 +59,15 @@ data class ModMaterializationPlan( val errors: Map = emptyMap(), ) { val isComplete: Boolean get() = errors.isEmpty() + val digest: String + get() { + val canonical = files.joinToString("\n") { file -> + "${file.sourceRelativePath}|${file.targetRoot}|${file.targetRelativePath}|${file.normalizedTargetKey}|${file.mode}" + } + return MessageDigest.getInstance("SHA-256") + .digest(canonical.toByteArray(Charsets.UTF_8)) + .joinToString("") { "%02x".format(it) } + } } object ModMaterializer { @@ -342,6 +351,9 @@ object ModMaterializer { } } }.sortedWith(compareBy { it.normalizedTargetKey }.thenBy { it.sourceRelativePath.lowercase() }) + if (files.isEmpty()) { + errors[install.modName] = "The reviewed placement does not contain any materialized files" + } return ModMaterializationPlan(install.installId, operations, files, errors) } diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index 2c7de36970..9cd7507407 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -116,7 +116,10 @@ object ModProfileOverlayPlanner { } object ModOwnershipStore { - private val json = Json { ignoreUnknownKeys = true } + private val json = Json { + ignoreUnknownKeys = true + encodeDefaults = true + } fun read(root: File, installId: String): ModOwnershipManifest? = readFile(currentFile(root, installId)) ?: readFile(previousFile(root, installId)) @@ -196,7 +199,7 @@ object ModOwnershipStore { installId = plan.installId, appId = appId, profileId = profileId, - planDigest = planDigest(plan), + planDigest = plan.digest, files = (files + preservedStale).distinctBy { it.normalizedTargetKey to it.active }, operations = plan.operations.map { operation -> ModOwnedOperation( @@ -242,15 +245,6 @@ object ModOwnershipStore { } } - private fun planDigest(plan: ModMaterializationPlan): String { - val canonical = plan.files.joinToString("\n") { file -> - "${file.sourceRelativePath}|${file.targetRoot}|${file.targetRelativePath}|${file.normalizedTargetKey}|${file.mode}" - } - return MessageDigest.getInstance("SHA-256") - .digest(canonical.toByteArray(Charsets.UTF_8)) - .joinToString("") { "%02x".format(it) } - } - internal fun sha256(file: File): String { if (!file.isFile) return "" val digest = MessageDigest.getInstance("SHA-256") diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index c59f01f3a1..b7fda3ed80 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -71,6 +71,7 @@ data class ModHealthIssue( val title: String, val detail: String, val installName: String = "", + val installId: String = "", ) data class ModHealthReport( @@ -515,6 +516,7 @@ object NexusModManager { preserveStatusOnError: Boolean = false, profileId: String = "", priority: Int = 0, + checkpointHook: (ModDeploymentCheckpoint) -> Unit = {}, ): ModPlacementResult = withContext(Dispatchers.IO) { val dao = dao(context) val existingManifests = dao.getOverwriteManifests(install.installId) @@ -524,12 +526,31 @@ object NexusModManager { val ownershipRoot = cacheRoot(context, install.appId) val previousOwnership = ModOwnershipStore.read(ownershipRoot, install.installId) val plan = ModMaterializer.materializationPlan(install, recipes, gameRootDir, winePrefix) - val result = ModMaterializer.apply( + var journal = ModDeploymentJournalStore.begin(ownershipRoot, install.installId, install.appId, plan) + checkpointHook(ModDeploymentCheckpoint.PLANNED) + fun advance(checkpoint: ModDeploymentCheckpoint, detail: String = "") { + journal = ModDeploymentJournalStore.checkpoint(ownershipRoot, journal, checkpoint, detail) + checkpointHook(checkpoint) + } + advance(ModDeploymentCheckpoint.PREPARING) + advance(ModDeploymentCheckpoint.APPLYING) + val applied = ModMaterializer.apply( install = install, plan = plan, backupRoot = backupRoot(context, install.appId), allowOverwrite = allowOverwrite, ) + if (applied.errors.isEmpty()) advance(ModDeploymentCheckpoint.VERIFYING) + val verification = if (applied.errors.isEmpty()) ModDeploymentVerifier.verify(plan) else ModDeploymentVerification(emptyList()) + val result = if (verification.successful) { + applied + } else { + applied.copy( + errors = applied.errors + verification.issues.associate { issue -> + issue.targetPath to "${issue.type}: ${issue.detail}" + }, + ) + } if (result.errors.isEmpty()) { if (result.manifests.isNotEmpty()) { dao.replaceOverwriteManifestsForTargets(install.installId, result.manifests) @@ -571,11 +592,13 @@ object NexusModManager { dao.updateInstallStatus(install.installId, ModInstallStatus.APPLIED.name) } if (saveLastPlacement) saveLastPlacementForApp(install.appId, recipes) + advance(ModDeploymentCheckpoint.COMMITTED) return@withContext result.copy(warnings = staleCleanup.skippedPaths) } else if (!preserveStatusOnError && install.status != ModInstallStatus.ERROR.name) { dao.updateInstallStatus(install.installId, ModInstallStatus.ERROR.name) } + advance(ModDeploymentCheckpoint.ROLLING_BACK, "Apply or verification failed") val restoreSkipped = ModMaterializer.restoreBackups(result.manifests) val restoredTargets = result.manifests .map { it.targetPath } @@ -596,8 +619,10 @@ object NexusModManager { .forEach { deleteFileBytes(File(it)) } val rollbackSkipped = (restoreSkipped + removeSkipped).distinct() if (rollbackSkipped.isEmpty()) { + advance(ModDeploymentCheckpoint.ROLLED_BACK) result } else { + advance(ModDeploymentCheckpoint.RECOVERY_REQUIRED, "${rollbackSkipped.size} changed file(s) were preserved") result.copy( errors = result.errors + ("Rollback" to "${rollbackSkipped.size} changed file(s) left in place after failed apply"), ) @@ -980,14 +1005,35 @@ object NexusModManager { detail: String, install: ModInstall? = null, ) { - issues += ModHealthIssue(severity, title, detail, install?.modName.orEmpty()) + issues += ModHealthIssue(severity, title, detail, install?.modName.orEmpty(), install?.installId.orEmpty()) } + val ownershipRoot = cacheRoot(context, appId) + val journals = ModDeploymentJournalStore.reconcile(ownershipRoot).associateBy { it.installId } + val ownershipByInstallId = installs.mapNotNull { install -> + ModOwnershipStore.read(ownershipRoot, install.installId)?.let { install.installId to it } + }.toMap() + val activeProfile = dao.getActiveProfileForApp(appId) + val enabledPriorities = activeProfile?.let { profile -> + dao.getProfileInstallStates(appId, profile.profileId) + .filter { it.enabled } + .associate { it.installId to it.priority } + }.orEmpty() + val overlayFindings = ModDeploymentVerifier.verify( + ModProfileOverlayPlanner.build(ownershipByInstallId.values.toList(), enabledPriorities), + ).issues + installs.forEach { install -> val status = runCatching { ModInstallStatus.valueOf(install.status) }.getOrNull() val extracted = File(install.extractedPath) val recipes = dao.getRecipesForInstall(install.installId) val manifests = dao.getOverwriteManifests(install.installId) + val ownership = ownershipByInstallId[install.installId] + val journal = journals[install.installId] + + if (journal?.checkpoint == ModDeploymentCheckpoint.RECOVERY_REQUIRED) { + add(ModHealthSeverity.ERROR, "Deployment recovery is required", journal.detail, install) + } if (status == null) { add(ModHealthSeverity.ERROR, "Unknown install status", install.status, install) @@ -1003,7 +1049,36 @@ object NexusModManager { if (install.status == ModInstallStatus.APPLIED.name) { if (recipes.none { it.enabled }) { add(ModHealthSeverity.ERROR, "Applied mod has no placement recipe", "GameNative cannot verify or safely remove deployed files.", install) - } else if (extracted.isDirectory) { + } else if (ownership == null) { + add( + ModHealthSeverity.WARNING, + "Ownership adoption is required", + "This historical install remains usable, but destructive cleanup is blocked until it is safely reapplied.", + install, + ) + } else if (ownership.state != ModOwnershipState.ACTIVE) { + add(ModHealthSeverity.ERROR, "Ownership state does not match the applied mod", ownership.state.name, install) + } else { + val findingsForInstall = overlayFindings.filter { it.installId == install.installId } + + ModDeploymentVerifier.verify(ownership).issues.filter { it.type == ModVerificationIssueType.STALE } + findingsForInstall.groupBy { it.type }.forEach { (type, findings) -> + val severity = if (type == ModVerificationIssueType.STALE) ModHealthSeverity.WARNING else ModHealthSeverity.ERROR + add( + severity, + when (type) { + ModVerificationIssueType.MISSING -> "Managed files are missing" + ModVerificationIssueType.MODIFIED -> "Managed files were modified" + ModVerificationIssueType.WRONG_CASE -> "Managed files have unexpected casing" + ModVerificationIssueType.AMBIGUOUS -> "Case-ambiguous target files exist" + ModVerificationIssueType.STALE -> "Stale managed files were preserved" + ModVerificationIssueType.OWNERSHIP -> "Ownership records need review" + }, + findings.take(3).joinToString("\n") { it.targetPath }, + install, + ) + } + } + if (ownership == null && extracted.isDirectory) { val missing = missingAppliedTargets(install, recipes, gameRootDir, winePrefix).take(3) if (missing.isNotEmpty()) { add( @@ -1014,6 +1089,13 @@ object NexusModManager { ) } } + } else if (ownership != null) { + ModDeploymentVerifier.verify(ownership).issues + .filter { it.type == ModVerificationIssueType.STALE } + .take(3) + .forEach { finding -> + add(ModHealthSeverity.WARNING, "Stale managed file was preserved", finding.targetPath, install) + } } if (install.status == ModInstallStatus.READY.name && manifests.isNotEmpty()) { add(ModHealthSeverity.WARNING, "Ready mod has overwrite records", "This mod is not applied but still has ${manifests.size} overwrite record(s).", install) @@ -1068,6 +1150,9 @@ object NexusModManager { ModHealthReport(issues) } + suspend fun reconcilePendingDeploymentsForApp(context: Context, appId: String): List = + withContext(Dispatchers.IO) { ModDeploymentJournalStore.reconcile(cacheRoot(context, appId)) } + fun hasMissingAppliedTargets( install: ModInstall, recipes: List, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 6f106abd5b..5a6a5adf09 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -31,6 +31,7 @@ import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.LinearProgressIndicator import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.OutlinedButton import androidx.compose.material3.SnackbarHost import androidx.compose.material3.SnackbarHostState import androidx.compose.material3.Surface @@ -348,6 +349,7 @@ private data class ProfileOrderPlan( val disabledInstalls: List, val configuredInstalls: List, val installsToApply: List, + val rebuildManagedOverlay: Boolean, val missingTargetRepairInstallIds: Set, val recipesByInstallId: Map>, val recipesToPersistByInstallId: Map>, @@ -653,6 +655,8 @@ private fun InstallHealthSection( report: ModHealthReport?, loading: Boolean, onCheck: () -> Unit, + onRebuild: () -> Unit, + onReconfigure: (String) -> Unit, ) { NexusSectionCard { NexusSectionHeader(stringResource(R.string.nexus_install_health_title), loading, stringResource(R.string.nexus_check), onCheck) @@ -667,11 +671,19 @@ private fun InstallHealthSection( } else { val summaryColor = if (current.errorCount > 0) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant Text(stringResource(R.string.nexus_install_health_summary, current.errorCount, current.warningCount), style = MaterialTheme.typography.bodySmall, color = summaryColor) + OutlinedButton(onClick = onRebuild, enabled = !loading, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.nexus_apply_order)) + } current.issues.take(8).forEach { issue -> Column(verticalArrangement = Arrangement.spacedBy(2.dp)) { val titleColor = if (issue.severity == ModHealthSeverity.ERROR) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface Text(listOf(issue.installName, issue.title).filter(String::isNotBlank).joinToString(": "), style = MaterialTheme.typography.bodySmall, fontWeight = FontWeight.SemiBold, color = titleColor) Text(issue.detail, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant) + if (issue.installId.isNotBlank()) { + TextButton(onClick = { onReconfigure(issue.installId) }) { + Text(stringResource(R.string.nexus_configure)) + } + } } } if (current.issues.size > 8) { @@ -1112,6 +1124,7 @@ fun NexusModsDialog( } launch { delay(750) + NexusModManager.reconcilePendingDeploymentsForApp(context, libraryItem.appId) NexusModImportService.resumeInterruptedImports(context) NexusModManager.cleanupOrphanedFilesForApp(context, libraryItem.appId) storageBreakdown = NexusModManager.scanStorageForApp(context, libraryItem.appId) @@ -1478,6 +1491,20 @@ fun NexusModsDialog( } val configuredInstalls = orderedInstalls.filter { recipesByInstallId[it.installId].orEmpty().isNotEmpty() } val unconfiguredInstalls = orderedInstalls - configuredInstalls.toSet() + val configuredOwnership = configuredInstalls.mapNotNull { install -> + app.gamenative.mods.ModOwnershipStore.read( + NexusModManager.cacheRoot(context, libraryItem.appId), + install.installId, + ) + } + val configuredOverlay = app.gamenative.mods.ModProfileOverlayPlanner.build( + configuredOwnership, + stateByInstallId.mapValues { it.value.priority }, + ) + val rebuildManagedOverlay = configuredInstalls.isNotEmpty() && + configuredOwnership.size == configuredInstalls.size && + configuredOwnership.all { it.state == app.gamenative.mods.ModOwnershipState.ACTIVE } && + app.gamenative.mods.ModDeploymentVerifier.verify(configuredOverlay).successful val game = BethesdaPluginManager.detectGame(libraryItem.name) val plugins = game?.let { BethesdaPluginManager.detectPlugins( @@ -1511,11 +1538,15 @@ fun NexusModsDialog( ) } .mapTo(mutableSetOf()) { it.installId } - val installsToApply = configuredInstalls.filter { install -> - install.status != ModInstallStatus.APPLIED.name || - install.installId in conflictInstallIds || - install.installId in assetRepairInstallIds || - install.installId in missingTargetRepairInstallIds + val installsToApply = if (rebuildManagedOverlay) { + configuredInstalls + } else { + configuredInstalls.filter { install -> + install.status != ModInstallStatus.APPLIED.name || + install.installId in conflictInstallIds || + install.installId in assetRepairInstallIds || + install.installId in missingTargetRepairInstallIds + } } ProfileOrderPlan( profileId = profile.profileId, @@ -1523,6 +1554,7 @@ fun NexusModsDialog( disabledInstalls = disabledInstalls, configuredInstalls = configuredInstalls, installsToApply = installsToApply, + rebuildManagedOverlay = rebuildManagedOverlay, missingTargetRepairInstallIds = missingTargetRepairInstallIds, recipesByInstallId = recipesByInstallId, recipesToPersistByInstallId = recipesToPersistByInstallId, @@ -1607,6 +1639,26 @@ fun NexusModsDialog( } } + if (plan.rebuildManagedOverlay) { + loadingMessage = context.getString(R.string.nexus_applying_mod_order) + disabledSkipped += withContext(Dispatchers.IO) { + plan.configuredInstalls.asReversed().sumOf { install -> + NexusModManager.disableInstall( + context = context, + install = install, + restoreBackups = true, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + ).size + } + } + if (disabledSkipped > 0) { + SnackbarManager.show(context.getString(R.string.nexus_changed_disabled_files_left_in_place, disabledSkipped)) + return@launch + } + effectiveAllowOverwrite = true + } + loadingMessage = context.getString(R.string.nexus_applying_mod_order) val result = withContext(Dispatchers.IO) { var errors = 0 @@ -1626,7 +1678,11 @@ fun NexusModsDialog( } else { NexusModManager.applyInstall( context = context, - install = install, + install = if (plan.rebuildManagedOverlay) { + install.copy(status = ModInstallStatus.DISABLED.name) + } else { + install + }, recipes = recipes, gameRootDir = gameRootDir, winePrefix = winePrefix, @@ -3294,6 +3350,11 @@ fun NexusModsDialog( report = healthReport, loading = healthLoading, onCheck = ::runInstallHealthCheck, + onRebuild = { applyProfileOrder(allowOverwrite = false) }, + onReconfigure = { installId -> + installs.firstOrNull { it.installId == installId }?.let(::selectInstallForPlacement) + selectedTab = ManageModsTab.PLACEMENT + }, ) StorageCleanupSection( breakdown = storageBreakdown, diff --git a/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt b/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt new file mode 100644 index 0000000000..fe873f5935 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt @@ -0,0 +1,88 @@ +package app.gamenative.mods + +import app.gamenative.data.ModPlacementMode +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import java.io.File + +class ModDeploymentJournalTest { + @get:Rule + val temporaryFolder = TemporaryFolder() + + @Test + fun interruptedCheckpoints_reconcileToSafeExplicitStates() { + val expectations = mapOf( + ModDeploymentCheckpoint.PLANNED to ModDeploymentCheckpoint.ROLLED_BACK, + ModDeploymentCheckpoint.PREPARING to ModDeploymentCheckpoint.ROLLED_BACK, + ModDeploymentCheckpoint.APPLYING to ModDeploymentCheckpoint.RECOVERY_REQUIRED, + ModDeploymentCheckpoint.VERIFYING to ModDeploymentCheckpoint.RECOVERY_REQUIRED, + ModDeploymentCheckpoint.ROLLING_BACK to ModDeploymentCheckpoint.RECOVERY_REQUIRED, + ModDeploymentCheckpoint.ROLLED_BACK to ModDeploymentCheckpoint.ROLLED_BACK, + ModDeploymentCheckpoint.RECOVERY_REQUIRED to ModDeploymentCheckpoint.RECOVERY_REQUIRED, + ) + expectations.forEach { (interruptedAt, expected) -> + val root = temporaryFolder.newFolder(interruptedAt.name) + val initial = ModDeploymentJournalStore.begin(root, "install", "game", emptyPlan()) + if (interruptedAt != ModDeploymentCheckpoint.PLANNED) { + ModDeploymentJournalStore.checkpoint(root, initial, interruptedAt) + } + + assertEquals(expected, ModDeploymentJournalStore.reconcile(root).single().checkpoint) + } + } + + @Test + fun verifyingCheckpoint_commitsOnlyWhenOwnershipAndFilesMatch() { + val root = temporaryFolder.newFolder("verified") + val source = temporaryFolder.newFile("source").apply { writeText("expected") } + val target = temporaryFolder.newFile("target").apply { writeText("expected") } + val plan = ModMaterializationPlan( + installId = "install", + operations = emptyList(), + files = listOf( + ModPlannedFile( + installId = "install", + source = source, + target = target, + mode = ModPlacementMode.COPY, + targetRoot = "GAME_DIR", + sourceRelativePath = source.name, + targetRelativePath = target.name, + ), + ), + ) + val journal = ModDeploymentJournalStore.begin(root, "install", "game", plan) + ModDeploymentJournalStore.checkpoint(root, journal, ModDeploymentCheckpoint.VERIFYING) + ModOwnershipStore.writePending( + root, + ModOwnershipManifest( + installId = "install", + appId = "game", + planDigest = plan.digest, + files = listOf( + ModOwnedFile( + sourceRelativePath = source.name, + targetRoot = "GAME_DIR", + targetRelativePath = target.name, + targetPath = target.absolutePath, + normalizedTargetKey = WindowsPathIdentity.absoluteKey(target), + mode = ModPlacementMode.COPY.name, + installedHash = ModOwnershipStore.sha256(source), + installedSize = target.length(), + installedMtime = target.lastModified(), + disposition = ModOwnedFileDisposition.CREATED, + ), + ), + ), + ) + + assertEquals(ModDeploymentCheckpoint.COMMITTED, ModDeploymentJournalStore.reconcile(root).single().checkpoint) + target.writeText("external change") + assertTrue(ModDeploymentVerifier.verify(ModOwnershipStore.read(root, "install")!!).issues.any { it.type == ModVerificationIssueType.MODIFIED }) + } + + private fun emptyPlan() = ModMaterializationPlan("install", emptyList(), emptyList()) +} From 9b78be9fa5023804243879f9349a8fac483c3560 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 13:01:05 -0500 Subject: [PATCH 17/60] perf: finish placement validation --- .../mods/AutomaticPlacementPlanner.kt | 30 ++----- .../gamenative/mods/BethesdaPluginManager.kt | 34 +++----- .../app/gamenative/mods/ModArchiveIndex.kt | 80 +++++++++-------- .../gamenative/mods/ModConflictAnalyzer.kt | 29 +++---- .../gamenative/mods/ModDiagnosticSanitizer.kt | 19 ++++ .../app/gamenative/mods/ModInstallPlan.kt | 16 ++-- .../app/gamenative/mods/ModMaterializer.kt | 55 +++++++++--- .../app/gamenative/mods/ModPlacementPreset.kt | 78 ++++++----------- .../gamenative/mods/ModPlacementRulePacks.kt | 41 +++++++++ .../app/gamenative/mods/NexusModManager.kt | 86 +++++++------------ .../gamenative/mods/WindowsTargetNamespace.kt | 27 +++++- .../ui/component/dialog/NexusModsDialog.kt | 17 +++- app/src/main/res/values-da/strings.xml | 8 ++ app/src/main/res/values-de/strings.xml | 8 ++ app/src/main/res/values-es/strings.xml | 8 ++ app/src/main/res/values-fr/strings.xml | 8 ++ app/src/main/res/values-it/strings.xml | 8 ++ app/src/main/res/values-ja/strings.xml | 8 ++ app/src/main/res/values-ko/strings.xml | 8 ++ app/src/main/res/values-pl/strings.xml | 8 ++ app/src/main/res/values-pt-rBR/strings.xml | 8 ++ app/src/main/res/values-ro/strings.xml | 8 ++ app/src/main/res/values-ru/strings.xml | 8 ++ app/src/main/res/values-uk/strings.xml | 8 ++ app/src/main/res/values-zh-rCN/strings.xml | 8 ++ app/src/main/res/values-zh-rTW/strings.xml | 8 ++ .../mods/ModArchiveIndexPerformanceTest.kt | 26 ++++++ .../mods/ModInstallPlanContractTest.kt | 12 +++ .../gamenative/mods/ModTargetResolverTest.kt | 25 ++++++ 29 files changed, 455 insertions(+), 232 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt create mode 100644 app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt create mode 100644 app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index adf023d513..8241fd3dc1 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -21,25 +21,7 @@ data class AutomaticPlacementResult( ) object AutomaticPlacementPlanner { - private val bethesdaContentDirectories = setOf( - "meshes", - "textures", - "scripts", - "interface", - "sound", - "sounds", - "strings", - "skse", - "f4se", - "sfse", - "seq", - "video", - "music", - "lodsettings", - "calientetools", - "nemesis_engine", - ) - private val bethesdaDataExtensions = setOf("esp", "esm", "esl", "bsa", "ba2") + private val bethesdaRule = ModPlacementRulePacks.bethesda fun plan(gameName: String, entries: List): AutomaticPlacementResult { val index = ModArchiveIndex.build(entries) @@ -139,11 +121,13 @@ object AutomaticPlacementPlanner { if (bestData != null) add("Found ${bestData.displayPath} as a Data container") val anchors = index.nodes.flatMapTo(mutableSetOf()) { it.semanticAnchors }.sorted() if (anchors.isNotEmpty()) add("Recognized Data content: ${anchors.joinToString()}") - val loose = index.files.count { it.displayPath.substringAfterLast('.').lowercase(Locale.ROOT) in bethesdaDataExtensions } + val loose = index.files.count { + it.displayPath.substringAfterLast('.').lowercase(Locale.ROOT) in bethesdaRule.looseExtensions + } if (loose > 0) add("Found $loose Bethesda plugin/archive file(s)") } return candidateFromDrafts( - id = "rules:bethesda-data-v1", + id = "rules:${bethesdaRule.stableId}-v${bethesdaRule.version}", label = "Complete Bethesda Data plan", description = "Maps recognized Data content and loose plugins while preserving content folders.", drafts = drafts, @@ -167,9 +151,9 @@ object AutomaticPlacementPlanner { private fun bethesdaSourceForFile(file: IndexedArchiveFile): String? { if (file.role != ArchiveContentRole.INSTALLABLE) return null val segments = file.displayPath.split('/') - val anchorIndex = segments.indexOfFirst { it.lowercase(Locale.ROOT) in bethesdaContentDirectories } + val anchorIndex = segments.indexOfFirst { it.lowercase(Locale.ROOT) in bethesdaRule.directoryTargets } if (anchorIndex >= 0) return segments.take(anchorIndex + 1).joinToString("/") - if (file.displayPath.substringAfterLast('.', "").lowercase(Locale.ROOT) in bethesdaDataExtensions) { + if (file.displayPath.substringAfterLast('.', "").lowercase(Locale.ROOT) in bethesdaRule.looseExtensions) { return file.displayPath } return null diff --git a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt index 07dbdcd17a..467ac5690f 100644 --- a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt +++ b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt @@ -89,8 +89,16 @@ object BethesdaPluginManager { installs.filter { it.status == ModInstallStatus.APPLIED.name }.flatMap { install -> val recipes = recipesByInstallId[install.installId].orEmpty() runCatching { - ModMaterializer.plannedEntries(install, recipes, gameRootDir, winePrefix) - .flatMap { entry -> entry.toPluginFiles() } + val plan = ModMaterializer.materializationPlan( + install, + recipes, + gameRootDir, + winePrefix, + captureTargetHashes = false, + ) + check(plan.isComplete) { plan.errors.values.joinToString() } + plan.files + .filter { file -> file.source.extension.lowercase() in pluginExtensions } .map { plugin -> BethesdaPlugin( fileName = plugin.target.name, @@ -287,28 +295,6 @@ object BethesdaPluginManager { return PluginEntry(fileName = fileName, enabled = enabled) } - private data class PlannedPluginFile(val source: File, val target: File) - - private fun ModPlannedEntry.toPluginFiles(): List { - if (source.isFile) { - return if (source.extension.lowercase() in pluginExtensions) { - listOf(PlannedPluginFile(source, target)) - } else { - emptyList() - } - } - if (!source.isDirectory) return emptyList() - val sourceRoot = source.canonicalFile - return source.walkTopDown() - .filter { it.isFile && it.extension.lowercase() in pluginExtensions } - .mapNotNull { file -> - val relative = file.canonicalFile.relativeToOrNull(sourceRoot)?.path ?: return@mapNotNull null - val resolvedTarget = ModTargetResolver.resolveWithin(target, relative) ?: return@mapNotNull null - PlannedPluginFile(file, resolvedTarget) - } - .toList() - } - private fun pluginTypeRank(name: String): Int = when (name.substringAfterLast('.', "").lowercase()) { "esm" -> 0 "esl" -> 1 diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index 2e1cd8056e..45c938db74 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -38,31 +38,27 @@ data class ModArchiveIndex( fun filesUnder(sourcePath: String): List { val key = normalizedArchiveKey(sourcePath) ?: return emptyList() if (key.isBlank()) return files - return files.filter { it.normalizedKey == key || it.normalizedKey.startsWith("$key/") } + val prefix = "$key/" + var low = 0 + var high = files.size + while (low < high) { + val middle = (low + high) ushr 1 + if (files[middle].normalizedKey < key) low = middle + 1 else high = middle + } + var end = low + while (end < files.size && (files[end].normalizedKey == key || files[end].normalizedKey.startsWith(prefix))) { + end++ + } + return files.subList(low, end).toList() } fun isDirectory(sourcePath: String): Boolean { val key = normalizedArchiveKey(sourcePath) ?: return false - return nodes.any { it.normalizedKey == key } || files.any { it.normalizedKey.startsWith("$key/") } + return nodes.binarySearchBy(key) { it.normalizedKey } >= 0 } companion object { - private val semanticAnchors = setOf( - "meshes", - "textures", - "scripts", - "interface", - "sound", - "sounds", - "strings", - "skse", - "f4se", - "sfse", - "seq", - "video", - "music", - "lodsettings", - ) + private val semanticAnchors = ModPlacementRulePacks.archiveSemanticAnchors fun build(entries: List): ModArchiveIndex { val indexedFiles = entries.asSequence() @@ -79,29 +75,38 @@ data class ModArchiveIndex( } .sortedWith(compareBy { it.normalizedKey }.thenBy { it.displayPath }) .toList() - val directoryPaths = buildSet { - entries.filter { it.directory }.forEach { entry -> - normalizeArchiveDisplayPath(entry.path).takeIf(String::isNotBlank)?.let(::add) - } - indexedFiles.forEach { file -> - val segments = file.displayPath.split('/') - (1 until segments.size).forEach { count -> add(segments.take(count).joinToString("/")) } + val displayPaths = sortedMapOf() + val counts = mutableMapOf() + val bytes = mutableMapOf() + val anchors = mutableMapOf>() + entries.asSequence().filter { it.directory }.forEach { entry -> + val display = normalizeArchiveDisplayPath(entry.path) + val key = normalizedArchiveKey(display) + if (display.isNotBlank() && key != null) displayPaths.merge(key, display, ::stableDisplayPath) + } + indexedFiles.forEach { file -> + val displaySegments = file.displayPath.split('/') + val keySegments = file.normalizedKey.split('/') + val fileAnchors = keySegments.filterTo(mutableSetOf()) { it in semanticAnchors } + (1 until keySegments.size).forEach { count -> + val key = keySegments.take(count).joinToString("/") + val display = displaySegments.take(count).joinToString("/") + displayPaths.merge(key, display, ::stableDisplayPath) + counts[key] = counts.getOrDefault(key, 0) + 1 + bytes[key] = bytes.getOrDefault(key, 0L) + file.sizeBytes + anchors.getOrPut(key, ::mutableSetOf).addAll(fileAnchors) } } - val nodes = directoryPaths.mapNotNull { path -> - val key = normalizedArchiveKey(path) ?: return@mapNotNull null - val descendants = indexedFiles.filter { it.normalizedKey.startsWith("$key/") } + val nodes = displayPaths.map { (key, display) -> ArchiveTreeNode( - displayPath = path, + displayPath = display, normalizedKey = key, - descendantFileCount = descendants.size, - descendantBytes = descendants.sumOf { it.sizeBytes }, - semanticAnchors = descendants.flatMapTo(mutableSetOf()) { descendant -> - descendant.normalizedKey.split('/').filter { it in semanticAnchors } - }, - optionStyleWrapper = looksLikeOptionWrapper(path.substringAfterLast('/')), + descendantFileCount = counts.getOrDefault(key, 0), + descendantBytes = bytes.getOrDefault(key, 0L), + semanticAnchors = anchors[key].orEmpty(), + optionStyleWrapper = looksLikeOptionWrapper(display.substringAfterLast('/')), ) - }.sortedBy { it.normalizedKey } + } return ModArchiveIndex( files = indexedFiles, nodes = nodes, @@ -140,6 +145,9 @@ data class ModArchiveIndex( return Regex("^\\d{1,2}[ _.-]").containsMatchIn(normalized) || listOf("optional", "option", "variant", "choose", "pick one").any(normalized::contains) } + + private fun stableDisplayPath(left: String, right: String): String = + minOf(left, right, compareBy { it.lowercase(Locale.ROOT) }.thenBy { it }) } } diff --git a/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt b/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt index d61cf8a2f7..cfecb8242a 100644 --- a/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt +++ b/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt @@ -34,8 +34,17 @@ object ModConflictAnalyzer { val plannedFiles = installs.flatMap { install -> val recipes = recipesByInstallId[install.installId].orEmpty() runCatching { - ModMaterializer.plannedEntries(install, recipes, gameRootDir, winePrefix) - .flatMap { it.toPlannedFiles() } + val plan = ModMaterializer.materializationPlan( + install, + recipes, + gameRootDir, + winePrefix, + captureTargetHashes = false, + ) + check(plan.isComplete) { plan.errors.values.joinToString() } + plan.files.map { file -> + PlannedFile(file.installId, file.source, file.target) + } }.getOrElse { error -> Timber.w(error, "Skipping Nexus conflict analysis for install %s", install.installId) emptyList() @@ -77,22 +86,6 @@ object ModConflictAnalyzer { val target: File, ) - private fun ModPlannedEntry.toPlannedFiles(): List { - if (source.isFile) { - return listOf(PlannedFile(installId, source, target)) - } - if (!source.isDirectory) return emptyList() - val sourceRoot = source.canonicalFile - return source.walkTopDown() - .filter { it.isFile } - .mapNotNull { file -> - val relative = file.canonicalFile.relativeToOrNull(sourceRoot)?.path ?: return@mapNotNull null - val resolvedTarget = ModTargetResolver.resolveWithin(target, relative) ?: return@mapNotNull null - PlannedFile(installId, file, resolvedTarget) - } - .toList() - } - private fun relativeTargetPath(path: String, gameRootDir: File?, winePrefix: String): String { val target = File(path) val roots = ModTargetResolver.roots(gameRootDir, winePrefix) diff --git a/app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt b/app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt new file mode 100644 index 0000000000..5decb6d565 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt @@ -0,0 +1,19 @@ +package app.gamenative.mods + +object ModDiagnosticSanitizer { + private val urlQuery = Regex("(?i)(https?://[^\\s?#]+)\\?[^\\s#]+") + private val signedQuery = Regex("(?i)([?&](?:token|key|auth|authorization|signature|sig|expires)\\s*=)[^&#\\s]+") + private val windowsPath = Regex("(?i)(?:[A-Z]:[\\\\/])(?:[^\\s\\r\\n]+)") + private val androidPath = Regex("(? "${match.groupValues[1]}?" } + .replace(signedQuery) { match -> "${match.groupValues[1]}" } + .replace(windowsPath, "") + .replace(androidPath, "") + .replace('\n', ' ') + .replace('\r', ' ') + + fun relativePath(value: String): String = + text(value.substringBefore('?')).trim().replace('\\', '/').trimStart('/') +} diff --git a/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt index e4ac037c95..5ccaf1b3c3 100644 --- a/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt +++ b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt @@ -113,19 +113,25 @@ data class ModInstallPlan( files.sortedBy { it.sourceRelativePath.lowercase() }.forEach { file -> append(file.status.name) append(' ') - append(file.sourceRelativePath) + append(ModDiagnosticSanitizer.relativePath(file.sourceRelativePath)) if (file.targetRoot != null && file.targetRelativePath != null) { append(" -> ") append(file.targetRoot) append('/') - append(file.targetRelativePath) + append( + if (file.targetRoot == "CUSTOM_ABSOLUTE") { + "" + } else { + ModDiagnosticSanitizer.relativePath(file.targetRelativePath) + }, + ) } append(" [") - append(file.reason.replace('\n', ' ')) + append(ModDiagnosticSanitizer.text(file.reason)) appendLine(']') } - warnings.sorted().forEach { appendLine("warning: ${it.replace('\n', ' ')}") } - blockingIssues.sorted().forEach { appendLine("blocker: ${it.replace('\n', ' ')}") } + warnings.sorted().forEach { appendLine("warning: ${ModDiagnosticSanitizer.text(it)}") } + blockingIssues.sorted().forEach { appendLine("blocker: ${ModDiagnosticSanitizer.text(it)}") } } } diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index f723af50ba..f827da013c 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -93,7 +93,7 @@ object ModMaterializer { gameRootDir: File?, winePrefix: String, ): List = withContext(Dispatchers.IO) { - val plan = materializationPlan(install, recipes, gameRootDir, winePrefix) + val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) buildList { plan.operations.forEach { entry -> when (entry.mode) { @@ -230,7 +230,7 @@ object ModMaterializer { ): ModPlacementResult = withContext(Dispatchers.IO) { var created = 0 var skipped = 0 - val plan = materializationPlan(install, recipes, gameRootDir, winePrefix) + val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) val errors = linkedMapOf().apply { putAll(plan.errors) } plan.operations.forEach { entry -> @@ -292,7 +292,7 @@ object ModMaterializer { restoredOverwriteTargets: Set = emptySet(), ): List = withContext(Dispatchers.IO) { val skipped = mutableListOf() - val plan = materializationPlan(install, recipes, gameRootDir, winePrefix) + val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) plan.operations.forEach { entry -> runCatching { when (entry.mode) { @@ -327,6 +327,7 @@ object ModMaterializer { recipes: List, gameRootDir: File?, winePrefix: String, + captureTargetHashes: Boolean = true, ): ModMaterializationPlan { val operations = mutableListOf() val errors = linkedMapOf() @@ -338,7 +339,23 @@ object ModMaterializer { errors[key] = error.message ?: error::class.simpleName.orEmpty() } } - val expandedFiles = operations.flatMap(::expandPlannedFiles) + val targetHashes = mutableMapOf() + val targetNamespaces = mutableMapOf() + val expandedFiles = buildList { + operations.forEach { entry -> + val targetNamespace = targetNamespaces.getOrPut(entry.normalizedTargetKey) { + WindowsTargetNamespace(entry.target) + } + runCatching { + expandPlannedFiles(entry, targetNamespace, targetHashes, captureTargetHashes) + } + .onSuccess(::addAll) + .onFailure { error -> + errors[entry.sourceRelativePath.ifBlank { entry.targetRelativePath }] = + error.message ?: error::class.simpleName.orEmpty() + } + } + } val files = expandedFiles.groupBy { it.normalizedTargetKey }.flatMap { (targetKey, values) -> val distinctSources = values.map { it.source.canonicalPath }.distinct() when { @@ -357,13 +374,6 @@ object ModMaterializer { return ModMaterializationPlan(install.installId, operations, files, errors) } - fun plannedEntries( - install: ModInstall, - recipes: List, - gameRootDir: File?, - winePrefix: String, - ): List = materializationPlan(install, recipes, gameRootDir, winePrefix).operations - private fun plannedEntries( install: ModInstall, recipe: ModPlacementRecipe, @@ -472,11 +482,22 @@ object ModMaterializer { ) } - private fun expandPlannedFiles(entry: ModPlannedEntry): List { + private fun expandPlannedFiles( + entry: ModPlannedEntry, + targetNamespace: WindowsTargetNamespace, + targetHashes: MutableMap, + captureTargetHashes: Boolean, + ): List { val files = if (entry.source.isFile) sequenceOf(entry.source) else entry.source.walkTopDown().filter { it.isFile } return files.map { sourceFile -> val nested = if (entry.source.isFile) "" else sourceFile.relativeTo(entry.source).path - val targetFile = if (nested.isBlank()) entry.target else safeChildTarget(entry.target, nested) + val targetFile = if (nested.isBlank()) { + entry.target + } else { + targetNamespace.resolve(nested).takeIf { it.isValid }?.file + ?: throw IOException("Target path escapes or is ambiguous in destination directory: $nested") + } + val targetKey = WindowsPathIdentity.absoluteKey(targetFile) ModPlannedFile( installId = entry.installId, source = sourceFile, @@ -494,7 +515,13 @@ object ModMaterializer { targetRelativePath = listOf(entry.targetRelativePath, nested.replace(File.separatorChar, '/')) .filter(String::isNotBlank) .joinToString("/"), - targetHashBefore = if (targetFile.isFile && !Files.isSymbolicLink(targetFile.toPath())) sha256(targetFile) else "", + targetHashBefore = if ( + captureTargetHashes && targetFile.isFile && !Files.isSymbolicLink(targetFile.toPath()) + ) { + targetHashes.getOrPut(targetKey) { sha256(targetFile) } + } else { + "" + }, ) }.toList() } diff --git a/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt b/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt index eaf8d2fa1b..f23c889f72 100644 --- a/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt +++ b/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt @@ -18,24 +18,7 @@ data class ModPlacementPresetDraft( ) object ModPlacementPresetDetector { - private val bethesdaContentDirs = setOf( - "meshes", - "textures", - "scripts", - "interface", - "sound", - "sounds", - "seq", - "skse", - "f4se", - "sfse", - "strings", - "video", - "music", - "lodsettings", - "calientetools", - "nemesis_engine", - ) + private val bethesdaRule = ModPlacementRulePacks.bethesda fun detect(gameName: String, entries: List): List { if (entries.isEmpty()) return emptyList() @@ -70,7 +53,7 @@ object ModPlacementPresetDetector { else -> "" } return ModPlacementPreset( - id = "bethesda-data", + id = bethesdaRule.stableId, label = "Bethesda Data folder", description = "For Skyrim, Fallout, Oblivion, Morrowind, and Starfield mods.", drafts = listOf( @@ -84,15 +67,17 @@ object ModPlacementPresetDetector { } private fun detectBepInEx(entries: List): ModPlacementPreset? { - val source = entries.findDirectoryPath("BepInEx") ?: return null + val rule = ModPlacementRulePacks.bepInEx + val sourceName = rule.directoryTargets.keys.single() + val source = entries.findDirectoryPath(sourceName) ?: return null return ModPlacementPreset( - id = "bepinex", + id = rule.stableId, label = "BepInEx mod", description = "Places BepInEx plugins, patchers, config, and related folders into BepInEx.", drafts = listOf( ModPlacementPresetDraft( sourceSubpath = source, - targetRelativePath = "BepInEx", + targetRelativePath = rule.directoryTargets.getValue(sourceName), includeSourceDirectory = false, ), ), @@ -100,19 +85,19 @@ object ModPlacementPresetDetector { } private fun detectMelonLoader(entries: List): ModPlacementPreset? { - val drafts = listOf("Mods", "UserData", "Plugins") - .mapNotNull { name -> - entries.findDirectoryPath(name)?.let { source -> - ModPlacementPresetDraft( - sourceSubpath = source, - targetRelativePath = name, - includeSourceDirectory = false, - ) - } + val rule = ModPlacementRulePacks.melonLoader + val drafts = rule.directoryTargets.mapNotNull { (sourceName, target) -> + entries.findDirectoryPath(sourceName)?.let { source -> + ModPlacementPresetDraft( + sourceSubpath = source, + targetRelativePath = target, + includeSourceDirectory = false, + ) } + } if (drafts.isEmpty()) return null return ModPlacementPreset( - id = "melonloader", + id = rule.stableId, label = "MelonLoader mod", description = "Places MelonLoader Mods, Plugins, or UserData folders into the game folder.", drafts = drafts, @@ -120,6 +105,7 @@ object ModPlacementPresetDetector { } private fun detectUnreal(entries: List): ModPlacementPreset? { + val rule = ModPlacementRulePacks.unreal val contentPaks = entries.findDirectoryPath("Content/Paks") val paks = entries.findDirectoryPath("Paks") val loosePakFiles = entries @@ -127,7 +113,7 @@ object ModPlacementPresetDetector { .map { it.path } .filter { path -> path.count { it == '/' } == 0 && - listOf(".pak", ".ucas", ".utoc").any { path.endsWith(it, ignoreCase = true) } + path.substringAfterLast('.', "").lowercase(Locale.ROOT) in rule.looseExtensions } val source = when { @@ -137,7 +123,7 @@ object ModPlacementPresetDetector { else -> return null } return ModPlacementPreset( - id = "unreal-paks", + id = rule.stableId, label = "Unreal Engine Paks", description = "Places Pak, UCAS, and UTOC files into Content/Paks.", drafts = listOf( @@ -154,19 +140,11 @@ object ModPlacementPresetDetector { gameName: String, entries: List, ): ModPlacementPreset? { - val looksLikeCyberpunk = gameName.lowercase(Locale.US).let { name -> - name.contains("cyberpunk") || name.contains("redmod") - } + val rule = ModPlacementRulePacks.redmod + val looksLikeCyberpunk = gameName.lowercase(Locale.US).let { name -> rule.gameNameTokens.any(name::contains) } if (!looksLikeCyberpunk) return null - val targets = listOf( - "archive/pc/mod", - "r6", - "red4ext", - "bin/x64/plugins", - "mods", - ) - val drafts = targets.mapNotNull { target -> - entries.findDirectoryPath(target)?.let { source -> + val drafts = rule.directoryTargets.mapNotNull { (sourcePath, target) -> + entries.findDirectoryPath(sourcePath)?.let { source -> ModPlacementPresetDraft( sourceSubpath = source, targetRelativePath = target, @@ -176,7 +154,7 @@ object ModPlacementPresetDetector { } if (drafts.isEmpty()) return null return ModPlacementPreset( - id = "redmod", + id = rule.stableId, label = "Cyberpunk / REDmod", description = "Places archive, r6, red4ext, bin plugin, or REDmod folders into the game.", drafts = drafts, @@ -210,7 +188,7 @@ object ModPlacementPresetDetector { val roots = mapNotNull { entry -> val path = normalizePath(entry.path) val segments = path.split('/').filter { it.isNotBlank() } - val contentIndex = segments.indexOfFirst { it.lowercase(Locale.US) in bethesdaContentDirs } + val contentIndex = segments.indexOfFirst { it.lowercase(Locale.US) in bethesdaRule.directoryTargets } when { contentIndex == 0 -> segments.first() contentIndex > 0 -> segments.take(contentIndex).joinToString("/") @@ -230,11 +208,11 @@ object ModPlacementPresetDetector { val normalized = normalizePath(source) return normalized.isNotBlank() && !normalized.contains("/") && - normalized.lowercase(Locale.US) in bethesdaContentDirs + normalized.lowercase(Locale.US) in bethesdaRule.directoryTargets } private fun String.endsWithBethesdaDataFile(): Boolean = - listOf(".esp", ".esm", ".esl", ".bsa", ".ba2").any { endsWith(it, ignoreCase = true) } + substringAfterLast('.', "").lowercase(Locale.US) in bethesdaRule.looseExtensions private fun normalizePath(path: String): String = path.replace('\\', '/') diff --git a/app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt b/app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt new file mode 100644 index 0000000000..1ba82f64af --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt @@ -0,0 +1,41 @@ +package app.gamenative.mods + +data class ModPlacementRulePack( + val stableId: String, + val version: Int, + val directoryTargets: Map = emptyMap(), + val looseExtensions: Set = emptySet(), + val gameNameTokens: Set = emptySet(), +) + +object ModPlacementRulePacks { + val bethesda = ModPlacementRulePack( + stableId = "bethesda-data", + version = 1, + directoryTargets = setOf( + "meshes", "textures", "scripts", "interface", "sound", "sounds", "strings", "skse", "f4se", + "sfse", "seq", "video", "music", "lodsettings", "calientetools", "nemesis_engine", + ).associateWith { "Data" }, + looseExtensions = setOf("esp", "esm", "esl", "bsa", "ba2"), + ) + val bepInEx = ModPlacementRulePack("bepinex", 1, mapOf("BepInEx" to "BepInEx")) + val melonLoader = ModPlacementRulePack( + "melonloader", + 1, + setOf("Mods", "UserData", "Plugins").associateWith { it }, + ) + val unreal = ModPlacementRulePack( + "unreal-paks", + 1, + mapOf("Content/Paks" to "Content/Paks", "Paks" to "Content/Paks"), + setOf("pak", "ucas", "utoc"), + ) + val redmod = ModPlacementRulePack( + "redmod", + 1, + setOf("archive/pc/mod", "r6", "red4ext", "bin/x64/plugins", "mods").associateWith { it }, + gameNameTokens = setOf("cyberpunk", "redmod"), + ) + + val archiveSemanticAnchors: Set = bethesda.directoryTargets.keys +} diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index b7fda3ed80..db683abc13 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -79,6 +79,21 @@ data class ModHealthReport( ) { val errorCount: Int get() = issues.count { it.severity == ModHealthSeverity.ERROR } val warningCount: Int get() = issues.count { it.severity == ModHealthSeverity.WARNING } + + fun sanitizedManifest(): String = buildString { + appendLine("health-version: 1") + appendLine("errors: $errorCount") + appendLine("warnings: $warningCount") + issues.forEach { issue -> + append(issue.severity.name) + append(' ') + if (issue.installName.isNotBlank()) append("${ModDiagnosticSanitizer.text(issue.installName)}: ") + append(ModDiagnosticSanitizer.text(issue.title)) + append(" [") + append(ModDiagnosticSanitizer.text(issue.detail)) + appendLine(']') + } + } } object NexusModManager { @@ -691,31 +706,6 @@ object NexusModManager { PrefManager.nexusLastPlacementJson = root.toString() } - private fun samePlacementRecipes( - first: List, - second: List, - ): Boolean = - first.map(::recipeKey).sorted() == second.map(::recipeKey).sorted() - - private fun recipeKey(recipe: ModPlacementRecipe): String = - listOf( - recipe.sourceSubpath, - recipe.targetRoot, - normalizedRecipeTarget(recipe).lowercase(), - recipe.targetFileName.lowercase(), - recipe.mode, - recipe.stripPrefixSegments.toString(), - recipe.includeSourceDirectory.toString(), - recipe.enabled.toString(), - ).joinToString("|") - - private fun normalizedRecipeTarget(recipe: ModPlacementRecipe): String = - if (recipe.targetRoot == ModTargetRoot.CUSTOM_ABSOLUTE.name) { - recipe.targetRelativePath.trim().replace('\\', '/') - } else { - ModTargetResolver.normalizeRelativePath(recipe.targetRelativePath) - } - suspend fun disableInstall( context: Context, install: ModInstall, @@ -1359,39 +1349,25 @@ object NexusModManager { winePrefix: String, ): List { val missing = mutableListOf() - recipes.filter { it.enabled }.forEach { recipe -> - val mode = runCatching { ModPlacementMode.valueOf(recipe.mode) }.getOrDefault(ModPlacementMode.SYMLINK) - val entries = runCatching { - ModMaterializer.plannedEntries(install, listOf(recipe), gameRootDir, winePrefix) - }.getOrElse { e -> - missing += e.message ?: "${recipe.targetRoot}:${recipe.targetRelativePath}" - return@forEach - } - entries.forEach { entry -> - missing += missingTargetsForEntry(entry, mode) - if (missing.size >= 3) return missing + val plan = ModMaterializer.materializationPlan( + install, + recipes, + gameRootDir, + winePrefix, + captureTargetHashes = false, + ) + missing += plan.errors.values + plan.operations.filter { it.mode == ModPlacementMode.SYMLINK }.forEach { entry -> + if (!Files.isSymbolicLink(entry.target.toPath()) && !entry.target.exists()) { + missing += entry.target.absolutePath } + if (missing.size >= 3) return missing.take(3) } - return missing - } - - private fun missingTargetsForEntry(entry: ModPlannedEntry, mode: ModPlacementMode): List { - if (mode == ModPlacementMode.SYMLINK) { - return if (Files.isSymbolicLink(entry.target.toPath()) || entry.target.exists()) emptyList() else listOf(entry.target.absolutePath) - } - if (entry.source.isFile) { - return if (entry.target.isFile) emptyList() else listOf(entry.target.absolutePath) + plan.files.filter { it.mode != ModPlacementMode.SYMLINK }.forEach { file -> + if (!file.target.isFile) missing += file.target.absolutePath + if (missing.size >= 3) return missing.take(3) } - if (!entry.source.isDirectory) return emptyList() - return entry.source.walkTopDown() - .filter { it.isFile } - .take(50) - .mapNotNull { sourceFile -> - val relative = sourceFile.relativeTo(entry.source).path - File(entry.target, relative).takeUnless { it.isFile }?.absolutePath - } - .take(3) - .toList() + return missing } private fun partialFileFor(archiveFile: File): File? = diff --git a/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt index 27f53ab800..81c17648ee 100644 --- a/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt +++ b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt @@ -18,6 +18,7 @@ class WindowsTargetNamespace( ) { private val root = root.canonicalFile private val listingCache = mutableMapOf>>() + private val plannedChildren = mutableMapOf>() fun resolve(relativePath: String): WindowsTargetResolution { val segments = WindowsPathIdentity.relativeSegments(relativePath) @@ -26,12 +27,12 @@ class WindowsTargetNamespace( val caseMerges = mutableListOf() val ambiguities = mutableListOf() - segments.forEachIndexed { index, requested -> + for ((index, requested) in segments.withIndex()) { val matches = childrenByWindowsName(current)[WindowsPathIdentity.segmentKey(requested)].orEmpty() when { matches.size > 1 -> { ambiguities += segments.take(index + 1).joinToString("/") - return@forEachIndexed + break } matches.size == 1 -> { val existing = matches.single() @@ -41,7 +42,21 @@ class WindowsTargetNamespace( } current = existing } - else -> current = File(current, requested) + else -> { + val parentKey = directoryKey(current) + val requestedKey = WindowsPathIdentity.segmentKey(requested) + val planned = plannedChildren[parentKey]?.get(requestedKey) + if (planned != null) { + if (planned.name != requested) { + caseMerges += "${segments.take(index).joinToString("/")}/$requested -> ${planned.name}" + .trimStart('/') + } + current = planned + } else { + current = File(current, requested) + plannedChildren.getOrPut(parentKey, ::mutableMapOf)[requestedKey] = current + } + } } } @@ -55,10 +70,11 @@ class WindowsTargetNamespace( fun invalidate() { listingCache.clear() + plannedChildren.clear() } private fun childrenByWindowsName(dir: File): Map> { - val key = runCatching { dir.canonicalPath }.getOrDefault(dir.absolutePath) + val key = directoryKey(dir) return listingCache.getOrPut(key) { if (!dir.isDirectory) { emptyMap() @@ -67,6 +83,9 @@ class WindowsTargetNamespace( } } } + + private fun directoryKey(dir: File): String = + WindowsPathIdentity.absoluteKey(runCatching { dir.canonicalFile }.getOrDefault(dir.absoluteFile)) } object WindowsPathIdentity { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 5a6a5adf09..59a89af917 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -657,6 +657,7 @@ private fun InstallHealthSection( onCheck: () -> Unit, onRebuild: () -> Unit, onReconfigure: (String) -> Unit, + onExport: (ModHealthReport) -> Unit, ) { NexusSectionCard { NexusSectionHeader(stringResource(R.string.nexus_install_health_title), loading, stringResource(R.string.nexus_check), onCheck) @@ -674,6 +675,9 @@ private fun InstallHealthSection( OutlinedButton(onClick = onRebuild, enabled = !loading, modifier = Modifier.fillMaxWidth()) { Text(stringResource(R.string.nexus_apply_order)) } + OutlinedButton(onClick = { onExport(current) }, enabled = !loading, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.nexus_plan_export)) + } current.issues.take(8).forEach { issue -> Column(verticalArrangement = Arrangement.spacedBy(2.dp)) { val titleColor = if (issue.severity == ModHealthSeverity.ERROR) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface @@ -3017,12 +3021,12 @@ fun NexusModsDialog( } } - fun exportPlacementPlan(install: ModInstall, plan: ModInstallPlan) { + fun shareDiagnostic(fileName: String, content: String) { scope.launch { val file = withContext(Dispatchers.IO) { val outputDir = File(context.cacheDir, "mod-diagnostics").apply { mkdirs() } - File(outputDir, "placement-${install.installId.replace(Regex("[^A-Za-z0-9._-]"), "_")}.txt").apply { - writeText(plan.sanitizedManifest()) + File(outputDir, fileName.replace(Regex("[^A-Za-z0-9._-]"), "_")).apply { + writeText(content) } } val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file) @@ -3035,6 +3039,12 @@ fun NexusModsDialog( } } + fun exportPlacementPlan(install: ModInstall, plan: ModInstallPlan) = + shareDiagnostic("placement-${install.installId}.txt", plan.sanitizedManifest()) + + fun exportHealthReport(report: ModHealthReport) = + shareDiagnostic("mod-health-${libraryItem.appId}.txt", report.sanitizedManifest()) + val issueCount = conflictReports.size + bethesdaPluginIssues.size + bethesdaPluginAssetIssues.size + (healthReport?.issues?.size ?: 0) fun selectInstallForPlacement(install: ModInstall) { @@ -3355,6 +3365,7 @@ fun NexusModsDialog( installs.firstOrNull { it.installId == installId }?.let(::selectInstallForPlacement) selectedTab = ManageModsTab.PLACEMENT }, + onExport = ::exportHealthReport, ) StorageCleanupSection( breakdown = storageBreakdown, diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 53a4e123a8..a8ccc10338 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2232,4 +2232,12 @@ Føjet til favoritter Føjede %1$s til favoritter VR-opdateringsfrekvens + Gennemse placering + %1$d af %2$d filer planlagt • %3$d ignoreret • %4$d kræver gennemgang + Rangerede forslag + %1$d. %2$s — %3$d%% dækning + Sammenfletning af store/små bogstaver: %1$s + tvetydige varianter med store/små bogstaver findes allerede + Automatisk anvendelse er blokeret, indtil alle installerbare filer har en sikker destination. + Del diagnosticering diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index d7f661002e..d03bf3698b 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2302,4 +2302,12 @@ Zu Favoriten hinzugefügt %1$s zu Favoriten hinzugefügt VR-Bildwiederholrate + Platzierung prüfen + %1$d von %2$d Dateien geplant • %3$d ignoriert • %4$d zu prüfen + Sortierte Vorschläge + %1$d. %2$s — %3$d%% Abdeckung + Groß-/Kleinschreibung zusammengeführt: %1$s + mehrdeutige Varianten der Groß-/Kleinschreibung sind bereits vorhanden + Die automatische Anwendung ist blockiert, bis jede installierbare Datei ein eindeutiges Ziel hat. + Diagnose teilen diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 82dde47ce2..78d4b190f9 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2360,4 +2360,12 @@ Añadido a favoritos %1$s añadido a favoritos Frecuencia de actualización de RV + Revisión de ubicación + %1$d de %2$d archivos planificados • %3$d ignorados • %4$d por revisar + Sugerencias clasificadas + %1$d. %2$s — %3$d%% de cobertura + Unificación de mayúsculas: %1$s + ya existen variantes ambiguas de mayúsculas y minúsculas + La aplicación automática está bloqueada hasta que cada archivo instalable tenga un destino comprobado. + Compartir diagnóstico diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 928934755d..d7a006c8f9 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2362,4 +2362,12 @@ Ajouté aux favoris %1$s ajouté aux favoris Taux de rafraîchissement VR + Vérification du placement + %1$d fichiers planifiés sur %2$d • %3$d ignorés • %4$d à vérifier + Suggestions classées + %1$d. %2$s — couverture de %3$d%% + Fusion de casse : %1$s + des variantes de casse ambiguës existent déjà + L’application automatique est bloquée tant que chaque fichier installable n’a pas de destination vérifiée. + Partager le diagnostic diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 1675941165..1be7bab2d5 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2353,4 +2353,12 @@ Aggiunto ai preferiti %1$s aggiunto ai preferiti Frequenza di aggiornamento VR + Revisione posizionamento + %1$d file pianificati su %2$d • %3$d ignorati • %4$d da verificare + Suggerimenti classificati + %1$d. %2$s — copertura %3$d%% + Unione maiuscole/minuscole: %1$s + esistono già varianti ambigue di maiuscole/minuscole + L’applicazione automatica è bloccata finché ogni file installabile non ha una destinazione verificata. + Condividi diagnostica diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index b8d6f6dab9..bf64e0f30d 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2316,4 +2316,12 @@ お気に入りに追加しました %1$s をお気に入りに追加しました VRリフレッシュレート + 配置の確認 + %2$d 個中 %1$d 個のファイルを計画 • %3$d 個を除外 • %4$d 個を要確認 + 候補ランキング + %1$d. %2$s — カバー率 %3$d%% + 大文字小文字を統合: %1$s + 大文字小文字だけが異なる曖昧な項目がすでに存在します + インストール可能なすべてのファイルの配置先が確認されるまで、自動適用はブロックされます。 + 診断情報を共有 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index bd259d8e18..2f1b4ed307 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2357,4 +2357,12 @@ 즐겨찾기에 추가됨 %1$s을(를) 즐겨찾기에 추가함 VR 재생 빈도 + 배치 검토 + 파일 %2$d개 중 %1$d개 계획됨 • %3$d개 제외됨 • %4$d개 검토 필요 + 순위별 제안 + %1$d. %2$s — 포함률 %3$d%% + 대소문자 병합: %1$s + 대소문자만 다른 모호한 항목이 이미 있습니다 + 설치 가능한 모든 파일의 대상 위치가 확인될 때까지 자동 적용이 차단됩니다. + 진단 공유 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 131fe34821..f52fb61ab8 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2366,4 +2366,12 @@ Dodano do ulubionych Dodano %1$s do ulubionych Częstotliwość odświeżania VR + Przegląd rozmieszczenia + Zaplanowano %1$d z %2$d plików • pominięto %3$d • %4$d do sprawdzenia + Uszeregowane sugestie + %1$d. %2$s — pokrycie %3$d%% + Scalenie wielkości liter: %1$s + istnieją już niejednoznaczne warianty wielkości liter + Automatyczne zastosowanie jest zablokowane, dopóki każdy plik instalacyjny nie ma potwierdzonego miejsca docelowego. + Udostępnij diagnostykę diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 94708d1101..bde7321aab 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2232,4 +2232,12 @@ Adicionado aos favoritos %1$s adicionado aos favoritos Taxa de atualização de VR + Revisão do posicionamento + %1$d de %2$d arquivos planejados • %3$d ignorados • %4$d para revisar + Sugestões classificadas + %1$d. %2$s — %3$d%% de cobertura + Mesclagem de maiúsculas/minúsculas: %1$s + já existem variantes ambíguas de maiúsculas e minúsculas + A aplicação automática está bloqueada até que cada arquivo instalável tenha um destino comprovado. + Compartilhar diagnóstico diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 2987833fa3..a96a5ecf8b 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2366,4 +2366,12 @@ Adăugat la favorite %1$s adăugat la favorite Rată de reîmprospătare VR + Verificarea amplasării + %1$d din %2$d fișiere planificate • %3$d ignorate • %4$d de verificat + Sugestii clasificate + %1$d. %2$s — acoperire %3$d%% + Îmbinare majuscule/minuscule: %1$s + există deja variante ambigue de majuscule/minuscule + Aplicarea automată este blocată până când fiecare fișier instalabil are o destinație verificată. + Partajează diagnosticul diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 69b69abd4d..745853930a 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2294,4 +2294,12 @@ https://gamenative.app Добавлено в избранное %1$s добавлено в избранное Частота обновления VR + Проверка размещения + Запланировано файлов: %1$d из %2$d • пропущено: %3$d • требуют проверки: %4$d + Ранжированные предложения + %1$d. %2$s — покрытие %3$d%% + Объединение регистра: %1$s + уже существуют неоднозначные варианты регистра + Автоматическое применение заблокировано, пока для каждого устанавливаемого файла не подтверждено место назначения. + Поделиться диагностикой diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 7f009af0b5..db0345d3fb 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2362,4 +2362,12 @@ Додано до вибраного %1$s додано до вибраного Частота оновлення VR + Перевірка розміщення + Заплановано файлів: %1$d із %2$d • пропущено: %3$d • потребують перевірки: %4$d + Ранжовані пропозиції + %1$d. %2$s — покриття %3$d%% + Об’єднання регістру: %1$s + неоднозначні варіанти регістру вже існують + Автоматичне застосування заблоковано, доки для кожного встановлюваного файлу не підтверджено місце призначення. + Поділитися діагностикою diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 710e7dd7fa..1d81e68e31 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2377,4 +2377,12 @@ 已添加到收藏 已将 %1$s 添加到收藏 VR 刷新率 + 放置审核 + 已规划 %1$d/%2$d 个文件 • 已忽略 %3$d 个 • %4$d 个需要审核 + 建议排名 + %1$d. %2$s — 覆盖率 %3$d%% + 大小写合并：%1$s + 已存在大小写不明确的变体 + 在每个可安装文件都有明确目标位置之前，自动应用将被阻止。 + 分享诊断信息 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 9243ca7656..c6d7b9d3c7 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2368,4 +2368,12 @@ 已加入收藏 已將 %1$s 加入收藏 VR 重新整理頻率 + 放置檢查 + 已規劃 %1$d/%2$d 個檔案 • 已忽略 %3$d 個 • %4$d 個需要檢查 + 建議排名 + %1$d. %2$s — 涵蓋率 %3$d%% + 大小寫合併：%1$s + 已存在大小寫不明確的變體 + 在每個可安裝檔案都有明確目的地之前，自動套用將被封鎖。 + 分享診斷資訊 diff --git a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt new file mode 100644 index 0000000000..5ec51f6940 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt @@ -0,0 +1,26 @@ +package app.gamenative.mods + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Test +import kotlin.system.measureTimeMillis + +class ModArchiveIndexPerformanceTest { + @Test + fun fiftyThousandEntries_indexWithinGenerousRegressionBudget() { + val entries = List(50_000) { index -> + ModArchiveEntry( + path = "Data/Textures/Set${index / 100}/texture$index.dds", + directory = false, + sizeBytes = 1, + ) + } + lateinit var archiveIndex: ModArchiveIndex + + val elapsed = measureTimeMillis { archiveIndex = ModArchiveIndex.build(entries) } + + assertEquals(50_000, archiveIndex.files.size) + assertEquals(100, archiveIndex.filesUnder("Data/Textures/Set42").size) + assertTrue("Indexing took ${elapsed}ms", elapsed < 15_000) + } +} diff --git a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt index 5db9ca005e..1efa9b81da 100644 --- a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt @@ -36,6 +36,18 @@ class ModInstallPlanContractTest { assertEquals(first.digest, second.digest) } + @Test + fun diagnosticSanitizer_removesCredentialsAndAbsolutePaths() { + val sanitized = ModDiagnosticSanitizer.text( + "C:\\Games\\Skyrim\\Data https://example.invalid/file?X-Amz-Credential=secret&X-Amz-Signature=123 " + + "/data/user/0/app/file", + ) + + assertFalse("secret" in sanitized) + assertFalse("C:\\Games" in sanitized) + assertFalse("/data/user" in sanitized) + } + private fun plan( placed: List, ignored: List = emptyList(), diff --git a/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt b/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt index e37721a48d..b981a4c9f4 100644 --- a/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModTargetResolverTest.kt @@ -125,6 +125,21 @@ class ModTargetResolverTest { assertTrue(inspection.ambiguousPaths.isEmpty()) } + @Test + fun inspectPlan_reusesPlannedDirectoryCasing() { + val plan = ModInstallPlan( + files = listOf( + plannedFile("Data/Scripts/First.pex"), + plannedFile("data/scripts/Second.pex"), + ), + ) + + val inspection = ModTargetResolver.inspectPlan(plan, ModTargetResolver.roots(gameDir, winePrefix.absolutePath)) + + assertTrue(inspection.caseMerges.any { it.contains("scripts -> Scripts") }) + assertTrue(inspection.ambiguousPaths.isEmpty()) + } + @Test fun resolve_blocksAmbiguousExistingCaseVariants() { File(gameDir, "Data/Scripts").mkdirs() @@ -176,4 +191,14 @@ class ModTargetResolverTest { assertEquals(File(emptyPrefix, "drive_c/users/steamuser").canonicalFile, userHome.canonicalFile) assertTrue(userHome.isDirectory) } + + private fun plannedFile(path: String) = PlannedModFile( + sourceRelativePath = path, + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = path, + normalizedTargetKey = ModTargetResolver.normalizedTargetKey(ModTargetRoot.GAME_DIR.name, path), + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.GAME_RULE, + reason = "fixture", + ) } From df7725ef998e2917503294f81f388ad4f8b17b46 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 13:40:12 -0500 Subject: [PATCH 18/60] style: normalize placement formatting --- .../mods/AutomaticPlacementPlanner.kt | 3 +- .../app/gamenative/mods/FomodAutoSelector.kt | 12 +- .../gamenative/mods/FomodInstallPlanner.kt | 8 +- .../app/gamenative/mods/FomodInstaller.kt | 26 ++- .../mods/GenericOptionSetDetector.kt | 3 +- .../gamenative/mods/ModDeploymentJournal.kt | 14 +- .../app/gamenative/mods/ModMaterializer.kt | 159 +++++++++--------- .../gamenative/mods/ModOwnershipManifest.kt | 16 +- .../gamenative/mods/WindowsTargetNamespace.kt | 2 +- .../dialog/NexusModsFomodSections.kt | 9 +- .../gamenative/mods/FomodEnvironmentTest.kt | 4 +- .../mods/ModArchiveIndexPerformanceTest.kt | 2 +- .../mods/ModDeploymentJournalTest.kt | 8 +- .../mods/ModOwnershipManifestTest.kt | 2 +- 14 files changed, 157 insertions(+), 111 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index 8241fd3dc1..1e1042c775 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -203,7 +203,8 @@ object AutomaticPlacementPlanner { placedBySource[file.normalizedKey] ?: when (file.role) { ArchiveContentRole.DOCUMENTATION, ArchiveContentRole.METADATA, - ArchiveContentRole.INSTALLER_SUPPORT -> PlannedModFile( + ArchiveContentRole.INSTALLER_SUPPORT, + -> PlannedModFile( sourceRelativePath = file.displayPath, status = PlannedFileStatus.INTENTIONALLY_IGNORED, origin = origin, diff --git a/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt b/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt index c9302aa472..45c5884bf3 100644 --- a/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt +++ b/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt @@ -19,11 +19,19 @@ object FomodAutoSelector { environment: FomodEnvironmentSnapshot = FomodEnvironmentSnapshot(), ): FomodAutoSelectionResult? { if (installer.unsupportedWarnings.isNotEmpty()) return null - if (installer.steps.any { step -> step.groups.any { group -> group.plugins.any { it.typePatterns.isNotEmpty() } } }) { + val hasDynamicPluginTypes = installer.steps.any { step -> + step.groups.any { group -> + group.plugins.any { plugin -> plugin.typePatterns.isNotEmpty() } + } + } + if (hasDynamicPluginTypes) { return null } if (installer.moduleDependencies.evaluate(emptyMap(), environment) != FomodFactState.TRUE) return null - if (installer.conditionalFileInstalls.any { it.dependencies.evaluate(emptyMap(), environment) == FomodFactState.UNKNOWN }) return null + val hasUnknownConditionalFiles = installer.conditionalFileInstalls.any { conditional -> + conditional.dependencies.evaluate(emptyMap(), environment) == FomodFactState.UNKNOWN + } + if (hasUnknownConditionalFiles) return null val selectedKeys = linkedSetOf() val selectedLabels = mutableListOf() diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 5499595423..6cee22427b 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -75,8 +75,12 @@ object FomodSelectionEvaluator { } private fun FomodDependencyExpression.hasFacts(): Boolean = - flagDependencies.isNotEmpty() || fileDependencies.isNotEmpty() || pluginDependencies.isNotEmpty() || - gameDependencies.isNotEmpty() || childGroups.isNotEmpty() || unsupportedDependencyCount > 0 + flagDependencies.isNotEmpty() || + fileDependencies.isNotEmpty() || + pluginDependencies.isNotEmpty() || + gameDependencies.isNotEmpty() || + childGroups.isNotEmpty() || + unsupportedDependencyCount > 0 } object FomodPlanExpander { diff --git a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt index a5bd2de8d6..6f4a13ee70 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt @@ -273,21 +273,35 @@ object FomodParser { child.tagName.equals("flagDependency", ignoreCase = true) -> { val flag = child.attr("flag").trim() val value = child.attr("value").trim() - if (flag.isBlank()) unsupportedCount++ else flagDependencies += FomodFlagDependency(flag, value) + if (flag.isBlank()) { + unsupportedCount++ + } else { + flagDependencies += FomodFlagDependency(flag, value) + } } child.tagName.equals("fileDependency", ignoreCase = true) -> { val file = child.attr("file").trim().replace('\\', '/') - if (file.isBlank()) unsupportedCount++ else fileDependencies += - FomodFileDependency(file, requiredFileState(child.attr("state"))) + if (file.isBlank()) { + unsupportedCount++ + } else { + fileDependencies += FomodFileDependency(file, requiredFileState(child.attr("state"))) + } } child.tagName.equals("pluginDependency", ignoreCase = true) -> { val plugin = child.attr("plugin").ifBlank { child.attr("file") }.trim() - if (plugin.isBlank()) unsupportedCount++ else pluginDependencies += - FomodPluginDependency(plugin, requiredFileState(child.attr("state"))) + if (plugin.isBlank()) { + unsupportedCount++ + } else { + pluginDependencies += FomodPluginDependency(plugin, requiredFileState(child.attr("state"))) + } } child.tagName.equals("gameDependency", ignoreCase = true) -> { val version = child.attr("version").trim() - if (version.isBlank()) unsupportedCount++ else gameDependencies += FomodGameDependency(version) + if (version.isBlank()) { + unsupportedCount++ + } else { + gameDependencies += FomodGameDependency(version) + } } child.tagName.equals("dependencies", ignoreCase = true) -> childGroups += parseDependencies(child) child.tagName.endsWith("Dependency", ignoreCase = true) -> unsupportedCount++ diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt index cb85cc247c..33353a8c6d 100644 --- a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -52,7 +52,8 @@ object GenericOptionSetDetector { val peers = choices.filter { it != root } GenericOptionChoice( sourceDirectory = root.displayPath, - overlappingTargetCount = peers.maxOfOrNull { signatures.getValue(root).intersect(signatures.getValue(it)).size } ?: 0, + overlappingTargetCount = + peers.maxOfOrNull { signatures.getValue(root).intersect(signatures.getValue(it)).size } ?: 0, ) }, commonSourceDirectories = common, diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt index c625cc4cfd..e2f51ed23d 100644 --- a/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt @@ -1,14 +1,14 @@ package app.gamenative.mods -import kotlinx.serialization.Serializable -import kotlinx.serialization.decodeFromString -import kotlinx.serialization.encodeToString -import kotlinx.serialization.json.Json import java.io.File import java.io.FileOutputStream import java.nio.file.Files import java.nio.file.StandardCopyOption import java.util.UUID +import kotlinx.serialization.Serializable +import kotlinx.serialization.decodeFromString +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json @Serializable enum class ModDeploymentCheckpoint { @@ -72,7 +72,8 @@ object ModDeploymentJournalStore { fun reconcile(root: File): List = readAll(root).map { journal -> when (journal.checkpoint) { ModDeploymentCheckpoint.PLANNED, - ModDeploymentCheckpoint.PREPARING -> checkpoint( + ModDeploymentCheckpoint.PREPARING, + -> checkpoint( root, journal, ModDeploymentCheckpoint.ROLLED_BACK, @@ -90,7 +91,8 @@ object ModDeploymentJournalStore { } } ModDeploymentCheckpoint.APPLYING, - ModDeploymentCheckpoint.ROLLING_BACK -> checkpoint( + ModDeploymentCheckpoint.ROLLING_BACK, + -> checkpoint( root, journal, ModDeploymentCheckpoint.RECOVERY_REQUIRED, diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index f827da013c..e3d25d2d5a 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -96,24 +96,24 @@ object ModMaterializer { val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) buildList { plan.operations.forEach { entry -> - when (entry.mode) { - ModPlacementMode.OVERWRITE_COPY -> addAll(overwriteConflicts(entry)) - else -> { - if (entry.target.exists() || Files.isSymbolicLink(entry.target.toPath())) { - val alreadyCorrectSymlink = Files.isSymbolicLink(entry.target.toPath()) && - resolveSymlinkTarget(entry.target)?.canonicalFile == entry.source.canonicalFile - if (!alreadyCorrectSymlink) { - add( - ModPlacementConflict( - sourcePath = entry.source.absolutePath, - targetPath = entry.target.absolutePath, - directory = entry.source.isDirectory, - ), - ) - } + when (entry.mode) { + ModPlacementMode.OVERWRITE_COPY -> addAll(overwriteConflicts(entry)) + else -> { + if (entry.target.exists() || Files.isSymbolicLink(entry.target.toPath())) { + val alreadyCorrectSymlink = Files.isSymbolicLink(entry.target.toPath()) && + resolveSymlinkTarget(entry.target)?.canonicalFile == entry.source.canonicalFile + if (!alreadyCorrectSymlink) { + add( + ModPlacementConflict( + sourcePath = entry.source.absolutePath, + targetPath = entry.target.absolutePath, + directory = entry.source.isDirectory, + ), + ) } } } + } } } } @@ -190,33 +190,33 @@ object ModMaterializer { backupRoot.mkdirs() plan.operations.forEach { entry -> - try { - when (entry.mode) { - ModPlacementMode.SYMLINK -> { - val result = ensureSymlink(entry.target, entry.source) - if (result) created++ else skipped++ - } - ModPlacementMode.COPY -> { - val result = copyWithoutOverwrite(entry.target, entry.source, install.installId) - if (result) created++ else skipped++ - } - ModPlacementMode.OVERWRITE_COPY -> { - val result = copyWithBackups( - install = install, - target = entry.target, - source = entry.source, - backupRoot = backupRoot, - allowOverwrite = allowOverwrite, - targetsWrittenThisApply = targetsWrittenThisApply, - ) - created += result.created - backedUp += result.backedUp - manifests += result.manifests - } + try { + when (entry.mode) { + ModPlacementMode.SYMLINK -> { + val result = ensureSymlink(entry.target, entry.source) + if (result) created++ else skipped++ + } + ModPlacementMode.COPY -> { + val result = copyWithoutOverwrite(entry.target, entry.source, install.installId) + if (result) created++ else skipped++ + } + ModPlacementMode.OVERWRITE_COPY -> { + val result = copyWithBackups( + install = install, + target = entry.target, + source = entry.source, + backupRoot = backupRoot, + allowOverwrite = allowOverwrite, + targetsWrittenThisApply = targetsWrittenThisApply, + ) + created += result.created + backedUp += result.backedUp + manifests += result.manifests } - } catch (e: Exception) { - errors[entry.target.absolutePath] = "${e::class.simpleName}: ${e.message}" } + } catch (e: Exception) { + errors[entry.target.absolutePath] = "${e::class.simpleName}: ${e.message}" + } } ModPlacementResult(created, skipped, backedUp, errors, manifests) @@ -234,27 +234,28 @@ object ModMaterializer { val errors = linkedMapOf().apply { putAll(plan.errors) } plan.operations.forEach { entry -> - try { - when (entry.mode) { - ModPlacementMode.SYMLINK -> { - if (entry.target.exists() || Files.isSymbolicLink(entry.target.toPath())) { - skipped++ - } else if (ensureSymlink(entry.target, entry.source)) { - created++ - } else { - skipped++ - } - } - ModPlacementMode.COPY, - ModPlacementMode.OVERWRITE_COPY -> { - val result = copyMissingFiles(entry.target, entry.source) - created += result.created - skipped += result.skipped + try { + when (entry.mode) { + ModPlacementMode.SYMLINK -> { + if (entry.target.exists() || Files.isSymbolicLink(entry.target.toPath())) { + skipped++ + } else if (ensureSymlink(entry.target, entry.source)) { + created++ + } else { + skipped++ } } - } catch (e: Exception) { - errors[entry.target.absolutePath] = "${e::class.simpleName}: ${e.message}" + ModPlacementMode.COPY, + ModPlacementMode.OVERWRITE_COPY, + -> { + val result = copyMissingFiles(entry.target, entry.source) + created += result.created + skipped += result.skipped + } } + } catch (e: Exception) { + errors[entry.target.absolutePath] = "${e::class.simpleName}: ${e.message}" + } } ModPlacementResult(created, skipped, backedUp = 0, errors = errors, manifests = emptyList()) @@ -295,27 +296,27 @@ object ModMaterializer { val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) plan.operations.forEach { entry -> runCatching { - when (entry.mode) { - ModPlacementMode.SYMLINK -> removeSymlink(entry.target, entry.source, skipped) - ModPlacementMode.COPY -> removeCopiedEntry( - target = entry.target, - source = entry.source, - installId = install.installId, - skipped = skipped, - allowOwnedDirectoryDelete = true, - reportChangedFiles = true, - ) - ModPlacementMode.OVERWRITE_COPY -> removeCopiedEntry( - target = entry.target, - source = entry.source, - installId = install.installId, - skipped = skipped, - allowOwnedDirectoryDelete = false, - reportChangedFiles = true, - ignoredChangedTargets = restoredOverwriteTargets, - removeLegacySentinel = true, - ) - } + when (entry.mode) { + ModPlacementMode.SYMLINK -> removeSymlink(entry.target, entry.source, skipped) + ModPlacementMode.COPY -> removeCopiedEntry( + target = entry.target, + source = entry.source, + installId = install.installId, + skipped = skipped, + allowOwnedDirectoryDelete = true, + reportChangedFiles = true, + ) + ModPlacementMode.OVERWRITE_COPY -> removeCopiedEntry( + target = entry.target, + source = entry.source, + installId = install.installId, + skipped = skipped, + allowOwnedDirectoryDelete = false, + reportChangedFiles = true, + ignoredChangedTargets = restoredOverwriteTargets, + removeLegacySentinel = true, + ) + } }.onFailure { skipped += "${entry.targetRoot}:${entry.targetRelativePath}" } } skipped += plan.errors.keys diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index 9cd7507407..ae53ee55e9 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -3,15 +3,15 @@ package app.gamenative.mods import app.gamenative.data.ModOverwriteManifest import com.github.luben.zstd.Zstd import com.github.luben.zstd.ZstdInputStream -import kotlinx.serialization.Serializable -import kotlinx.serialization.decodeFromString -import kotlinx.serialization.encodeToString -import kotlinx.serialization.json.Json import java.io.File import java.io.FileInputStream import java.io.FileOutputStream import java.nio.file.Files import java.security.MessageDigest +import kotlinx.serialization.Serializable +import kotlinx.serialization.decodeFromString +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json @Serializable enum class ModOwnershipState { @@ -292,7 +292,8 @@ object ModOwnershipReconciler { owned.mode == "SYMLINK" && (owned.normalizedTargetKey == operation.normalizedTargetKey || owned.targetPath.startsWith(operationPath)) } - operation.mode == "SYMLINK" && ownedUnderOperation.isNotEmpty() && + operation.mode == "SYMLINK" && + ownedUnderOperation.isNotEmpty() && ownedUnderOperation.all { it.normalizedTargetKey in targetKeys } } symlinkOperations.forEach { operation -> @@ -310,7 +311,10 @@ object ModOwnershipReconciler { } else { preserved += selected.filter { owned -> owned.mode == "SYMLINK" && - (owned.normalizedTargetKey == operation.normalizedTargetKey || owned.targetPath.startsWith(operation.targetPath + File.separator)) + ( + owned.normalizedTargetKey == operation.normalizedTargetKey || + owned.targetPath.startsWith(operation.targetPath + File.separator) + ) } } } diff --git a/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt index 81c17648ee..b2767e364c 100644 --- a/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt +++ b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt @@ -101,7 +101,7 @@ object WindowsPathIdentity { relativeSegments(path)?.joinToString("/", transform = ::segmentKey) fun targetKey(targetRoot: String, relativePath: String): String? = - normalizedRelativeKey(relativePath)?.let { "$targetRoot:${it}" } + normalizedRelativeKey(relativePath)?.let { "$targetRoot:$it" } fun absoluteKey(file: File): String = file.absoluteFile.normalize().path diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index 708d6e182f..af00cd835a 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -443,14 +443,19 @@ private fun fomodInvalidGroups( step.groups.forEachIndexed { groupIndex, group -> val selected = selectedByGroup["$stepIndex:$groupIndex"].orEmpty() val selectable = group.plugins.mapIndexedNotNull { pluginIndex, plugin -> - if (plugin.effectiveType(flags, environment) == FomodPluginType.NOT_USABLE) null else FomodRecipeGenerator.pluginKey(stepIndex, groupIndex, pluginIndex) + if (plugin.effectiveType(flags, environment) == FomodPluginType.NOT_USABLE) { + null + } else { + FomodRecipeGenerator.pluginKey(stepIndex, groupIndex, pluginIndex) + } }.toSet() val selectedUsable = selected.intersect(selectable) val invalid = when (group.type) { FomodGroupType.SELECT_EXACTLY_ONE -> selectedUsable.size != 1 FomodGroupType.SELECT_AT_LEAST_ONE -> selectedUsable.isEmpty() FomodGroupType.SELECT_AT_MOST_ONE, - FomodGroupType.SELECT_ANY -> false + FomodGroupType.SELECT_ANY, + -> false } if (invalid) { add("${step.name.ifBlank { fallbackStepNames.getOrElse(stepIndex) { "" } }} / ${group.name}") diff --git a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt index 32060f8bc7..8a8fee5f09 100644 --- a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt @@ -35,7 +35,9 @@ class FomodEnvironmentTest { steps = emptyList(), conditionalFileInstalls = listOf( FomodConditionalFileInstall( - FomodDependencyExpression(fileDependencies = listOf(FomodFileDependency("Data/Maybe.dll", FomodRequiredFileState.ACTIVE))), + FomodDependencyExpression( + fileDependencies = listOf(FomodFileDependency("Data/Maybe.dll", FomodRequiredFileState.ACTIVE)), + ), listOf(FomodFileMapping("Maybe.dll", "Maybe.dll", 0, directory = false)), ), ), diff --git a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt index 5ec51f6940..e8c4d98cbd 100644 --- a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt @@ -1,9 +1,9 @@ package app.gamenative.mods +import kotlin.system.measureTimeMillis import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue import org.junit.Test -import kotlin.system.measureTimeMillis class ModArchiveIndexPerformanceTest { @Test diff --git a/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt b/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt index fe873f5935..203cc19752 100644 --- a/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt @@ -6,7 +6,6 @@ import org.junit.Assert.assertTrue import org.junit.Rule import org.junit.Test import org.junit.rules.TemporaryFolder -import java.io.File class ModDeploymentJournalTest { @get:Rule @@ -81,7 +80,12 @@ class ModDeploymentJournalTest { assertEquals(ModDeploymentCheckpoint.COMMITTED, ModDeploymentJournalStore.reconcile(root).single().checkpoint) target.writeText("external change") - assertTrue(ModDeploymentVerifier.verify(ModOwnershipStore.read(root, "install")!!).issues.any { it.type == ModVerificationIssueType.MODIFIED }) + assertTrue( + ModDeploymentVerifier.verify(ModOwnershipStore.read(root, "install")!!).issues.any { + it.type == + ModVerificationIssueType.MODIFIED + }, + ) } private fun emptyPlan() = ModMaterializationPlan("install", emptyList(), emptyList()) diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt index 13cdd9b3e9..b48c698233 100644 --- a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -1,6 +1,7 @@ package app.gamenative.mods import app.gamenative.data.ModPlacementMode +import java.io.File import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse @@ -8,7 +9,6 @@ import org.junit.Assert.assertTrue import org.junit.Rule import org.junit.Test import org.junit.rules.TemporaryFolder -import java.io.File class ModOwnershipManifestTest { @get:Rule From 09aa082a4f27f8752966505da53dc7fa4df3f1c6 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 13:57:10 -0500 Subject: [PATCH 19/60] test: validate placement migration and review --- app/build.gradle.kts | 1 + .../db/ModPlacementMigrationAndroidTest.kt | 75 +++++++++++++++++ .../dialog/PlacementReviewAndroidTest.kt | 83 +++++++++++++++++++ gradle/libs.versions.toml | 3 +- 4 files changed, 161 insertions(+), 1 deletion(-) create mode 100644 app/src/androidTest/java/app/gamenative/db/ModPlacementMigrationAndroidTest.kt create mode 100644 app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt diff --git a/app/build.gradle.kts b/app/build.gradle.kts index a76918c971..01d2d3ca95 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -414,6 +414,7 @@ dependencies { androidTestImplementation(platform(libs.androidx.compose.bom)) androidTestImplementation(libs.androidx.espresso.core) androidTestImplementation(libs.androidx.junit) + androidTestImplementation(libs.androidx.room.testing) androidTestImplementation(libs.androidx.runner) androidTestImplementation(libs.androidx.ui.test.junit4) debugImplementation(libs.androidx.ui.test.manifest) diff --git a/app/src/androidTest/java/app/gamenative/db/ModPlacementMigrationAndroidTest.kt b/app/src/androidTest/java/app/gamenative/db/ModPlacementMigrationAndroidTest.kt new file mode 100644 index 0000000000..49a73b7192 --- /dev/null +++ b/app/src/androidTest/java/app/gamenative/db/ModPlacementMigrationAndroidTest.kt @@ -0,0 +1,75 @@ +package app.gamenative.db + +import androidx.room.testing.MigrationTestHelper +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import app.gamenative.db.migration.ROOM_MIGRATION_V25_to_V26 +import org.junit.Assert.assertEquals +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith + +@RunWith(AndroidJUnit4::class) +class ModPlacementMigrationAndroidTest { + @get:Rule + val helper = MigrationTestHelper( + InstrumentationRegistry.getInstrumentation(), + PluviaDatabase::class.java, + ) + + @Test + fun migrate25To26_preservesInstallAndRecipe() { + helper.createDatabase(DATABASE_NAME, 25).apply { + execSQL( + """ + INSERT INTO mod_install ( + install_id, app_id, source, nexus_game_domain, nexus_mod_id, nexus_file_id, + mod_name, file_name, version, size_bytes, archive_path, extracted_path, + enabled, status, created_at, updated_at, downloaded_at, metadata_json, archive_sha256 + ) VALUES ( + 'install-1', 'steam:489830', 'LOCAL_ARCHIVE', NULL, NULL, NULL, + 'Historical mod', 'historical.zip', '1.0', 42, '/archive.zip', '/extracted', + 1, 'APPLIED', 1, 2, 3, '{}', 'archive-hash' + ) + """.trimIndent(), + ) + execSQL( + """ + INSERT INTO mod_placement_recipe ( + install_id, source_subpath, target_root, target_relative_path, mode, + strip_prefix_segments, include_source_directory, enabled + ) VALUES ( + 'install-1', 'Scripts', 'GAME_DIR', 'Data', 'OVERWRITE_COPY', 0, 1, 1 + ) + """.trimIndent(), + ) + close() + } + + helper.runMigrationsAndValidate( + DATABASE_NAME, + 26, + true, + ROOM_MIGRATION_V25_to_V26, + ).use { database -> + database.query( + """ + SELECT i.mod_name, r.source_subpath, r.target_relative_path, r.target_file_name + FROM mod_install i + JOIN mod_placement_recipe r ON r.install_id = i.install_id + """.trimIndent(), + ).use { cursor -> + assertEquals(true, cursor.moveToFirst()) + assertEquals("Historical mod", cursor.getString(0)) + assertEquals("Scripts", cursor.getString(1)) + assertEquals("Data", cursor.getString(2)) + assertEquals("", cursor.getString(3)) + assertEquals(false, cursor.moveToNext()) + } + } + } + + private companion object { + const val DATABASE_NAME = "mod-placement-migration" + } +} diff --git a/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt new file mode 100644 index 0000000000..b0e3ba931f --- /dev/null +++ b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt @@ -0,0 +1,83 @@ +package app.gamenative.ui.component.dialog + +import androidx.activity.ComponentActivity +import androidx.compose.material3.MaterialTheme +import androidx.compose.ui.test.assertHasClickAction +import androidx.compose.ui.test.junit4.createAndroidComposeRule +import androidx.compose.ui.test.onNodeWithText +import app.gamenative.R +import app.gamenative.data.ModInstall +import app.gamenative.data.ModTargetRoot +import app.gamenative.mods.AutomaticPlacementPlanner +import app.gamenative.mods.FomodEnvironmentSnapshot +import app.gamenative.mods.ModArchiveEntry +import app.gamenative.mods.ResolvedModTargetRoot +import java.io.File +import org.junit.Rule +import org.junit.Test + +class PlacementReviewAndroidTest { + @get:Rule + val compose = createAndroidComposeRule() + + @Test + fun completeAutomaticPlan_exposesReviewAndExportAction() { + val entries = listOf( + ModArchiveEntry("Sounds/voice.wav", directory = false, sizeBytes = 1), + ModArchiveEntry("Scripts/menu.pex", directory = false, sizeBytes = 1), + ModArchiveEntry("SKSE/Plugins/Example.dll", directory = false, sizeBytes = 1), + ModArchiveEntry("Example.esp", directory = false, sizeBytes = 1), + ModArchiveEntry("Example.bsa", directory = false, sizeBytes = 1), + ) + val automatic = AutomaticPlacementPlanner.plan("Skyrim Special Edition", entries) + val recommended = checkNotNull(automatic.recommended) + val drafts = recommended.drafts.map { draft -> + RecipeDraft( + sourceSubpath = draft.sourceSubpath, + targetRelativePath = draft.targetRelativePath, + mode = draft.mode, + includeSourceDirectory = draft.includeSourceDirectory, + ) + } + val gameRoot = File(compose.activity.cacheDir, "placement-review-game").apply { mkdirs() } + + compose.setContent { + MaterialTheme { + PlacementSection( + install = ModInstall( + installId = "install-1", + appId = "steam:489830", + modName = "Example mod", + fileName = "example.zip", + archivePath = "/archive.zip", + extractedPath = "/extracted", + ), + entries = entries, + fomodInstaller = null, + fomodEnvironment = FomodEnvironmentSnapshot(), + roots = listOf(ResolvedModTargetRoot(ModTargetRoot.GAME_DIR, "Game folder", gameRoot)), + drafts = drafts, + presetOptions = emptyList(), + automaticPlacement = automatic, + placementChoice = PlacementChoice.AUTOMATIC, + canUseLastPlacement = false, + onPlacementChoiceChange = {}, + onUseLastPlacement = {}, + onPresetSelected = {}, + onUpdateDraft = { _, _ -> }, + onAddDraft = {}, + onRemoveDraft = {}, + onFomodRecipes = { _, _ -> }, + applyStatusMessage = null, + onExportPlan = {}, + onSaveAndApply = {}, + ) + } + } + + compose.onNodeWithText(compose.activity.getString(R.string.nexus_plan_review_title)).assertExists() + compose.onNodeWithText(compose.activity.getString(R.string.nexus_plan_export)) + .assertExists() + .assertHasClickAction() + } +} diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index 39e75efb83..7f730a3ae6 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -8,7 +8,7 @@ coreKtx = "1.15.0" # https://mvnrepository.com/artifact/androidx.core/core-ktx coroutines = "1.10.2" # https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core dagger-hilt = "2.55" # https://mvnrepository.com/artifact/com.google.dagger/hilt-android dataStore = "1.1.2" # https://mvnrepository.com/artifact/androidx.datastore/datastore-preferences -espressoCore = "3.6.1" # https://mvnrepository.com/artifact/androidx.test.espresso/espresso-core +espressoCore = "3.7.0" # https://mvnrepository.com/artifact/androidx.test.espresso/espresso-core feature-delivery = "2.1.0" # https://mvnrepository.com/artifact/com.google.android.play/feature-delivery play-integrity = "1.6.0" # https://mvnrepository.com/artifact/com.google.android.play/integrity hiltNavigationCompose = "1.2.0" # https://mvnrepository.com/artifact/androidx.hilt/hilt-navigation-compose @@ -59,6 +59,7 @@ androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = androidx-room-ktx = { module = "androidx.room:room-ktx", version.ref = "room-runtime" } androidx-room-paging = { module = "androidx.room:room-paging", version.ref = "room-runtime" } androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "room-runtime" } +androidx-room-testing = { module = "androidx.room:room-testing", version.ref = "room-runtime" } # TODO: Remove 'version' once 1.8.0 is rolled into stable BOM, see https://developer.android.com/jetpack/androidx/releases/compose-ui # This fixes `Placement happened before lookahead` crash when animating lists items. From 54b03cc7d91367f3c8f521eadd9b7f492ed36f30 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 17:16:33 -0500 Subject: [PATCH 20/60] fix: make reviewed mod plans authoritative --- .../dialog/PlacementReviewAndroidTest.kt | 10 +- .../mods/AutomaticPlacementPlanner.kt | 161 ++++++++++++-- .../app/gamenative/mods/FomodEnvironment.kt | 88 +++++++- .../gamenative/mods/FomodInstallPlanner.kt | 10 +- .../app/gamenative/mods/FomodInstaller.kt | 2 +- .../mods/GenericOptionSetDetector.kt | 2 + .../mods/ModDeploymentCoordinator.kt | 25 +++ .../app/gamenative/mods/ModInstallPlan.kt | 33 ++- .../app/gamenative/mods/ModMaterializer.kt | 152 +++++++++++-- .../gamenative/mods/ModOwnershipManifest.kt | 171 ++++++++++++++- .../gamenative/mods/ModPlacementRulePacks.kt | 8 +- .../app/gamenative/mods/ModTargetResolver.kt | 64 ++++-- .../app/gamenative/mods/NexusModManager.kt | 123 ++++++++--- .../ui/component/dialog/NexusModsDialog.kt | 199 ++++++++++++++---- .../dialog/NexusModsDialogHelpers.kt | 14 +- .../dialog/NexusModsFomodSections.kt | 6 +- .../dialog/NexusModsPlacementSections.kt | 109 +++++++++- app/src/main/res/values-da/strings.xml | 7 + app/src/main/res/values-de/strings.xml | 7 + app/src/main/res/values-es/strings.xml | 7 + app/src/main/res/values-fr/strings.xml | 7 + app/src/main/res/values-it/strings.xml | 7 + app/src/main/res/values-ja/strings.xml | 7 + app/src/main/res/values-ko/strings.xml | 7 + app/src/main/res/values-pl/strings.xml | 7 + app/src/main/res/values-pt-rBR/strings.xml | 7 + app/src/main/res/values-ro/strings.xml | 7 + app/src/main/res/values-ru/strings.xml | 7 + app/src/main/res/values-uk/strings.xml | 7 + app/src/main/res/values-zh-rCN/strings.xml | 7 + app/src/main/res/values-zh-rTW/strings.xml | 7 + app/src/main/res/values/strings.xml | 7 + .../mods/AutomaticPlacementPlannerTest.kt | 32 +++ .../gamenative/mods/FomodEnvironmentTest.kt | 43 ++++ .../app/gamenative/mods/FomodInstallerTest.kt | 33 +-- .../mods/ModArchiveIndexPerformanceTest.kt | 20 ++ .../mods/ModDeploymentCoordinatorTest.kt | 29 +++ .../gamenative/mods/ModMaterializerTest.kt | 18 ++ .../mods/ModOwnershipManifestTest.kt | 73 ++++++- .../dialog/NexusModsDialogHelpersTest.kt | 14 ++ 40 files changed, 1400 insertions(+), 144 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt create mode 100644 app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt diff --git a/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt index b0e3ba931f..2f4bf5da27 100644 --- a/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt +++ b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt @@ -55,10 +55,18 @@ class PlacementReviewAndroidTest { entries = entries, fomodInstaller = null, fomodEnvironment = FomodEnvironmentSnapshot(), + fomodBaseDraft = RecipeDraft(targetRelativePath = "Data"), roots = listOf(ResolvedModTargetRoot(ModTargetRoot.GAME_DIR, "Game folder", gameRoot)), drafts = drafts, presetOptions = emptyList(), automaticPlacement = automatic, + automaticPlanLoading = false, + selectedAutomaticOptions = emptyMap(), + onAutomaticOptionSelected = { _, _ -> }, + riskyAutomaticPlanApproved = false, + onRiskyAutomaticPlanApprovalChange = {}, + reviewedPlan = null, + previousOwnership = null, placementChoice = PlacementChoice.AUTOMATIC, canUseLastPlacement = false, onPlacementChoiceChange = {}, @@ -67,7 +75,7 @@ class PlacementReviewAndroidTest { onUpdateDraft = { _, _ -> }, onAddDraft = {}, onRemoveDraft = {}, - onFomodRecipes = { _, _ -> }, + onFomodRecipes = { _, _, _ -> }, applyStatusMessage = null, onExportPlan = {}, onSaveAndApply = {}, diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index 1e1042c775..8d0e191c41 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -23,10 +23,29 @@ data class AutomaticPlacementResult( object AutomaticPlacementPlanner { private val bethesdaRule = ModPlacementRulePacks.bethesda - fun plan(gameName: String, entries: List): AutomaticPlacementResult { - val index = ModArchiveIndex.build(entries) - val optionGroups = GenericOptionSetDetector.detect(index) - val legacy = ModPlacementPresetDetector.detect(gameName, entries).map { preset -> + fun plan( + gameName: String, + entries: List, + selectedOptions: Map = emptyMap(), + ): AutomaticPlacementResult { + val fullIndex = ModArchiveIndex.build(entries) + val optionGroups = GenericOptionSetDetector.detect(fullIndex) + val validSelections = optionGroups.mapNotNull { group -> + selectedOptions[group.stableId] + ?.takeIf { selected -> group.choices.any { it.sourceDirectory == selected } } + ?.let { group.stableId to it } + }.toMap() + val excludedOptionRoots = optionGroups.flatMap { group -> + val selected = validSelections[group.stableId] + if (selected == null) emptyList() else group.choices.map { it.sourceDirectory }.filterNot { it == selected } + } + val effectiveEntries = if (excludedOptionRoots.isEmpty()) { + entries + } else { + entries.filterNot { entry -> excludedOptionRoots.any { root -> entry.path.isUnderArchiveRoot(root) } } + } + val index = if (effectiveEntries === entries) fullIndex else ModArchiveIndex.build(effectiveEntries) + val legacy = ModPlacementPresetDetector.detect(gameName, effectiveEntries).map { preset -> candidateFromDrafts( id = "legacy:${preset.id}", label = preset.label, @@ -39,8 +58,24 @@ object AutomaticPlacementPlanner { } val generated = buildList { bethesdaCandidate(gameName, index)?.let(::add) + frameworkCandidates(gameName, index).let(::addAll) } - val ranked = (generated + legacy) + val combined = generated.takeIf { candidates -> candidates.size > 1 } + ?.flatMap { it.drafts } + ?.distinct() + ?.let { drafts -> + candidateFromDrafts( + id = "rules:combined-v1", + label = "Complete mixed-layout plan", + description = "Combines compatible built-in game and framework rules.", + drafts = drafts, + index = index, + origin = PlacementOrigin.GAME_RULE, + evidence = generated.flatMap { it.evidence }.distinct(), + ) + } + val generatedCandidates = if (combined == null) generated else generated + combined + val ranked = (generatedCandidates + legacy) .distinctBy { candidate -> candidate.plan.digest } .sortedWith( compareByDescending { it.plan.isComplete } @@ -48,7 +83,7 @@ object AutomaticPlacementPlanner { .thenBy { it.id }, ) val baseline = legacy.firstOrNull() - val bestGenerated = generated.maxWithOrNull(compareBy { it.score }.thenBy { it.id }) + val bestGenerated = generatedCandidates.maxWithOrNull(compareBy { it.score }.thenBy { it.id }) val recommendedBase = when { bestGenerated == null -> baseline baseline == null -> bestGenerated @@ -56,13 +91,35 @@ object AutomaticPlacementPlanner { preservesExistingDestinations(baseline.plan, bestGenerated.plan) -> bestGenerated else -> baseline } - val optionMessage = optionGroups.firstOrNull()?.let { group -> + val optionMessage = optionGroups.firstOrNull { it.stableId !in validSelections }?.let { group -> "Choose one package variant: ${group.choices.joinToString { it.sourceDirectory }}" } - val reviewed = if (optionMessage == null) { + val withExcluded = if (excludedOptionRoots.isEmpty()) { ranked } else { + val excludedFiles = fullIndex.files.filter { file -> + excludedOptionRoots.any { root -> file.displayPath.isUnderArchiveRoot(root) } + } ranked.map { candidate -> + candidate.copy( + plan = candidate.plan.copy( + files = candidate.plan.files + excludedFiles.map { file -> + PlannedModFile( + sourceRelativePath = file.displayPath, + status = PlannedFileStatus.INTENTIONALLY_IGNORED, + origin = PlacementOrigin.GAME_RULE, + sizeBytes = file.sizeBytes, + reason = "Unselected package variant", + ) + }, + ), + ) + } + } + val reviewed = if (optionMessage == null) { + withExcluded + } else { + withExcluded.map { candidate -> candidate.copy( plan = candidate.plan.copy(blockingIssues = (candidate.plan.blockingIssues + optionMessage).distinct()), evidence = candidate.evidence + optionMessage, @@ -97,14 +154,14 @@ object AutomaticPlacementPlanner { .thenBy { it.normalizedKey }, ) val drafts = if (bestData != null) { - listOf( + dataNodes.sortedBy { it.normalizedKey }.map { dataNode -> ModPlacementPresetDraft( - sourceSubpath = bestData.displayPath, + sourceSubpath = dataNode.displayPath, targetRelativePath = game.dataDirName, mode = ModPlacementMode.OVERWRITE_COPY.name, includeSourceDirectory = false, - ), - ) + riskyGameRootDrafts(index) + ) + } + riskyGameRootDrafts(index) } else { val sources = index.files.mapNotNull(::bethesdaSourceForFile).distinctBy { it.lowercase(Locale.ROOT) } if (sources.isEmpty()) return null @@ -118,7 +175,9 @@ object AutomaticPlacementPlanner { ) } val evidence = buildList { - if (bestData != null) add("Found ${bestData.displayPath} as a Data container") + if (bestData != null) { + add("Found ${dataNodes.size} compatible Data container(s): ${dataNodes.take(3).joinToString { it.displayPath }}") + } val anchors = index.nodes.flatMapTo(mutableSetOf()) { it.semanticAnchors }.sorted() if (anchors.isNotEmpty()) add("Recognized Data content: ${anchors.joinToString()}") val loose = index.files.count { @@ -148,6 +207,66 @@ object AutomaticPlacementPlanner { ) } + private fun frameworkCandidates(gameName: String, index: ModArchiveIndex): List { + if (index.hasFomod) return emptyList() + return listOf( + Triple(ModPlacementRulePacks.bepInEx, "BepInEx framework plan", "Recognized BepInEx package layout"), + Triple(ModPlacementRulePacks.melonLoader, "MelonLoader framework plan", "Recognized MelonLoader package layout"), + Triple(ModPlacementRulePacks.unreal, "Unreal Engine package plan", "Recognized Unreal Paks package layout"), + Triple(ModPlacementRulePacks.redmod, "REDmod package plan", "Recognized Cyberpunk/REDmod package layout"), + ).mapNotNull { (rule, label, evidence) -> + if (rule.gameNameTokens.isNotEmpty()) { + val normalizedGame = gameName.lowercase(Locale.ROOT) + if (rule.gameNameTokens.none(normalizedGame::contains)) return@mapNotNull null + } + val drafts = rule.directoryTargets.mapNotNull { (sourcePath, targetPath) -> + index.nodes + .filter { node -> + val sourceKey = sourcePath.lowercase(Locale.ROOT) + val suffixMatch = node.normalizedKey.endsWith("/$sourceKey") + val parentName = node.normalizedKey.substringBeforeLast('/', "").substringAfterLast('/') + node.normalizedKey == sourceKey || + ( + suffixMatch && + parentName !in setOf("bepinex", "skse", "f4se", "sfse", "content", "bin", "x64") + ) + } + .maxByOrNull { it.descendantFileCount } + ?.let { node -> + ModPlacementPresetDraft( + sourceSubpath = node.displayPath, + targetRelativePath = targetPath, + mode = ModPlacementMode.OVERWRITE_COPY.name, + includeSourceDirectory = false, + ) + } + }.toMutableList() + if (rule == ModPlacementRulePacks.unreal) { + val loose = index.files.filter { file -> + '/' !in file.displayPath && + file.displayPath.substringAfterLast('.', "").lowercase(Locale.ROOT) in rule.looseExtensions + }.map { it.displayPath } + if (loose.isNotEmpty()) { + drafts += ModPlacementPresetDraft( + sourceSubpath = ModPlacementSources.encode(loose), + targetRelativePath = "Content/Paks", + mode = ModPlacementMode.OVERWRITE_COPY.name, + ) + } + } + if (drafts.isEmpty()) return@mapNotNull null + candidateFromDrafts( + id = "rules:${rule.stableId}-v${rule.version}", + label = label, + description = evidence, + drafts = drafts, + index = index, + origin = PlacementOrigin.GAME_RULE, + evidence = listOf(evidence, "Rule ${rule.stableId}@${rule.version}"), + ) + } + } + private fun bethesdaSourceForFile(file: IndexedArchiveFile): String? { if (file.role != ArchiveContentRole.INSTALLABLE) return null val segments = file.displayPath.split('/') @@ -191,6 +310,7 @@ object AutomaticPlacementPlanner { normalizedTargetKey = targetKey, status = if (targetKey == null) PlannedFileStatus.UNSUPPORTED else PlannedFileStatus.PLACED, origin = origin, + mode = draft.mode, sizeBytes = file.sizeBytes, reason = evidence.firstOrNull() ?: description, evidence = evidence, @@ -239,9 +359,14 @@ object AutomaticPlacementPlanner { if (index.caseCollisions.isNotEmpty()) add("Archive contains case-colliding file paths") if (classified.any { it.status == PlannedFileStatus.UNSUPPORTED }) add("Some installable files have no proven destination") if (duplicateTargets.isNotEmpty()) add("Multiple files target the same Windows path") - if (classified.any { it.risk == PlacementRisk.UNSAFE }) add("Risky game-root installer content requires review") + if (classified.any { it.risk == PlacementRisk.UNSAFE }) add(ModInstallPlan.RISKY_ROOT_REVIEW_BLOCKER) } - val plan = ModInstallPlan(classified, blockingIssues = blockers) + val plan = ModInstallPlan( + files = classified, + blockingIssues = blockers, + producerId = id, + producerVersion = id.substringAfterLast("-v", "1").toIntOrNull() ?: 1, + ) val score = (plan.coverage * 1_000).toInt() + evidence.size * 25 - blockers.size * 250 return AutomaticPlacementCandidate(id, label, description, drafts, plan, score, evidence) } @@ -255,4 +380,10 @@ object AutomaticPlacementPlanner { private fun String.removePrefixCaseInsensitive(prefix: String): String = if (startsWith(prefix, ignoreCase = true)) substring(prefix.length) else this + + private fun String.isUnderArchiveRoot(root: String): Boolean { + val path = normalizeArchiveDisplayPath(this) + val normalizedRoot = normalizeArchiveDisplayPath(root) + return path.equals(normalizedRoot, ignoreCase = true) || path.startsWith("$normalizedRoot/", ignoreCase = true) + } } diff --git a/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt index f901f62435..a7c65151d3 100644 --- a/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt +++ b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt @@ -1,14 +1,33 @@ package app.gamenative.mods import java.io.File +import java.io.RandomAccessFile import java.util.Locale +enum class NativeBinaryArchitecture { + X86, + X64, + ARM64, + UNKNOWN, +} + +data class ScriptExtenderFact( + val id: String, + val present: Boolean, + val version: String? = null, + val path: String = "", +) + data class FomodEnvironmentSnapshot( val gameName: String = "", val gameVersion: String? = null, val fileFacts: Map = emptyMap(), val presentPlugins: Set = emptySet(), val activePlugins: Set = emptySet(), + val pluginMasters: Map> = emptyMap(), + val scriptExtenders: Map = emptyMap(), + val nativeDllArchitectures: Map = emptyMap(), + val unsupportedRequirements: List = emptyList(), ) { fun evaluate(dependency: FomodFileDependency): FomodFactState { val key = dependency.file.normalizedFactKey() @@ -94,7 +113,30 @@ object FomodEnvironmentSnapshotBuilder { val activePlugins = pluginsFile?.takeIf(File::isFile)?.readLines().orEmpty() .map { it.trim().removePrefix("*").substringBefore('#').trim().lowercase(Locale.ROOT) } .filterTo(mutableSetOf(), String::isNotBlank) - return FomodEnvironmentSnapshot(gameName, gameVersion, fileFacts, presentPlugins, activePlugins) + val pluginMasters = presentPlugins.associateWith { plugin -> + val file = resolveRequestedFile(gameRootDir, plugin) + if (file.isFile) BethesdaPluginManager.readPluginMasters(file) else emptyList() + } + val scriptExtenders = discoverScriptExtenders(gameRootDir) + val nativeDllArchitectures = requestedFiles.asSequence() + .filter { it.endsWith(".dll", ignoreCase = true) } + .mapNotNull { requested -> + resolveRequestedFile(gameRootDir, requested).takeIf(File::isFile)?.let { file -> + requested.normalizedFactKey() to readPeArchitecture(file) + } + } + .toMap() + return FomodEnvironmentSnapshot( + gameName = gameName, + gameVersion = gameVersion, + fileFacts = fileFacts, + presentPlugins = presentPlugins, + activePlugins = activePlugins, + pluginMasters = pluginMasters, + scriptExtenders = scriptExtenders, + nativeDllArchitectures = nativeDllArchitectures, + unsupportedRequirements = installer.unsupportedWarnings, + ) } private fun resolveRequestedFile(gameRootDir: File?, requested: String): File { @@ -105,6 +147,50 @@ object FomodEnvironmentSnapshotBuilder { .firstOrNull { it.exists() } ?: File(root, relative) } + + private fun discoverScriptExtenders(gameRootDir: File?): Map { + val root = gameRootDir ?: return emptyMap() + val definitions = mapOf( + "skse" to listOf("skse_loader.exe", "skse64_loader.exe", "Data/SKSE"), + "f4se" to listOf("f4se_loader.exe", "Data/F4SE"), + "sfse" to listOf("sfse_loader.exe", "Data/SFSE"), + "nvse" to listOf("nvse_loader.exe", "Data/NVSE"), + "obse" to listOf("obse_loader.exe", "Data/OBSE"), + ) + return definitions.mapValues { (id, candidates) -> + val present = candidates.mapNotNull { ModTargetResolver.resolveWithin(root, it) }.firstOrNull(File::exists) + val version = root.listFiles().orEmpty().asSequence() + .filter { it.isFile && it.name.startsWith(id, ignoreCase = true) && it.extension.equals("dll", true) } + .mapNotNull { file -> + Regex("(?:^|_)(\\d+)[_.-](\\d+)[_.-](\\d+)(?:[_.-](\\d+))?", RegexOption.IGNORE_CASE) + .find(file.nameWithoutExtension) + ?.groupValues + ?.drop(1) + ?.filter(String::isNotBlank) + ?.map { part -> part.toIntOrNull()?.toString() ?: part } + ?.joinToString(".") + } + .firstOrNull() + ScriptExtenderFact(id, present != null, version, present?.absolutePath.orEmpty()) + } + } + + internal fun readPeArchitecture(file: File): NativeBinaryArchitecture = runCatching { + RandomAccessFile(file, "r").use { input -> + if (input.length() < 64L || input.readUnsignedShort() != 0x4d5a) return@use NativeBinaryArchitecture.UNKNOWN + input.seek(0x3c) + val peOffset = Integer.reverseBytes(input.readInt()).toLong() and 0xffffffffL + if (peOffset + 6 > input.length()) return@use NativeBinaryArchitecture.UNKNOWN + input.seek(peOffset) + if (Integer.reverseBytes(input.readInt()) != 0x00004550) return@use NativeBinaryArchitecture.UNKNOWN + when (java.lang.Short.toUnsignedInt(java.lang.Short.reverseBytes(input.readShort()))) { + 0x014c -> NativeBinaryArchitecture.X86 + 0x8664 -> NativeBinaryArchitecture.X64 + 0xaa64 -> NativeBinaryArchitecture.ARM64 + else -> NativeBinaryArchitecture.UNKNOWN + } + } + }.getOrDefault(NativeBinaryArchitecture.UNKNOWN) } private fun FomodInstaller.dependencyExpressions(): List = diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 6cee22427b..2110046527 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -1,6 +1,7 @@ package app.gamenative.mods import app.gamenative.data.ModTargetRoot +import app.gamenative.data.ModPlacementMode import java.io.File import java.util.Locale @@ -90,6 +91,7 @@ object FomodPlanExpander { extractedRoot: File, targetRoot: String = ModTargetRoot.GAME_DIR.name, targetRelativePath: String = "Data", + mode: String = ModPlacementMode.OVERWRITE_COPY.name, ): ModInstallPlan { val root = extractedRoot.canonicalFile val expanded = mutableListOf() @@ -110,7 +112,7 @@ object FomodPlanExpander { .forEach { file -> val relative = file.canonicalFile.relativeTo(sourceRoot).path.replace(File.separatorChar, '/') val destination = joinPath(targetRelativePath, expected.mapping.destination, relative) - expanded += expected.expanded(file, root, targetRoot, destination) + expanded += expected.expanded(file, root, targetRoot, destination, mode) } } else -> { @@ -119,7 +121,7 @@ object FomodPlanExpander { } else { joinPath(targetRelativePath, expected.mapping.destination) } - expanded += expected.expanded(source, root, targetRoot, destination) + expanded += expected.expanded(source, root, targetRoot, destination, mode) } } } @@ -151,6 +153,8 @@ object FomodPlanExpander { .thenByDescending { it.priority }, ), blockingIssues = blockers.distinct(), + producerId = "fomod", + producerVersion = 1, ) } @@ -164,6 +168,7 @@ object FomodPlanExpander { extractedRoot: File, targetRoot: String, destination: String, + mode: String, ): ExpandedFomodFile { val targetKey = WindowsPathIdentity.targetKey(targetRoot, destination) return ExpandedFomodFile( @@ -175,6 +180,7 @@ object FomodPlanExpander { status = if (targetKey == null) PlannedFileStatus.UNSUPPORTED else PlannedFileStatus.PLACED, origin = origin, priority = mapping.priority, + mode = mode, sizeBytes = source.length(), reason = "Selected FOMOD ${origin.name.lowercase(Locale.ROOT).replace('_', ' ')} mapping", risk = if (targetKey == null) PlacementRisk.REVIEW else PlacementRisk.SAFE, diff --git a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt index 6f4a13ee70..b9e28b594b 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt @@ -459,7 +459,7 @@ object FomodRecipeGenerator { ): FomodRecipeGenerationResult { if (extractedRoot != null) { val evaluation = FomodSelectionEvaluator.evaluate(installer, selectedPluginKeys, environment) - val plan = FomodPlanExpander.expand(installer, evaluation, extractedRoot, targetRoot, targetRelativePath) + val plan = FomodPlanExpander.expand(installer, evaluation, extractedRoot, targetRoot, targetRelativePath, mode) val recipes = plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { file -> val destination = file.targetRelativePath.orEmpty() ModPlacementRecipe( diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt index 33353a8c6d..5d98dbff91 100644 --- a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -8,6 +8,7 @@ data class GenericOptionChoice( ) data class GenericOptionGroup( + val stableId: String, val choices: List, val commonSourceDirectories: List, val reason: String, @@ -48,6 +49,7 @@ object GenericOptionSetDetector { val common = roots.filter { it.normalizedKey !in optionRootKeys }.map { it.displayPath }.sorted() return groups.map { choices -> GenericOptionGroup( + stableId = choices.map { it.normalizedKey }.sorted().joinToString("|").hashCode().toUInt().toString(16), choices = choices.sortedBy { it.normalizedKey }.map { root -> val peers = choices.filter { it != root } GenericOptionChoice( diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt new file mode 100644 index 0000000000..f3e5361409 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt @@ -0,0 +1,25 @@ +package app.gamenative.mods + +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock + +object ModDeploymentCoordinator { + private data class Entry(val mutex: Mutex = Mutex(), var users: Int = 0) + + private val entries = mutableMapOf() + + suspend fun withGameLock(appId: String, block: suspend () -> T): T { + val key = appId.ifBlank { "unknown-game" } + val entry = synchronized(entries) { + entries.getOrPut(key, ::Entry).also { it.users++ } + } + return try { + entry.mutex.withLock { block() } + } finally { + synchronized(entries) { + entry.users-- + if (entry.users == 0) entries.remove(key, entry) + } + } + } +} diff --git a/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt index 5ccaf1b3c3..a5ba2424fe 100644 --- a/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt +++ b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt @@ -1,6 +1,8 @@ package app.gamenative.mods +import app.gamenative.data.ModPlacementMode import java.security.MessageDigest +import java.util.Locale enum class PlannedFileStatus { PLACED, @@ -33,16 +35,20 @@ data class PlannedModFile( val status: PlannedFileStatus, val origin: PlacementOrigin, val priority: Int = 0, + val mode: String = ModPlacementMode.OVERWRITE_COPY.name, val sizeBytes: Long = 0L, val reason: String, val evidence: List = emptyList(), val risk: PlacementRisk = PlacementRisk.SAFE, + val riskApproved: Boolean = false, ) data class ModInstallPlan( val files: List, val warnings: List = emptyList(), val blockingIssues: List = emptyList(), + val producerId: String = "unknown", + val producerVersion: Int = 1, ) { val selectedCount: Int get() = files.count { it.status != PlannedFileStatus.INTENTIONALLY_IGNORED } @@ -78,14 +84,14 @@ data class ModInstallPlan( val isComplete: Boolean get() = blockingIssues.isEmpty() && unresolvedCount == 0 && - files.none { it.risk == PlacementRisk.UNSAFE } + files.none { it.risk == PlacementRisk.UNSAFE && !it.riskApproved } val digest: String get() { val canonical = files .sortedWith( compareBy { it.normalizedTargetKey.orEmpty() } - .thenBy { it.sourceRelativePath.lowercase() } + .thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) } .thenByDescending { it.priority }, ) .joinToString("\n") { file -> @@ -97,7 +103,10 @@ data class ModInstallPlan( file.status.name, file.origin.name, file.priority.toString(), + file.mode, file.sizeBytes.toString(), + file.risk.name, + file.riskApproved.toString(), ).joinToString("|") } return MessageDigest.getInstance("SHA-256") @@ -107,10 +116,11 @@ data class ModInstallPlan( fun sanitizedManifest(): String = buildString { appendLine("plan-version: 1") + appendLine("producer: ${ModDiagnosticSanitizer.text(producerId)}@$producerVersion") appendLine("digest: $digest") appendLine("complete: $isComplete") appendLine("placed: $placedCount/$selectedCount") - files.sortedBy { it.sourceRelativePath.lowercase() }.forEach { file -> + files.sortedBy { it.sourceRelativePath.lowercase(Locale.ROOT) }.forEach { file -> append(file.status.name) append(' ') append(ModDiagnosticSanitizer.relativePath(file.sourceRelativePath)) @@ -128,11 +138,28 @@ data class ModInstallPlan( } append(" [") append(ModDiagnosticSanitizer.text(file.reason)) + if (file.riskApproved) append("; high-risk target explicitly approved") appendLine(']') } warnings.sorted().forEach { appendLine("warning: ${ModDiagnosticSanitizer.text(it)}") } blockingIssues.sorted().forEach { appendLine("blocker: ${ModDiagnosticSanitizer.text(it)}") } } + + fun withRiskyRootApproval(approved: Boolean): ModInstallPlan = copy( + files = files.map { file -> + if (file.risk == PlacementRisk.UNSAFE) file.copy(riskApproved = approved) else file + }, + blockingIssues = when { + approved -> blockingIssues.filterNot { it == RISKY_ROOT_REVIEW_BLOCKER } + files.none { it.risk == PlacementRisk.UNSAFE } -> blockingIssues + RISKY_ROOT_REVIEW_BLOCKER in blockingIssues -> blockingIssues + else -> blockingIssues + RISKY_ROOT_REVIEW_BLOCKER + }, + ) + + companion object { + const val RISKY_ROOT_REVIEW_BLOCKER = "Risky game-root installer content requires review" + } } data class PlacementPlanQuality( diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index e3d25d2d5a..90225ab553 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -12,6 +12,7 @@ import java.io.FileInputStream import java.io.IOException import java.nio.file.Files import java.security.MessageDigest +import java.util.Locale data class ModPlacementConflict( val sourcePath: String, @@ -57,11 +58,16 @@ data class ModMaterializationPlan( val operations: List, val files: List, val errors: Map = emptyMap(), + val reviewedPlan: ModInstallPlan = ModInstallPlan( + files = emptyList(), + blockingIssues = errors.values.toList(), + producerId = "legacy-runtime", + ), ) { - val isComplete: Boolean get() = errors.isEmpty() + val isComplete: Boolean get() = errors.isEmpty() && reviewedPlan.isComplete val digest: String get() { - val canonical = files.joinToString("\n") { file -> + val canonical = reviewedPlan.digest + "\n" + files.joinToString("\n") { file -> "${file.sourceRelativePath}|${file.targetRoot}|${file.targetRelativePath}|${file.normalizedTargetKey}|${file.mode}" } return MessageDigest.getInstance("SHA-256") @@ -92,8 +98,16 @@ object ModMaterializer { recipes: List, gameRootDir: File?, winePrefix: String, + reviewedPlan: ModInstallPlan? = null, ): List = withContext(Dispatchers.IO) { - val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) + val plan = materializationPlan( + install, + recipes, + gameRootDir, + winePrefix, + captureTargetHashes = false, + reviewedPlan = reviewedPlan, + ) buildList { plan.operations.forEach { entry -> when (entry.mode) { @@ -329,11 +343,16 @@ object ModMaterializer { gameRootDir: File?, winePrefix: String, captureTargetHashes: Boolean = true, + reviewedPlan: ModInstallPlan? = null, ): ModMaterializationPlan { + if (reviewedPlan != null) { + return resolveReviewedPlan(install, reviewedPlan, gameRootDir, winePrefix, captureTargetHashes) + } val operations = mutableListOf() val errors = linkedMapOf() + val targetSession = ModTargetResolver.session(gameRootDir, winePrefix) recipes.filter { it.enabled }.forEach { recipe -> - runCatching { plannedEntries(install, recipe, gameRootDir, winePrefix) } + runCatching { plannedEntries(install, recipe, targetSession) } .onSuccess(operations::addAll) .onFailure { error -> val key = recipe.sourceSubpath.ifBlank { recipe.targetRelativePath.ifBlank { install.modName } } @@ -368,21 +387,125 @@ object ModMaterializer { values } } - }.sortedWith(compareBy { it.normalizedTargetKey }.thenBy { it.sourceRelativePath.lowercase() }) + }.sortedWith(compareBy { it.normalizedTargetKey }.thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) }) if (files.isEmpty()) { errors[install.modName] = "The reviewed placement does not contain any materialized files" } - return ModMaterializationPlan(install.installId, operations, files, errors) + val manualPlan = ModInstallPlan( + files = files.map { file -> + PlannedModFile( + sourceRelativePath = file.sourceRelativePath, + targetRoot = file.targetRoot, + targetRelativePath = file.targetRelativePath, + normalizedTargetKey = WindowsPathIdentity.targetKey(file.targetRoot, file.targetRelativePath), + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.MANUAL_RECIPE, + mode = file.mode.name, + sizeBytes = file.source.length(), + reason = "Expanded from a saved placement recipe", + ) + }, + blockingIssues = errors.values.distinct(), + producerId = "manual-recipes", + producerVersion = 1, + ) + return ModMaterializationPlan(install.installId, operations, files, errors, manualPlan) } - private fun plannedEntries( + private fun resolveReviewedPlan( install: ModInstall, - recipe: ModPlacementRecipe, + reviewedPlan: ModInstallPlan, gameRootDir: File?, winePrefix: String, + captureTargetHashes: Boolean, + ): ModMaterializationPlan { + val errors = linkedMapOf() + reviewedPlan.blockingIssues.forEachIndexed { index, issue -> errors["plan:$index"] = issue } + val extractedRoot = File(install.extractedPath).canonicalFile + val targetSession = ModTargetResolver.session(gameRootDir, winePrefix) + val targetHashes = mutableMapOf() + val operations = mutableListOf() + val files = mutableListOf() + + reviewedPlan.files.filter { it.status == PlannedFileStatus.PLACED } + .sortedWith(compareBy { it.normalizedTargetKey.orEmpty() }.thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) }) + .forEach { planned -> + val source = resolveReviewedSource(extractedRoot, planned.sourceRelativePath) + val targetRoot = planned.targetRoot + val targetRelativePath = planned.targetRelativePath + when { + source == null || !source.isFile -> errors[planned.sourceRelativePath] = "Reviewed source file is missing or case-ambiguous" + targetRoot == null || targetRelativePath == null -> errors[planned.sourceRelativePath] = "Reviewed target is missing" + else -> { + val logicalKey = WindowsPathIdentity.targetKey(targetRoot, targetRelativePath) + if (logicalKey == null || logicalKey != planned.normalizedTargetKey) { + errors[planned.sourceRelativePath] = "Reviewed target identity changed before apply" + return@forEach + } + val target = targetSession.resolve(targetRoot, targetRelativePath) + if (target == null) { + errors[planned.sourceRelativePath] = "Reviewed target is unavailable or case-ambiguous" + return@forEach + } + val mode = runCatching { ModPlacementMode.valueOf(planned.mode) } + .getOrDefault(ModPlacementMode.OVERWRITE_COPY) + val operation = ModPlannedEntry( + installId = install.installId, + source = source, + target = target, + mode = mode, + targetRoot = targetRoot, + sourceRelativePath = planned.sourceRelativePath, + targetRelativePath = targetRelativePath, + ) + operations += operation + files += expandPlannedFiles( + operation, + WindowsTargetNamespace(target.parentFile ?: target), + targetHashes, + captureTargetHashes, + ) + } + } + } + files.groupBy { it.normalizedTargetKey }.filterValues { it.size > 1 }.forEach { (key, contenders) -> + if (contenders.map { it.source.canonicalPath }.distinct().size > 1) { + errors[key] = "Reviewed plan contains multiple files for one Windows target" + } + } + if (files.size != reviewedPlan.placedCount) { + errors[install.modName] = "Resolved ${files.size} of ${reviewedPlan.placedCount} reviewed files" + } + return ModMaterializationPlan( + installId = install.installId, + operations = operations, + files = files.sortedWith(compareBy { it.normalizedTargetKey }.thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) }), + errors = errors, + reviewedPlan = reviewedPlan, + ) + } + + private fun resolveReviewedSource(extractedRoot: File, sourceRelativePath: String): File? { + val segments = normalizedArchiveKey(sourceRelativePath)?.split('/').orEmpty() + val displaySegments = normalizeArchiveDisplayPath(sourceRelativePath).split('/').filter(String::isNotBlank) + if (segments.size != displaySegments.size) return null + var current = extractedRoot + displaySegments.forEach { segment -> + val matches = current.listFiles().orEmpty().filter { it.name.equals(segment, ignoreCase = true) } + if (matches.size != 1) return null + current = matches.single() + } + val source = runCatching { current.canonicalFile }.getOrNull() ?: return null + return source.takeIf { it.path.startsWith(extractedRoot.path + File.separator) } + } + + private fun plannedEntries( + install: ModInstall, + recipe: ModPlacementRecipe, + targetSession: ModTargetResolutionSession, ): List = sourceSubpathsForPlacement(recipe.sourceSubpath).flatMap { sourceSubpath -> - plannedEntriesForSource(install, recipe, sourceSubpath, gameRootDir, winePrefix) + plannedEntriesForSource(install, recipe, sourceSubpath, targetSession) } private fun sourceSubpathsForPlacement(sourceSubpath: String): List = @@ -392,8 +515,7 @@ object ModMaterializer { install: ModInstall, recipe: ModPlacementRecipe, sourceSubpath: String, - gameRootDir: File?, - winePrefix: String, + targetSession: ModTargetResolutionSession, ): List { val extractedRoot = File(install.extractedPath).canonicalFile val normalizedSource = ModPlacementSources.normalize(sourceSubpath) @@ -404,12 +526,8 @@ object ModMaterializer { if (!source.exists()) { throw IOException("Source path does not exist: $sourceSubpath") } - val targetDir = ModTargetResolver.resolve( - targetRoot = recipe.targetRoot, - targetRelativePath = recipe.targetRelativePath, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - ) ?: throw IOException("Target root is unavailable: ${recipe.targetRoot}") + val targetDir = targetSession.resolve(recipe.targetRoot, recipe.targetRelativePath) + ?: throw IOException("Target root is unavailable: ${recipe.targetRoot}") val mode = runCatching { ModPlacementMode.valueOf(recipe.mode) }.getOrDefault(ModPlacementMode.SYMLINK) val effectiveSource = stripPrefix(source, recipe.stripPrefixSegments) diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index ae53ee55e9..157749f5a5 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -8,6 +8,7 @@ import java.io.FileInputStream import java.io.FileOutputStream import java.nio.file.Files import java.security.MessageDigest +import java.util.Locale import kotlinx.serialization.Serializable import kotlinx.serialization.decodeFromString import kotlinx.serialization.encodeToString @@ -54,9 +55,25 @@ data class ModOwnedOperation( val mode: String, ) +@Serializable +data class ModInstallDecision( + val sourceRelativePath: String, + val targetRoot: String = "", + val targetRelativePath: String = "", + val normalizedTargetKey: String = "", + val status: String, + val origin: String, + val mode: String, + val priority: Int, + val reason: String, + val outcome: String, + val risk: String = PlacementRisk.SAFE.name, + val riskApproved: Boolean = false, +) + @Serializable data class ModOwnershipManifest( - val version: Int = 1, + val version: Int = 2, val installId: String, val appId: String, val profileId: String = "", @@ -64,6 +81,9 @@ data class ModOwnershipManifest( val state: ModOwnershipState = ModOwnershipState.ACTIVE, val files: List, val operations: List = emptyList(), + val decisions: List = emptyList(), + val planProducerId: String = "legacy", + val planProducerVersion: Int = 1, val createdAt: Long = System.currentTimeMillis(), ) @@ -86,6 +106,96 @@ data class ModProfileOverlay( val conflicts: List, ) +data class ModProfileOverlayTransition( + val current: ModProfileOverlay, + val desired: ModProfileOverlay, + val changedWinnerKeys: List, + val currentVerification: ModDeploymentVerification, +) { + val requiresRebuild: Boolean get() = changedWinnerKeys.isNotEmpty() + val safeToRebuild: Boolean get() = currentVerification.successful +} + +enum class ModPlanChangeType { + ADDED, + CHANGED, + MOVED, + STALE, + UNCHANGED, +} + +data class ModPlanChange( + val type: ModPlanChangeType, + val sourceRelativePath: String, + val previousTarget: String = "", + val newTarget: String = "", +) + +data class ModReconfigurationDiff(val changes: List) { + val added: Int get() = changes.count { it.type == ModPlanChangeType.ADDED } + val changed: Int get() = changes.count { it.type == ModPlanChangeType.CHANGED } + val moved: Int get() = changes.count { it.type == ModPlanChangeType.MOVED } + val stale: Int get() = changes.count { it.type == ModPlanChangeType.STALE } + val hasChanges: Boolean get() = changes.any { it.type != ModPlanChangeType.UNCHANGED } +} + +object ModOwnershipPlanDiffer { + fun compare(previous: ModOwnershipManifest?, next: ModInstallPlan): ModReconfigurationDiff { + if (previous == null) { + return ModReconfigurationDiff( + next.files.filter { it.status == PlannedFileStatus.PLACED }.map { file -> + ModPlanChange(ModPlanChangeType.ADDED, file.sourceRelativePath, newTarget = file.normalizedTargetKey.orEmpty()) + }, + ) + } + val oldFiles = previous.files.filter { it.active } + val oldByTarget = oldFiles.associateBy { it.normalizedTargetKey } + val oldBySource = oldFiles.groupBy { it.sourceRelativePath } + val newFiles = next.files.filter { it.status == PlannedFileStatus.PLACED } + val newAbsoluteKeys = newFiles.mapNotNull { planned -> + oldFiles.firstOrNull { + it.targetRoot == planned.targetRoot && it.targetRelativePath.equals(planned.targetRelativePath, ignoreCase = true) + }?.normalizedTargetKey + }.toSet() + val changes = newFiles.map { planned -> + val logicalTarget = planned.normalizedTargetKey.orEmpty() + val sameSource = oldBySource[planned.sourceRelativePath].orEmpty().singleOrNull() + val sameTarget = oldByTarget.values.firstOrNull { + it.targetRoot == planned.targetRoot && it.targetRelativePath.equals(planned.targetRelativePath, ignoreCase = true) + } + when { + sameSource != null && sameTarget == null -> ModPlanChange( + ModPlanChangeType.MOVED, + planned.sourceRelativePath, + sameSource.normalizedTargetKey, + logicalTarget, + ) + sameTarget != null && sameTarget.sourceRelativePath != planned.sourceRelativePath -> ModPlanChange( + ModPlanChangeType.CHANGED, + planned.sourceRelativePath, + sameTarget.normalizedTargetKey, + logicalTarget, + ) + sameTarget != null -> ModPlanChange( + ModPlanChangeType.UNCHANGED, + planned.sourceRelativePath, + sameTarget.normalizedTargetKey, + logicalTarget, + ) + else -> ModPlanChange(ModPlanChangeType.ADDED, planned.sourceRelativePath, newTarget = logicalTarget) + } + }.toMutableList() + oldFiles.filter { old -> + old.normalizedTargetKey !in newAbsoluteKeys && newFiles.none { + it.targetRoot == old.targetRoot && it.targetRelativePath.equals(old.targetRelativePath, ignoreCase = true) + } && newFiles.none { it.sourceRelativePath == old.sourceRelativePath } + }.forEach { old -> + changes += ModPlanChange(ModPlanChangeType.STALE, old.sourceRelativePath, old.normalizedTargetKey) + } + return ModReconfigurationDiff(changes) + } +} + object ModProfileOverlayPlanner { fun build( manifests: List, @@ -107,12 +217,40 @@ object ModProfileOverlayPlanner { contributors = ordered, winner = ordered.last(), identicalContents = ordered.map { it.file.installedHash }.filter(String::isNotBlank).distinct().size <= 1, - hasCaseCollision = paths.map(String::lowercase).distinct().size < paths.size, + hasCaseCollision = paths.map { it.lowercase(Locale.ROOT) }.distinct().size < paths.size, ) } .toSortedMap() return ModProfileOverlay(targets, targets.values.filter { it.contributors.size > 1 && !it.identicalContents }) } + + fun transition( + manifests: List, + desiredPriorities: Map, + ): ModProfileOverlayTransition { + val currentPriorities = manifests + .filter { it.state == ModOwnershipState.ACTIVE } + .associate { manifest -> + manifest.installId to (manifest.files.filter { it.active }.maxOfOrNull { it.priority } ?: 0) + } + val current = build(manifests, currentPriorities) + val desired = build(manifests, desiredPriorities) + val changedWinnerKeys = (current.targets.keys + desired.targets.keys) + .filter { key -> + val before = current.targets[key]?.winner + val after = desired.targets[key]?.winner + before?.installId != after?.installId || + before?.file?.installedHash != after?.file?.installedHash || + before?.file?.targetPath != after?.file?.targetPath + } + .sorted() + return ModProfileOverlayTransition( + current = current, + desired = desired, + changedWinnerKeys = changedWinnerKeys, + currentVerification = ModDeploymentVerifier.verify(current), + ) + } } object ModOwnershipStore { @@ -209,6 +347,35 @@ object ModOwnershipStore { mode = operation.mode.name, ) }, + decisions = plan.reviewedPlan.files.map { decision -> + val owned = files.firstOrNull { file -> + file.sourceRelativePath == decision.sourceRelativePath && + file.targetRoot == decision.targetRoot && + file.targetRelativePath == decision.targetRelativePath + } + ModInstallDecision( + sourceRelativePath = decision.sourceRelativePath, + targetRoot = decision.targetRoot.orEmpty(), + targetRelativePath = decision.targetRelativePath.orEmpty(), + normalizedTargetKey = decision.normalizedTargetKey.orEmpty(), + status = decision.status.name, + origin = decision.origin.name, + mode = decision.mode, + priority = decision.priority, + reason = decision.reason, + outcome = owned?.disposition?.name ?: when (decision.status) { + PlannedFileStatus.INTENTIONALLY_IGNORED -> "INTENTIONALLY_SKIPPED" + PlannedFileStatus.UNSUPPORTED -> "BLOCKED_UNSUPPORTED" + PlannedFileStatus.MISSING -> "BLOCKED_MISSING" + PlannedFileStatus.CONFLICTED -> "BLOCKED_CONFLICT" + PlannedFileStatus.PLACED -> "PLANNED" + }, + risk = decision.risk.name, + riskApproved = decision.riskApproved, + ) + }, + planProducerId = plan.reviewedPlan.producerId, + planProducerVersion = plan.reviewedPlan.producerVersion, ) } diff --git a/app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt b/app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt index 1ba82f64af..55929dab63 100644 --- a/app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt +++ b/app/src/main/java/app/gamenative/mods/ModPlacementRulePacks.kt @@ -1,5 +1,7 @@ package app.gamenative.mods +import java.util.Locale + data class ModPlacementRulePack( val stableId: String, val version: Int, @@ -37,5 +39,9 @@ object ModPlacementRulePacks { gameNameTokens = setOf("cyberpunk", "redmod"), ) - val archiveSemanticAnchors: Set = bethesda.directoryTargets.keys + val builtIns: List = listOf(bethesda, bepInEx, melonLoader, unreal, redmod) + + val archiveSemanticAnchors: Set = builtIns.flatMapTo(mutableSetOf()) { rule -> + rule.directoryTargets.keys.flatMap { it.lowercase(Locale.ROOT).split('/') } + } } diff --git a/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt b/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt index bea597a72f..4877bf4028 100644 --- a/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt +++ b/app/src/main/java/app/gamenative/mods/ModTargetResolver.kt @@ -50,24 +50,10 @@ object ModTargetResolver { targetRelativePath: String, gameRootDir: File?, winePrefix: String, - ): File? { - val rootType = runCatching { ModTargetRoot.valueOf(targetRoot) }.getOrNull() ?: return null - if (rootType == ModTargetRoot.CUSTOM_ABSOLUTE) { - val rawTarget = File(targetRelativePath.trim().replace('\\', '/')) - if (!rawTarget.isAbsolute) return null - val target = rawTarget.safeCanonicalFile() ?: return null - val allowedRoots = roots(gameRootDir, winePrefix).mapNotNull { it.dir.safeCanonicalFile() } - return target.takeIf { candidate -> - allowedRoots.any { root -> candidate.isInsideOrEqual(root) } - } - } - val root = roots(gameRootDir, winePrefix).firstOrNull { it.type == rootType }?.dir ?: return null - if (WindowsPathIdentity.relativeSegments(targetRelativePath) == null) return null - val cleanRelative = normalizeRelativePath(targetRelativePath) - val rootCanonical = root.safeCanonicalFile() ?: return null - val target = WindowsTargetNamespace(rootCanonical).resolve(cleanRelative).takeIf { it.isValid }?.file ?: return null - return target.takeIf { it.isInsideOrEqual(rootCanonical) } - } + ): File? = session(gameRootDir, winePrefix).resolve(targetRoot, targetRelativePath) + + fun session(gameRootDir: File?, winePrefix: String): ModTargetResolutionSession = + ModTargetResolutionSession(roots(gameRootDir, winePrefix)) fun resolveWithin(root: File, relativePath: String): File? { val rootCanonical = root.safeCanonicalFile() ?: return null @@ -103,3 +89,45 @@ object ModTargetResolver { return path.startsWith(rootPath.trimEnd(File.separatorChar) + File.separator) } } + +/** Reuses one Windows-style namespace for every target in a reviewed plan. */ +class ModTargetResolutionSession internal constructor( + resolvedRoots: List, +) { + private val rootsByType = resolvedRoots.mapNotNull { root -> + root.dir.safeCanonicalFile()?.let { canonical -> root.type to canonical } + }.toMap() + private val namespaces = rootsByType.mapValues { (_, root) -> WindowsTargetNamespace(root) } + + fun resolve(targetRoot: String, targetRelativePath: String): File? { + val rootType = runCatching { ModTargetRoot.valueOf(targetRoot) }.getOrNull() ?: return null + if (rootType == ModTargetRoot.CUSTOM_ABSOLUTE) return resolveCustom(targetRelativePath) + val root = rootsByType[rootType] ?: return null + val relative = ModTargetResolver.normalizeRelativePath(targetRelativePath) + if (WindowsPathIdentity.relativeSegments(relative) == null) return null + return namespaces.getValue(rootType).resolve(relative).takeIf { it.isValid }?.file + ?.takeIf { it.isInsideOrEqual(root) } + } + + private fun resolveCustom(path: String): File? { + val raw = File(path.trim().replace('\\', '/')) + if (!raw.isAbsolute) return null + val candidate = raw.safeCanonicalFile() ?: return null + val matchingRoot = rootsByType.entries + .filter { (_, root) -> candidate.isInsideOrEqual(root) } + .maxByOrNull { (_, root) -> root.path.length } + ?: return null + val relative = candidate.relativeToOrNull(matchingRoot.value)?.path.orEmpty() + return namespaces.getValue(matchingRoot.key).resolve(relative).takeIf { it.isValid }?.file + ?.takeIf { it.isInsideOrEqual(matchingRoot.value) } + } + + private fun File.safeCanonicalFile(): File? = runCatching { canonicalFile }.getOrNull() + + private fun File.isInsideOrEqual(root: File): Boolean { + if (this == root) return true + val rootPath = root.path + if (rootPath == File.separator) return path.startsWith(rootPath) + return path.startsWith(rootPath.trimEnd(File.separatorChar) + File.separator) + } +} diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index db683abc13..f82cb7eb45 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -66,12 +66,19 @@ enum class ModHealthSeverity { WARNING, } +enum class ModHealthAction { + REAPPLY_MISSING, + RECONFIGURE, + REBUILD_PROFILE, +} + data class ModHealthIssue( val severity: ModHealthSeverity, val title: String, val detail: String, val installName: String = "", val installId: String = "", + val recommendedAction: ModHealthAction = ModHealthAction.REBUILD_PROFILE, ) data class ModHealthReport( @@ -89,6 +96,8 @@ data class ModHealthReport( append(' ') if (issue.installName.isNotBlank()) append("${ModDiagnosticSanitizer.text(issue.installName)}: ") append(ModDiagnosticSanitizer.text(issue.title)) + append(" action=") + append(issue.recommendedAction.name) append(" [") append(ModDiagnosticSanitizer.text(issue.detail)) appendLine(']') @@ -531,7 +540,38 @@ object NexusModManager { preserveStatusOnError: Boolean = false, profileId: String = "", priority: Int = 0, + reviewedPlan: ModInstallPlan? = null, checkpointHook: (ModDeploymentCheckpoint) -> Unit = {}, + ): ModPlacementResult = ModDeploymentCoordinator.withGameLock(install.appId) { + applyInstallLocked( + context = context, + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + allowOverwrite = allowOverwrite, + saveLastPlacement = saveLastPlacement, + preserveStatusOnError = preserveStatusOnError, + profileId = profileId, + priority = priority, + reviewedPlan = reviewedPlan, + checkpointHook = checkpointHook, + ) + } + + private suspend fun applyInstallLocked( + context: Context, + install: ModInstall, + recipes: List, + gameRootDir: File?, + winePrefix: String, + allowOverwrite: Boolean, + saveLastPlacement: Boolean, + preserveStatusOnError: Boolean, + profileId: String, + priority: Int, + reviewedPlan: ModInstallPlan?, + checkpointHook: (ModDeploymentCheckpoint) -> Unit, ): ModPlacementResult = withContext(Dispatchers.IO) { val dao = dao(context) val existingManifests = dao.getOverwriteManifests(install.installId) @@ -540,7 +580,13 @@ object NexusModManager { .toSet() val ownershipRoot = cacheRoot(context, install.appId) val previousOwnership = ModOwnershipStore.read(ownershipRoot, install.installId) - val plan = ModMaterializer.materializationPlan(install, recipes, gameRootDir, winePrefix) + val plan = ModMaterializer.materializationPlan( + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + reviewedPlan = reviewedPlan, + ) var journal = ModDeploymentJournalStore.begin(ownershipRoot, install.installId, install.appId, plan) checkpointHook(ModDeploymentCheckpoint.PLANNED) fun advance(checkpoint: ModDeploymentCheckpoint, detail: String = "") { @@ -650,12 +696,14 @@ object NexusModManager { gameRootDir: File?, winePrefix: String, ): ModPlacementResult = - ModMaterializer.repairMissingTargets( - install = install, - recipes = recipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - ) + ModDeploymentCoordinator.withGameLock(install.appId) { + ModMaterializer.repairMissingTargets( + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + ) + } fun lastPlacementRecipesForApp(appId: String, installId: String): List { val root = runCatching { JSONObject(PrefManager.nexusLastPlacementJson) }.getOrElse { JSONObject() } @@ -712,6 +760,16 @@ object NexusModManager { restoreBackups: Boolean, gameRootDir: File? = null, winePrefix: String = ModContainerResolver.getWinePrefix(context, install.appId), + ): List = ModDeploymentCoordinator.withGameLock(install.appId) { + disableInstallLocked(context, install, restoreBackups, gameRootDir, winePrefix) + } + + private suspend fun disableInstallLocked( + context: Context, + install: ModInstall, + restoreBackups: Boolean, + gameRootDir: File?, + winePrefix: String, ): List = withContext(Dispatchers.IO) { val dao = dao(context) if (install.status != ModInstallStatus.APPLIED.name) { @@ -750,22 +808,24 @@ object NexusModManager { restoreBackups: Boolean, gameRootDir: File? = null, winePrefix: String = ModContainerResolver.getWinePrefix(context, install.appId), - ): List = withContext(Dispatchers.IO) { - val skipped = disableInstall(context, install, restoreBackups, gameRootDir, winePrefix) - val dao = dao(context) - dao.deleteOverwriteManifests(install.installId) - dao.deleteInstall(install.installId) - ModOwnershipStore.delete(cacheRoot(context, install.appId), install.installId) - if (install.archivePath.isNotBlank()) { - val archiveFile = File(install.archivePath) - archiveFile.delete() - archiveFile.parentFile?.let { File(it, "${archiveFile.name}.part").delete() } + ): List = ModDeploymentCoordinator.withGameLock(install.appId) { + val skipped = disableInstallLocked(context, install, restoreBackups, gameRootDir, winePrefix) + withContext(Dispatchers.IO) { + val dao = dao(context) + dao.deleteOverwriteManifests(install.installId) + dao.deleteInstall(install.installId) + ModOwnershipStore.delete(cacheRoot(context, install.appId), install.installId) + if (install.archivePath.isNotBlank()) { + val archiveFile = File(install.archivePath) + archiveFile.delete() + archiveFile.parentFile?.let { File(it, "${archiveFile.name}.part").delete() } + } + File(install.extractedPath).deleteRecursively() + File("${install.extractedPath}.tmp").deleteRecursively() + File("${install.extractedPath}.previous").deleteRecursively() + File(backupRoot(context, install.appId), install.installId).deleteRecursively() + skipped } - File(install.extractedPath).deleteRecursively() - File("${install.extractedPath}.tmp").deleteRecursively() - File("${install.extractedPath}.previous").deleteRecursively() - File(backupRoot(context, install.appId), install.installId).deleteRecursively() - skipped } suspend fun deleteInstallsForApp( @@ -994,8 +1054,16 @@ object NexusModManager { title: String, detail: String, install: ModInstall? = null, + action: ModHealthAction = ModHealthAction.REBUILD_PROFILE, ) { - issues += ModHealthIssue(severity, title, detail, install?.modName.orEmpty(), install?.installId.orEmpty()) + issues += ModHealthIssue( + severity, + title, + detail, + install?.modName.orEmpty(), + install?.installId.orEmpty(), + action, + ) } val ownershipRoot = cacheRoot(context, appId) @@ -1022,7 +1090,7 @@ object NexusModManager { val journal = journals[install.installId] if (journal?.checkpoint == ModDeploymentCheckpoint.RECOVERY_REQUIRED) { - add(ModHealthSeverity.ERROR, "Deployment recovery is required", journal.detail, install) + add(ModHealthSeverity.ERROR, "Deployment recovery is required", journal.detail, install, ModHealthAction.RECONFIGURE) } if (status == null) { @@ -1045,6 +1113,7 @@ object NexusModManager { "Ownership adoption is required", "This historical install remains usable, but destructive cleanup is blocked until it is safely reapplied.", install, + ModHealthAction.RECONFIGURE, ) } else if (ownership.state != ModOwnershipState.ACTIVE) { add(ModHealthSeverity.ERROR, "Ownership state does not match the applied mod", ownership.state.name, install) @@ -1065,6 +1134,11 @@ object NexusModManager { }, findings.take(3).joinToString("\n") { it.targetPath }, install, + if (type == ModVerificationIssueType.MISSING) { + ModHealthAction.REAPPLY_MISSING + } else { + ModHealthAction.RECONFIGURE + }, ) } } @@ -1076,6 +1150,7 @@ object NexusModManager { "Some mod files are missing from the game folder", "Apply order can restore them if the mod cache is still available.\n${missing.joinToString("\n")}", install, + ModHealthAction.REAPPLY_MISSING, ) } } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 59a89af917..d18ed9f621 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -85,6 +85,7 @@ import app.gamenative.mods.BethesdaPluginDependencyIssue import app.gamenative.mods.BethesdaPluginManager import app.gamenative.mods.AuthorizedNexusWebsiteDownload import app.gamenative.mods.AutomaticPlacementPlanner +import app.gamenative.mods.AutomaticPlacementResult import app.gamenative.mods.BrowserFirstNexusWebsiteDownload import app.gamenative.mods.FomodInstaller import app.gamenative.mods.FomodEnvironmentSnapshot @@ -103,6 +104,7 @@ import app.gamenative.mods.ModConflictAnalyzer import app.gamenative.mods.ModDownloadInfo import app.gamenative.mods.ModDownloadRegistry import app.gamenative.mods.ModFileConflictReport +import app.gamenative.mods.ModHealthAction import app.gamenative.mods.ModHealthReport import app.gamenative.mods.ModHealthSeverity import app.gamenative.mods.ModImportProgress @@ -302,6 +304,7 @@ internal data class CollectionQueueItem( internal data class PendingFomodResult( val drafts: List, + val plan: ModInstallPlan?, val unsupportedCount: Int, val selectedOptions: List, val conditionalRuleCount: Int, @@ -311,6 +314,7 @@ internal data class PendingApply( val install: ModInstall, val recipes: List, val conflicts: List, + val reviewedPlan: ModInstallPlan? = null, ) internal data class PendingProfileApply( @@ -684,8 +688,24 @@ private fun InstallHealthSection( Text(listOf(issue.installName, issue.title).filter(String::isNotBlank).joinToString(": "), style = MaterialTheme.typography.bodySmall, fontWeight = FontWeight.SemiBold, color = titleColor) Text(issue.detail, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant) if (issue.installId.isNotBlank()) { - TextButton(onClick = { onReconfigure(issue.installId) }) { - Text(stringResource(R.string.nexus_configure)) + TextButton( + onClick = { + if (issue.recommendedAction == ModHealthAction.REAPPLY_MISSING) { + onRebuild() + } else { + onReconfigure(issue.installId) + } + }, + ) { + Text( + stringResource( + if (issue.recommendedAction == ModHealthAction.REAPPLY_MISSING) { + R.string.nexus_reapply_missing_files + } else { + R.string.nexus_configure + }, + ), + ) } } } @@ -801,6 +821,12 @@ fun NexusModsDialog( var pendingProfileNameEdit by remember { mutableStateOf(null) } var pendingProfileDelete by remember { mutableStateOf(null) } var placementChoice by remember { mutableStateOf(PlacementChoice.AUTOMATIC) } + var reviewedPlacementPlan by remember { mutableStateOf(null) } + var automaticOptionSelections by remember { mutableStateOf>(emptyMap()) } + var riskyAutomaticPlanApproved by remember { mutableStateOf(false) } + var automaticPlacementResult by remember { mutableStateOf(null) } + var automaticPlacementLoading by remember { mutableStateOf(false) } + var selectedOwnership by remember { mutableStateOf(null) } var lastPlacementDrafts by remember(libraryItem.appId) { mutableStateOf>(emptyList()) } var detectedDefaultDraft by remember(libraryItem.appId) { mutableStateOf(null) } val defaultDraft = detectedDefaultDraft ?: fallbackDefaultDraft @@ -812,6 +838,44 @@ fun NexusModsDialog( var healthLoading by remember(libraryItem.appId) { mutableStateOf(false) } var diagnosticsPaused by remember { mutableStateOf(false) } var nexusAuthActionInProgress by remember { mutableStateOf(false) } + + LaunchedEffect( + selectedInstall?.installId, + libraryItem.name, + archiveEntries, + automaticOptionSelections, + riskyAutomaticPlanApproved, + ) { + val install = selectedInstall + if (install == null || archiveEntries.isEmpty()) { + automaticPlacementResult = null + automaticPlacementLoading = false + return@LaunchedEffect + } + automaticPlacementLoading = true + automaticPlacementResult = null + val placement = withContext(Dispatchers.Default) { + val planned = AutomaticPlacementPlanner.plan( + libraryItem.name, + archiveEntries, + automaticOptionSelections, + ) + planned.copy( + candidates = planned.candidates.map { candidate -> + candidate.copy(plan = candidate.plan.withRiskyRootApproval(riskyAutomaticPlanApproved)) + }, + recommended = planned.recommended?.let { candidate -> + candidate.copy(plan = candidate.plan.withRiskyRootApproval(riskyAutomaticPlanApproved)) + }, + ) + } + automaticPlacementResult = placement + automaticPlacementLoading = false + if (placementChoice == PlacementChoice.AUTOMATIC && install.canPlaceFiles()) { + recipeDrafts.clear() + recipeDrafts += automaticDraftsFor(placement, libraryItem.name, archiveEntries, defaultDraft) + } + } val nexusAuthenticationUnavailableMessage = context.getString( when { @@ -1454,7 +1518,7 @@ fun NexusModsDialog( } fun applyProfileOrder(allowOverwrite: Boolean): kotlinx.coroutines.Job? { - if (profileApplyInProgress) { + if (profileApplyInProgress || modApplyInProgress) { SnackbarManager.show(context.getString(R.string.nexus_mod_order_already_applying)) return null } @@ -1495,20 +1559,25 @@ fun NexusModsDialog( } val configuredInstalls = orderedInstalls.filter { recipesByInstallId[it.installId].orEmpty().isNotEmpty() } val unconfiguredInstalls = orderedInstalls - configuredInstalls.toSet() - val configuredOwnership = configuredInstalls.mapNotNull { install -> + val allOwnership = currentInstalls.mapNotNull { install -> app.gamenative.mods.ModOwnershipStore.read( NexusModManager.cacheRoot(context, libraryItem.appId), install.installId, ) } - val configuredOverlay = app.gamenative.mods.ModProfileOverlayPlanner.build( - configuredOwnership, - stateByInstallId.mapValues { it.value.priority }, + val configuredOwnershipIds = allOwnership + .filter { it.state == app.gamenative.mods.ModOwnershipState.ACTIVE } + .mapTo(mutableSetOf()) { it.installId } + val desiredPriorities = stateByInstallId.values + .filter { it.enabled } + .associate { it.installId to it.priority } + val overlayTransition = app.gamenative.mods.ModProfileOverlayPlanner.transition( + allOwnership, + desiredPriorities, ) val rebuildManagedOverlay = configuredInstalls.isNotEmpty() && - configuredOwnership.size == configuredInstalls.size && - configuredOwnership.all { it.state == app.gamenative.mods.ModOwnershipState.ACTIVE } && - app.gamenative.mods.ModDeploymentVerifier.verify(configuredOverlay).successful + configuredInstalls.all { it.installId in configuredOwnershipIds } && + overlayTransition.safeToRebuild val game = BethesdaPluginManager.detectGame(libraryItem.name) val plugins = game?.let { BethesdaPluginManager.detectPlugins( @@ -1795,6 +1864,9 @@ fun NexusModsDialog( fomodEnvironment = FomodEnvironmentSnapshot() return } + archiveEntries = emptyList() + selectedFomodInstaller = null + fomodEnvironment = FomodEnvironmentSnapshot() scope.launch { val (entries, fomodInstaller, environment) = withContext(Dispatchers.IO) { val extractedRoot = File(install.extractedPath) @@ -1817,14 +1889,14 @@ fun NexusModsDialog( archiveEntries = entries selectedFomodInstaller = fomodInstaller fomodEnvironment = environment - if (placementChoice == PlacementChoice.AUTOMATIC && install.canPlaceFiles()) { - recipeDrafts.clear() - recipeDrafts += automaticDraftsFor(libraryItem.name, entries, defaultDraft) - } } } fun loadRecipes(install: ModInstall?) { + reviewedPlacementPlan = null + automaticOptionSelections = emptyMap() + riskyAutomaticPlanApproved = false + automaticPlacementResult = null recipeDrafts.clear() if (install == null || !install.canPlaceFiles()) { recipeDrafts += defaultDraft @@ -1835,19 +1907,13 @@ fun NexusModsDialog( recipeDrafts.clear() if (recipes.isEmpty()) { placementChoice = PlacementChoice.AUTOMATIC - recipeDrafts += automaticDraftsFor(libraryItem.name, archiveEntries, defaultDraft) + recipeDrafts += automaticPlacementResult + ?.let { automaticDraftsFor(it, libraryItem.name, archiveEntries, defaultDraft) } + .orEmpty() + .ifEmpty { listOf(defaultDraft) } } else { placementChoice = PlacementChoice.CUSTOM - recipeDrafts += recipes.map { - RecipeDraft( - sourceSubpath = it.sourceSubpath, - targetRoot = it.targetRoot, - targetRelativePath = it.targetRelativePath, - mode = it.mode, - stripPrefixSegments = it.stripPrefixSegments, - includeSourceDirectory = it.includeSourceDirectory, - ) - } + recipeDrafts += recipes.map { it.toDraft() } } } } @@ -2486,7 +2552,9 @@ fun NexusModsDialog( val drafts = if (hasFomodInstaller || !assessment.allowsAutomaticPlacement) { emptyList() } else { - automaticDraftsFor(libraryItem.name, entries, defaultDraft) + withContext(Dispatchers.Default) { + automaticDraftsFor(libraryItem.name, entries, defaultDraft) + } } val existingRecipes = withContext(Dispatchers.IO) { dao.getRecipesForInstall(install.installId) } if (existingRecipes.isEmpty()) { @@ -2886,6 +2954,7 @@ fun NexusModsDialog( install: ModInstall, recipes: List, allowOverwrite: Boolean, + reviewedPlan: ModInstallPlan? = null, ) { loadingMessage = context.getString(R.string.nexus_applying_mod_files) val result = withContext(Dispatchers.IO) { @@ -2896,6 +2965,7 @@ fun NexusModsDialog( gameRootDir = gameRootDir, winePrefix = winePrefix, allowOverwrite = allowOverwrite, + reviewedPlan = reviewedPlan, ) if (applied.errors.isEmpty()) { dao.replaceRecipes(install.installId, recipes) @@ -2925,8 +2995,9 @@ fun NexusModsDialog( install: ModInstall, recipes: List, allowOverwrite: Boolean, + reviewedPlan: ModInstallPlan? = null, ) { - if (modApplyInProgress) { + if (modApplyInProgress || profileApplyInProgress) { SnackbarManager.show(context.getString(R.string.nexus_mod_apply_already_running)) return } @@ -2934,7 +3005,7 @@ fun NexusModsDialog( modApplyInProgress = true try { placementApplyStatusMessage = null - applyRecipesInternal(install, recipes, allowOverwrite) + applyRecipesInternal(install, recipes, allowOverwrite, reviewedPlan) } catch (e: Exception) { val message = e.message ?: context.getString(R.string.nexus_failed_to_apply_mod) placementApplyStatusMessage = message @@ -2959,8 +3030,12 @@ fun NexusModsDialog( SnackbarManager.show(context.getString(R.string.nexus_choose_destination_inside)) return } + val automaticPlan = if (placementChoice == PlacementChoice.AUTOMATIC) { + automaticPlacementResult?.recommended?.plan + } else { + null + } if (placementChoice == PlacementChoice.AUTOMATIC) { - val automaticPlan = AutomaticPlacementPlanner.plan(libraryItem.name, archiveEntries).recommended?.plan val inspection = automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } if ( automaticPlan?.isComplete != true || @@ -2970,6 +3045,7 @@ fun NexusModsDialog( return } } + val reviewedPlan = automaticPlan ?: reviewedPlacementPlan if ( selectedFomodInstaller != null && placementChoice != PlacementChoice.CUSTOM && @@ -2994,6 +3070,7 @@ fun NexusModsDialog( recipes = recipes, gameRootDir = gameRootDir, winePrefix = winePrefix, + reviewedPlan = reviewedPlan, ) raw to ModMaterializer.filterUnapprovedConflicts( conflicts = raw, @@ -3002,13 +3079,18 @@ fun NexusModsDialog( } val hasOverwriteRecipe = recipes.any { it.mode == ModPlacementMode.OVERWRITE_COPY.name } if (conflicts.isNotEmpty() && hasOverwriteRecipe) { - pendingApply = PendingApply(install, recipes, conflicts) + pendingApply = PendingApply(install, recipes, conflicts, reviewedPlan) } else if (conflicts.isNotEmpty()) { val message = context.getString(R.string.nexus_target_files_exist_overwrite) placementApplyStatusMessage = message SnackbarManager.show(message) } else { - applyRecipesInternal(install, recipes, allowOverwrite = rawConflicts.isNotEmpty()) + applyRecipesInternal( + install, + recipes, + allowOverwrite = rawConflicts.isNotEmpty(), + reviewedPlan = reviewedPlan, + ) } } catch (e: Exception) { val message = e.message ?: context.getString(R.string.nexus_scan_placement_conflicts_failed) @@ -3021,6 +3103,17 @@ fun NexusModsDialog( } } + LaunchedEffect(selectedInstall?.installId) { + selectedOwnership = selectedInstall?.let { install -> + withContext(Dispatchers.IO) { + app.gamenative.mods.ModOwnershipStore.read( + NexusModManager.cacheRoot(context, install.appId), + install.installId, + ) + } + } + } + fun shareDiagnostic(fileName: String, content: String) { scope.launch { val file = withContext(Dispatchers.IO) { @@ -3284,27 +3377,48 @@ fun NexusModsDialog( ManageModsTab.PLACEMENT -> { selectedInstall?.let { install -> val presetOptions = placementPresetOptions(libraryItem.name, archiveEntries, defaultDraft) - val automaticPlacement = remember(libraryItem.name, archiveEntries) { - AutomaticPlacementPlanner.plan(libraryItem.name, archiveEntries) - } + val automaticPlacement = automaticPlacementResult + ?: AutomaticPlacementResult(emptyList(), null, emptyList()) PlacementSection( install = install, entries = archiveEntries, fomodInstaller = selectedFomodInstaller, fomodEnvironment = fomodEnvironment, + fomodBaseDraft = defaultDraft, roots = roots, drafts = recipeDrafts, presetOptions = presetOptions, automaticPlacement = automaticPlacement, + automaticPlanLoading = automaticPlacementLoading, + selectedAutomaticOptions = automaticOptionSelections, + onAutomaticOptionSelected = { groupId, sourceDirectory -> + placementApplyStatusMessage = null + reviewedPlacementPlan = null + placementChoice = PlacementChoice.AUTOMATIC + val updatedSelections = automaticOptionSelections + (groupId to sourceDirectory) + automaticOptionSelections = updatedSelections + }, + riskyAutomaticPlanApproved = riskyAutomaticPlanApproved, + onRiskyAutomaticPlanApprovalChange = { approved -> + placementApplyStatusMessage = null + reviewedPlacementPlan = null + riskyAutomaticPlanApproved = approved + }, + reviewedPlan = reviewedPlacementPlan, + previousOwnership = selectedOwnership, placementChoice = placementChoice, canUseLastPlacement = lastPlacementDrafts.isNotEmpty(), onPlacementChoiceChange = { choice -> placementApplyStatusMessage = null + reviewedPlacementPlan = null val currentDrafts = recipeDrafts.toList() placementChoice = choice recipeDrafts.clear() recipeDrafts += when (choice) { - PlacementChoice.AUTOMATIC -> automaticDraftsFor(libraryItem.name, archiveEntries, defaultDraft) + PlacementChoice.AUTOMATIC -> automaticPlacementResult + ?.let { automaticDraftsFor(it, libraryItem.name, archiveEntries, defaultDraft) } + .orEmpty() + .ifEmpty { listOf(defaultDraft) } PlacementChoice.PRESET -> presetOptions.firstOrNull()?.drafts ?: automaticDraftsFor(libraryItem.name, archiveEntries, defaultDraft) PlacementChoice.LAST_USED -> compatibleLastPlacementDrafts(lastPlacementDrafts, archiveEntries, defaultDraft) @@ -3313,33 +3427,39 @@ fun NexusModsDialog( }, onUseLastPlacement = { placementApplyStatusMessage = null + reviewedPlacementPlan = null placementChoice = PlacementChoice.LAST_USED recipeDrafts.clear() recipeDrafts += compatibleLastPlacementDrafts(lastPlacementDrafts, archiveEntries, defaultDraft) }, onPresetSelected = { drafts -> placementApplyStatusMessage = null + reviewedPlacementPlan = null placementChoice = PlacementChoice.PRESET recipeDrafts.clear() recipeDrafts += drafts }, onUpdateDraft = { index, draft -> placementApplyStatusMessage = null + reviewedPlacementPlan = null recipeDrafts[index] = draft }, onAddDraft = { placementApplyStatusMessage = null + reviewedPlacementPlan = null recipeDrafts += defaultDraft }, onRemoveDraft = { index -> if (recipeDrafts.size > 1) { placementApplyStatusMessage = null + reviewedPlacementPlan = null recipeDrafts.removeAt(index) } }, - onFomodRecipes = { drafts, unsupportedCount -> + onFomodRecipes = { drafts, plan, unsupportedCount -> placementApplyStatusMessage = null placementChoice = PlacementChoice.CUSTOM + reviewedPlacementPlan = plan recipeDrafts.clear() recipeDrafts += drafts if (unsupportedCount > 0) { @@ -3517,7 +3637,12 @@ fun NexusModsDialog( confirmLabel = stringResource(R.string.nexus_backup_overwrite), onConfirm = { pendingApply = null - applyRecipes(pending.install, pending.recipes, allowOverwrite = true) + applyRecipes( + pending.install, + pending.recipes, + allowOverwrite = true, + reviewedPlan = pending.reviewedPlan, + ) }, onDismiss = { pendingApply = null }, ) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt index 73fed0c93f..3e435fe2d8 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt @@ -20,6 +20,7 @@ import app.gamenative.data.ModTargetRoot import app.gamenative.mods.BethesdaPluginManager import app.gamenative.mods.BethesdaPluginDependencyIssue import app.gamenative.mods.AutomaticPlacementPlanner +import app.gamenative.mods.AutomaticPlacementResult import app.gamenative.mods.ModArchiveEntry import app.gamenative.mods.ModDownloadInfo import app.gamenative.mods.ModImportProgress @@ -220,8 +221,19 @@ internal fun automaticDraftsFor( gameName: String, entries: List, fallback: RecipeDraft, + selectedOptions: Map = emptyMap(), ): List { - val recommendation = AutomaticPlacementPlanner.plan(gameName, entries).recommended + val result = AutomaticPlacementPlanner.plan(gameName, entries, selectedOptions) + return automaticDraftsFor(result, gameName, entries, fallback) +} + +internal fun automaticDraftsFor( + result: AutomaticPlacementResult, + gameName: String, + entries: List, + fallback: RecipeDraft, +): List { + val recommendation = result.recommended if (recommendation != null) { return recommendation.drafts.map { draft -> fallback.copy( diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index af00cd835a..c1a4350829 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -50,6 +50,7 @@ import app.gamenative.data.ModPlacementMode import app.gamenative.mods.FomodGroupType import app.gamenative.mods.FomodEnvironmentSnapshot import app.gamenative.mods.FomodInstaller +import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.FomodPluginType import app.gamenative.mods.FomodRecipeGenerator import app.gamenative.mods.effectiveType @@ -102,7 +103,7 @@ internal fun FomodWizardDialog( environment: FomodEnvironmentSnapshot, extractedRoot: File, baseDraft: RecipeDraft, - onApply: (List, Int) -> Unit, + onApply: (List, ModInstallPlan?, Int) -> Unit, onDismiss: () -> Unit, ) { var previewImage by remember { mutableStateOf(null) } @@ -296,6 +297,7 @@ internal fun FomodWizardDialog( ) pendingResult = PendingFomodResult( drafts = result.recipes.map { it.toDraft() }, + plan = result.plan, unsupportedCount = result.plan?.let { plan -> plan.unresolvedCount + plan.blockingIssues.size } ?: (result.unsupportedMappings.size + result.blockingIssues.size), @@ -374,7 +376,7 @@ internal fun FomodWizardDialog( TextButton( onClick = { pendingResult = null - onApply(result.drafts, result.unsupportedCount) + onApply(result.drafts, result.plan, result.unsupportedCount) }, enabled = result.unsupportedCount == 0, ) { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 213deda80f..b3d52f2ee3 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -74,10 +74,13 @@ import app.gamenative.mods.FomodInstaller import app.gamenative.mods.FomodEnvironmentSnapshot import app.gamenative.mods.ModArchiveEntry import app.gamenative.mods.ModInstallPlan +import app.gamenative.mods.ModOwnershipManifest +import app.gamenative.mods.ModOwnershipPlanDiffer import app.gamenative.mods.ModPlacementPreset import app.gamenative.mods.ModPlacementSources import app.gamenative.mods.ModTargetResolver import app.gamenative.mods.PlannedFileStatus +import app.gamenative.mods.PlacementRisk import app.gamenative.mods.ResolvedModTargetRoot import app.gamenative.ui.component.NoExtractOutlinedTextField import app.gamenative.utils.StorageUtils @@ -115,10 +118,18 @@ internal fun PlacementSection( entries: List, fomodInstaller: FomodInstaller?, fomodEnvironment: FomodEnvironmentSnapshot, + fomodBaseDraft: RecipeDraft, roots: List, drafts: List, presetOptions: List, automaticPlacement: AutomaticPlacementResult, + automaticPlanLoading: Boolean, + selectedAutomaticOptions: Map, + onAutomaticOptionSelected: (String, String) -> Unit, + riskyAutomaticPlanApproved: Boolean, + onRiskyAutomaticPlanApprovalChange: (Boolean) -> Unit, + reviewedPlan: ModInstallPlan?, + previousOwnership: ModOwnershipManifest?, placementChoice: PlacementChoice, canUseLastPlacement: Boolean, onPlacementChoiceChange: (PlacementChoice) -> Unit, @@ -127,7 +138,7 @@ internal fun PlacementSection( onUpdateDraft: (Int, RecipeDraft) -> Unit, onAddDraft: () -> Unit, onRemoveDraft: (Int) -> Unit, - onFomodRecipes: (List, Int) -> Unit, + onFomodRecipes: (List, ModInstallPlan?, Int) -> Unit, applyStatusMessage: String?, onExportPlan: (ModInstallPlan) -> Unit, onSaveAndApply: () -> Unit, @@ -136,11 +147,18 @@ internal fun PlacementSection( var showFomodWizard by remember(install.installId, fomodInstaller) { mutableStateOf(false) } val destinationsValid = drafts.all { draft -> roots.any { it.type.name == draft.targetRoot } } val automaticPlan = automaticPlacement.recommended?.plan + val visiblePlan = if (placementChoice == PlacementChoice.AUTOMATIC) automaticPlan else reviewedPlan + val reconfigurationDiff = remember(previousOwnership, visiblePlan) { + visiblePlan?.let { ModOwnershipPlanDiffer.compare(previousOwnership, it) } + ?.takeIf { previousOwnership != null && it.hasChanges } + } val targetInspection = remember(automaticPlan, roots) { automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } } val automaticBlocked = placementChoice == PlacementChoice.AUTOMATIC && + (automaticPlanLoading || (automaticPlan?.isComplete != true || targetInspection?.ambiguousPaths?.isNotEmpty() == true) + ) Surface( modifier = Modifier.fillMaxWidth(), @@ -198,7 +216,12 @@ internal fun PlacementSection( }, ) - if (placementChoice == PlacementChoice.AUTOMATIC && automaticPlan != null) { + if (placementChoice == PlacementChoice.AUTOMATIC && automaticPlanLoading) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { + CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp) + Text(stringResource(R.string.nexus_building_install_plan), style = MaterialTheme.typography.bodySmall) + } + } else if (placementChoice == PlacementChoice.AUTOMATIC && automaticPlan != null) { PlacementPlanReview( automaticPlacement = automaticPlacement, plan = automaticPlan, @@ -214,6 +237,79 @@ internal fun PlacementSection( ) } + if (placementChoice == PlacementChoice.AUTOMATIC && automaticPlacement.optionGroups.isNotEmpty()) { + automaticPlacement.optionGroups.forEach { group -> + Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { + Text(stringResource(R.string.nexus_choose_package_variant), style = MaterialTheme.typography.labelLarge) + Text(group.reason, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant) + group.choices.forEach { choice -> + val selected = selectedAutomaticOptions[group.stableId] == choice.sourceDirectory + if (selected) { + Button( + onClick = { onAutomaticOptionSelected(group.stableId, choice.sourceDirectory) }, + modifier = Modifier.fillMaxWidth(), + ) { Text(choice.sourceDirectory) } + } else { + OutlinedButton( + onClick = { onAutomaticOptionSelected(group.stableId, choice.sourceDirectory) }, + modifier = Modifier.fillMaxWidth(), + ) { Text(choice.sourceDirectory) } + } + } + } + } + } + + if ( + placementChoice == PlacementChoice.AUTOMATIC && + automaticPlan?.files.orEmpty().any { it.risk == PlacementRisk.UNSAFE } + ) { + Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.errorContainer) { + Row( + modifier = Modifier + .fillMaxWidth() + .clickable { onRiskyAutomaticPlanApprovalChange(!riskyAutomaticPlanApproved) } + .padding(10.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Checkbox( + checked = riskyAutomaticPlanApproved, + onCheckedChange = onRiskyAutomaticPlanApprovalChange, + ) + Column { + Text( + stringResource(R.string.nexus_confirm_risky_game_root_files), + style = MaterialTheme.typography.labelLarge, + color = MaterialTheme.colorScheme.onErrorContainer, + ) + Text( + stringResource(R.string.nexus_confirm_risky_game_root_files_description), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onErrorContainer, + ) + } + } + } + } + + reconfigurationDiff?.let { diff -> + Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { + Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) { + Text(stringResource(R.string.nexus_reconfiguration_preview), style = MaterialTheme.typography.labelLarge) + Text( + stringResource( + R.string.nexus_reconfiguration_summary, + diff.added, + diff.changed, + diff.moved, + diff.stale, + ), + style = MaterialTheme.typography.bodySmall, + ) + } + } + } + if (placementChoice == PlacementChoice.PRESET && presetOptions.isNotEmpty()) { PresetSelectionSection( presets = presetOptions, @@ -320,10 +416,13 @@ internal fun PlacementSection( installer = fomodInstaller, environment = fomodEnvironment, extractedRoot = File(install.extractedPath), - baseDraft = drafts.firstOrNull() ?: RecipeDraft(), - onApply = { generatedDrafts, unsupportedCount -> + // FOMOD destinations are relative to the game's content root. Reusing the + // first generated mapping here recursively prefixes that mapping whenever + // an installer is reconfigured. + baseDraft = fomodBaseDraft, + onApply = { generatedDrafts, plan, unsupportedCount -> showFomodWizard = false - onFomodRecipes(generatedDrafts, unsupportedCount) + onFomodRecipes(generatedDrafts, plan, unsupportedCount) }, onDismiss = { showFomodWizard = false }, ) diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index a8ccc10338..49c22f8e6c 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2240,4 +2240,11 @@ tvetydige varianter med store/små bogstaver findes allerede Automatisk anvendelse er blokeret, indtil alle installerbare filer har en sikker destination. Del diagnosticering + Forhåndsvisning af omkonfiguration + %1$d tilføjet • %2$d ændret • %3$d flyttet • %4$d forældet + Vælg en pakkevariant + Jeg har gennemgået disse filer i spilmappen + DLL-, EXE- og indlæserfiler kan ændre, hvordan spillet starter. Bekræft kun, når arkivet er betroet, og forhåndsvisningen matcher installationsvejledningen. + Opretter filplaceringsplan… + Genanvend manglende filer diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index d03bf3698b..92b340b21c 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2310,4 +2310,11 @@ mehrdeutige Varianten der Groß-/Kleinschreibung sind bereits vorhanden Die automatische Anwendung ist blockiert, bis jede installierbare Datei ein eindeutiges Ziel hat. Diagnose teilen + Vorschau der Neukonfiguration + %1$d hinzugefügt • %2$d geändert • %3$d verschoben • %4$d veraltet + Paketvariante auswählen + Ich habe diese Dateien im Spielordner geprüft + DLL-, EXE- und Loader-Dateien können den Spielstart verändern. Nur bestätigen, wenn das Archiv vertrauenswürdig ist und die Vorschau der Installationsanleitung entspricht. + Dateiplatzierungsplan wird erstellt… + Fehlende Dateien erneut anwenden diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 78d4b190f9..347d93e64f 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2368,4 +2368,11 @@ ya existen variantes ambiguas de mayúsculas y minúsculas La aplicación automática está bloqueada hasta que cada archivo instalable tenga un destino comprobado. Compartir diagnóstico + Vista previa de la reconfiguración + %1$d añadidos • %2$d cambiados • %3$d movidos • %4$d obsoletos + Elige una variante del paquete + He revisado estos archivos de la carpeta del juego + Los archivos DLL, EXE y de carga pueden cambiar el inicio del juego. Confirma solo si confías en el archivo y la vista previa coincide con sus instrucciones de instalación. + Creando el plan de ubicación de archivos… + Reaplicar archivos que faltan diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index d7a006c8f9..8fef8a2b47 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2370,4 +2370,11 @@ des variantes de casse ambiguës existent déjà L’application automatique est bloquée tant que chaque fichier installable n’a pas de destination vérifiée. Partager le diagnostic + Aperçu de la reconfiguration + %1$d ajoutés • %2$d modifiés • %3$d déplacés • %4$d obsolètes + Choisir une variante du paquet + J’ai vérifié ces fichiers du dossier du jeu + Les fichiers DLL, EXE et de chargement peuvent modifier le démarrage du jeu. Confirmez uniquement si l’archive est fiable et si l’aperçu correspond à ses instructions d’installation. + Création du plan de placement des fichiers… + Réappliquer les fichiers manquants diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 1be7bab2d5..c2e08c399f 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2361,4 +2361,11 @@ esistono già varianti ambigue di maiuscole/minuscole L’applicazione automatica è bloccata finché ogni file installabile non ha una destinazione verificata. Condividi diagnostica + Anteprima riconfigurazione + %1$d aggiunti • %2$d modificati • %3$d spostati • %4$d obsoleti + Scegli una variante del pacchetto + Ho controllato questi file nella cartella del gioco + I file DLL, EXE e loader possono cambiare il modo in cui si avvia il gioco. Conferma solo se l’archivio è attendibile e l’anteprima corrisponde alle istruzioni di installazione. + Creazione del piano di posizionamento dei file… + Riapplica i file mancanti diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index bf64e0f30d..86a8468a4a 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2324,4 +2324,11 @@ 大文字小文字だけが異なる曖昧な項目がすでに存在します インストール可能なすべてのファイルの配置先が確認されるまで、自動適用はブロックされます。 診断情報を共有 + 再設定のプレビュー + 追加 %1$d • 変更 %2$d • 移動 %3$d • 古い出力 %4$d + パッケージのバリアントを選択 + ゲームフォルダのこれらのファイルを確認しました + DLL、EXE、ローダーファイルはゲームの起動方法を変更することがあります。信頼できるアーカイブで、プレビューがインストール手順と一致する場合のみ確認してください。 + ファイル配置プランを作成中… + 不足しているファイルを再適用 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 2f1b4ed307..49f557c4d3 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2365,4 +2365,11 @@ 대소문자만 다른 모호한 항목이 이미 있습니다 설치 가능한 모든 파일의 대상 위치가 확인될 때까지 자동 적용이 차단됩니다. 진단 공유 + 재설정 미리보기 + 추가 %1$d • 변경 %2$d • 이동 %3$d • 이전 출력 %4$d + 패키지 변형 선택 + 게임 폴더의 이 파일을 검토했습니다 + DLL, EXE 및 로더 파일은 게임 시작 방식을 바꿀 수 있습니다. 아카이브를 신뢰할 수 있고 미리보기가 설치 안내와 일치할 때만 확인하세요. + 파일 배치 계획 생성 중… + 누락된 파일 다시 적용 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index f52fb61ab8..8dc2ed3fa6 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2374,4 +2374,11 @@ istnieją już niejednoznaczne warianty wielkości liter Automatyczne zastosowanie jest zablokowane, dopóki każdy plik instalacyjny nie ma potwierdzonego miejsca docelowego. Udostępnij diagnostykę + Podgląd ponownej konfiguracji + Dodano: %1$d • zmieniono: %2$d • przeniesiono: %3$d • nieaktualne: %4$d + Wybierz wariant pakietu + Sprawdzono te pliki w folderze gry + Pliki DLL, EXE i moduły ładujące mogą zmienić sposób uruchamiania gry. Potwierdź tylko wtedy, gdy archiwum jest zaufane, a podgląd odpowiada instrukcji instalacji. + Tworzenie planu rozmieszczenia plików… + Zastosuj ponownie brakujące pliki diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index bde7321aab..dbe172f2ce 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2240,4 +2240,11 @@ já existem variantes ambíguas de maiúsculas e minúsculas A aplicação automática está bloqueada até que cada arquivo instalável tenha um destino comprovado. Compartilhar diagnóstico + Prévia da reconfiguração + %1$d adicionados • %2$d alterados • %3$d movidos • %4$d obsoletos + Escolha uma variante do pacote + Revisei estes arquivos da pasta do jogo + Arquivos DLL, EXE e de carregamento podem mudar como o jogo inicia. Confirme somente se o arquivo for confiável e a prévia corresponder às instruções de instalação. + Criando o plano de posicionamento de arquivos… + Reaplicar arquivos ausentes diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index a96a5ecf8b..4e254b5920 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2374,4 +2374,11 @@ există deja variante ambigue de majuscule/minuscule Aplicarea automată este blocată până când fiecare fișier instalabil are o destinație verificată. Partajează diagnosticul + Previzualizarea reconfigurării + %1$d adăugate • %2$d modificate • %3$d mutate • %4$d învechite + Alege o variantă a pachetului + Am verificat aceste fișiere din dosarul jocului + Fișierele DLL, EXE și de încărcare pot schimba modul în care pornește jocul. Confirmă numai dacă arhiva este de încredere, iar previzualizarea corespunde instrucțiunilor de instalare. + Se creează planul de amplasare a fișierelor… + Reaplică fișierele lipsă diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 745853930a..ea424eac93 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2302,4 +2302,11 @@ https://gamenative.app уже существуют неоднозначные варианты регистра Автоматическое применение заблокировано, пока для каждого устанавливаемого файла не подтверждено место назначения. Поделиться диагностикой + Предпросмотр перенастройки + Добавлено: %1$d • изменено: %2$d • перемещено: %3$d • устарело: %4$d + Выберите вариант пакета + Эти файлы в папке игры проверены + Файлы DLL, EXE и загрузчики могут изменить запуск игры. Подтверждайте, только если архиву можно доверять, а предпросмотр совпадает с инструкцией по установке. + Создание плана размещения файлов… + Повторно применить отсутствующие файлы diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index db0345d3fb..b1ca95184b 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2370,4 +2370,11 @@ неоднозначні варіанти регістру вже існують Автоматичне застосування заблоковано, доки для кожного встановлюваного файлу не підтверджено місце призначення. Поділитися діагностикою + Попередній перегляд переналаштування + Додано: %1$d • змінено: %2$d • переміщено: %3$d • застаріло: %4$d + Виберіть варіант пакета + Ці файли в папці гри перевірено + Файли DLL, EXE та завантажувачі можуть змінити запуск гри. Підтверджуйте, лише якщо архіву можна довіряти, а попередній перегляд відповідає інструкції зі встановлення. + Створення плану розміщення файлів… + Повторно застосувати відсутні файли diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 1d81e68e31..2c3731c5f2 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2385,4 +2385,11 @@ 已存在大小写不明确的变体 在每个可安装文件都有明确目标位置之前，自动应用将被阻止。 分享诊断信息 + 重新配置预览 + 新增 %1$d • 更改 %2$d • 移动 %3$d • 过期 %4$d + 选择软件包变体 + 我已检查这些游戏目录文件 + DLL、EXE 和加载器文件可能改变游戏的启动方式。仅当压缩包可信且预览与安装说明一致时才确认。 + 正在生成文件放置计划… + 重新应用缺失文件 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index c6d7b9d3c7..34c086375c 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2376,4 +2376,11 @@ 已存在大小寫不明確的變體 在每個可安裝檔案都有明確目的地之前，自動套用將被封鎖。 分享診斷資訊 + 重新設定預覽 + 新增 %1$d • 變更 %2$d • 移動 %3$d • 過期 %4$d + 選擇軟體包變體 + 我已檢查這些遊戲目錄檔案 + DLL、EXE 和載入器檔案可能改變遊戲的啟動方式。僅在壓縮檔可信且預覽與安裝說明一致時確認。 + 正在建立檔案放置計畫… + 重新套用遺失檔案 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 29961a3f33..bf732fa204 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2055,6 +2055,13 @@ ambiguous case variants already exist Automatic apply is blocked until every installable file has a proven destination. Share diagnostic + Reconfiguration preview + %1$d added • %2$d changed • %3$d moved • %4$d stale + Choose a package variant + I reviewed these game-root files + DLL, EXE, and loader files can change how the game starts. Confirm only when this archive is trusted and the preview matches its installation instructions. + Building the file placement plan… + Reapply missing files Mod order applied%1$s%2$s Mod order applied with %1$d error(s)%2$s%3$s Failed to apply mod order diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index 87dd7c1636..c6e02a08d0 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -70,6 +70,19 @@ class AutomaticPlacementPlannerTest { assertEquals(listOf("Common"), result.optionGroups.single().commonSourceDirectories) assertFalse(result.recommended!!.plan.isComplete) assertTrue(result.recommended!!.plan.blockingIssues.any { "variant" in it.lowercase() }) + + val group = result.optionGroups.single() + val selected = AutomaticPlacementPlanner.plan( + "Skyrim Special Edition", + archive("Option A/Data/textures/x.dds", "Option B/Data/textures/x.dds", "Common/Data/scripts/y.pex"), + selectedOptions = mapOf(group.stableId to "Option B"), + ).recommended!!.plan + assertTrue(selected.blockingIssues.toString(), selected.isComplete) + assertEquals( + setOf("Data/textures/x.dds", "Data/scripts/y.pex"), + selected.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet(), + ) + assertTrue(selected.files.any { it.sourceRelativePath.startsWith("Option A/") && it.status == PlannedFileStatus.INTENTIONALLY_IGNORED }) } @Test @@ -85,6 +98,25 @@ class AutomaticPlacementPlannerTest { ) assertFalse(plan.isComplete) assertEquals(PlacementRisk.UNSAFE, plan.files.single { it.sourceRelativePath == "dinput8.dll" }.risk) + val approved = plan.withRiskyRootApproval(true) + assertTrue(approved.isComplete) + assertFalse(approved.withRiskyRootApproval(false).isComplete) + } + + @Test + fun frameworkRules_produceCompletePlansWithoutRegressingLegacyTargets() { + val cases = listOf( + Triple("Any Unity game", archive("BepInEx/plugins/Test.dll", "BepInEx/config/Test.cfg"), setOf("BepInEx/plugins/Test.dll", "BepInEx/config/Test.cfg")), + Triple("Another Unity game", archive("Mods/Test.dll", "UserData/settings.cfg"), setOf("Mods/Test.dll", "UserData/settings.cfg")), + Triple("Any Unreal game", archive("Content/Paks/Test.pak", "Content/Paks/Test.utoc"), setOf("Content/Paks/Test.pak", "Content/Paks/Test.utoc")), + Triple("Cyberpunk 2077", archive("archive/pc/mod/Test.archive", "r6/scripts/Test.reds"), setOf("archive/pc/mod/Test.archive", "r6/scripts/Test.reds")), + ) + + cases.forEach { (game, entries, targets) -> + val plan = AutomaticPlacementPlanner.plan(game, entries).recommended!!.plan + assertTrue("$game: ${plan.blockingIssues}", plan.isComplete) + assertEquals(targets, plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet()) + } } private fun archive(vararg paths: String): List = diff --git a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt index 8a8fee5f09..0f2ca576e5 100644 --- a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt @@ -1,5 +1,9 @@ package app.gamenative.mods +import java.io.File +import java.nio.ByteBuffer +import java.nio.ByteOrder +import kotlin.io.path.createTempDirectory import org.junit.Assert.assertEquals import org.junit.Test @@ -49,5 +53,44 @@ class FomodEnvironmentTest { assertTrue(result.blockingIssues.any { "unknown" in it.lowercase() }) } + @Test + fun environment_discoversScriptExtenderVersionAndDllArchitecture() { + val root = createTempDirectory("fomod-environment").toFile() + try { + File(root, "skse64_loader.exe").writeText("loader") + File(root, "skse64_2_02_06.dll").writeBytes(peHeader(0x8664)) + File(root, "Data/SKSE/Plugins/Test.dll").apply { + parentFile?.mkdirs() + writeBytes(peHeader(0x8664)) + } + val installer = FomodInstaller( + moduleName = "Environment", + requiredFiles = emptyList(), + steps = emptyList(), + moduleDependencies = FomodDependencyExpression( + fileDependencies = listOf(FomodFileDependency("SKSE/Plugins/Test.dll", FomodRequiredFileState.ACTIVE)), + ), + ) + + val snapshot = FomodEnvironmentSnapshotBuilder.build(installer, "Skyrim Special Edition", root) + + assertTrue(snapshot.scriptExtenders.getValue("skse").present) + assertEquals("2.2.6", snapshot.scriptExtenders.getValue("skse").version) + assertEquals(NativeBinaryArchitecture.X64, snapshot.nativeDllArchitectures["skse/plugins/test.dll"]) + } finally { + root.deleteRecursively() + } + } + + private fun peHeader(machine: Int): ByteArray = ByteArray(512).also { bytes -> + bytes[0] = 'M'.code.toByte() + bytes[1] = 'Z'.code.toByte() + ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).apply { + putInt(0x3c, 0x80) + putInt(0x80, 0x00004550) + putShort(0x84, machine.toShort()) + } + } + private fun assertTrue(value: Boolean) = org.junit.Assert.assertTrue(value) } diff --git a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt index 6cfd28e55a..10af9dda09 100644 --- a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt @@ -401,10 +401,10 @@ class FomodInstallerTest { MCM Helper fixture - - - - + + + + @@ -424,10 +424,10 @@ class FomodInstallerTest { """.trimIndent(), ) listOf( - "Required/config.json", - "Required/settings.ini", - "Required/readme.txt", - "Required/SKI_ConfigMenu.psc", + "Data/MCM/Config/SkyUI_SE/config.json", + "Data/MCM/Config/SkyUI_SE/settings.ini", + "Data/MCM/Settings/readme.txt", + "Data/Source/Scripts/SKI_ConfigMenu.psc", "SkyrimSE/SKSE/Plugins/MCMHelper.dll", "SkyrimSE/SKSE/Plugins/MCMHelper.pdb", "SkyrimVR/SKSE/Plugins/MCMHelper.dll", @@ -474,15 +474,22 @@ class FomodInstallerTest { archivePath = "", extractedPath = tempDir.absolutePath, ) + val executionPlan = ModMaterializer.materializationPlan( + install = install, + recipes = result.recipes, + gameRootDir = game, + winePrefix = "", + reviewedPlan = result.plan, + ) val applied = ModMaterializer.apply( - install, - result.recipes, - game, - "", - File(tempDir, "backups"), + install = install, + plan = executionPlan, + backupRoot = File(tempDir, "backups"), allowOverwrite = true, ) assertTrue(applied.errors.isEmpty()) + assertEquals(result.plan!!.placedCount, executionPlan.files.size) + assertEquals(result.plan.digest, executionPlan.reviewedPlan.digest) assertEquals( expected, game.walkTopDown().filter { it.isFile } diff --git a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt index e8c4d98cbd..a994becb81 100644 --- a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt @@ -23,4 +23,24 @@ class ModArchiveIndexPerformanceTest { assertEquals(100, archiveIndex.filesUnder("Data/Textures/Set42").size) assertTrue("Indexing took ${elapsed}ms", elapsed < 15_000) } + + @Test + fun fiftyThousandEntries_completePlanningWithinGenerousRegressionBudget() { + val entries = List(50_000) { index -> + ModArchiveEntry( + path = "Data/Textures/Set${index / 100}/texture$index.dds", + directory = false, + sizeBytes = 1, + ) + } + lateinit var plan: ModInstallPlan + + val elapsed = measureTimeMillis { + plan = AutomaticPlacementPlanner.plan("Skyrim Special Edition", entries).recommended!!.plan + } + + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals(50_000, plan.placedCount) + assertTrue("Planning took ${elapsed}ms", elapsed < 20_000) + } } diff --git a/app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt b/app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt new file mode 100644 index 0000000000..0aae8af9ad --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt @@ -0,0 +1,29 @@ +package app.gamenative.mods + +import java.util.concurrent.atomic.AtomicInteger +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.delay +import kotlinx.coroutines.runBlocking +import org.junit.Assert.assertEquals +import org.junit.Test + +class ModDeploymentCoordinatorTest { + @Test + fun sameGameMutationsAreSerialized() = runBlocking { + val active = AtomicInteger() + val maximum = AtomicInteger() + + List(8) { + async { + ModDeploymentCoordinator.withGameLock("game") { + maximum.updateAndGet { previous -> maxOf(previous, active.incrementAndGet()) } + delay(5) + active.decrementAndGet() + } + } + }.awaitAll() + + assertEquals(1, maximum.get()) + } +} diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index 916c769b19..1e5522dbf7 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -746,6 +746,24 @@ class ModMaterializerTest { assertEquals(2, plan.files.map { it.normalizedTargetKey }.distinct().size) } + @Test + fun onePlan_coalescesNewCaseVariantTargetDirectoriesBeforeApply() = runBlocking { + File(extracted, "first/A.pex").apply { parentFile?.mkdirs(); writeText("a") } + File(extracted, "second/B.pex").apply { parentFile?.mkdirs(); writeText("b") } + val recipes = listOf( + recipe(ModPlacementMode.OVERWRITE_COPY, "first", "Data/Scripts"), + recipe(ModPlacementMode.OVERWRITE_COPY, "second", "Data/scripts"), + ) + + val plan = ModMaterializer.materializationPlan(install(), recipes, gameDir, "") + val result = ModMaterializer.apply(install(), plan, backupDir, allowOverwrite = true) + + assertTrue(result.errors.toString(), result.errors.isEmpty()) + assertEquals(1, plan.operations.map { WindowsPathIdentity.absoluteKey(it.target.parentFile!!) }.distinct().size) + assertEquals(listOf("Scripts"), File(gameDir, "Data").listFiles().orEmpty().map { it.name }) + assertEquals(setOf("A.pex", "B.pex"), File(gameDir, "Data/Scripts").listFiles().orEmpty().map { it.name }.toSet()) + } + @Test fun restoreBackups_replacesMatchingSymlinkWithoutChangingLinkDestination() = runBlocking { File(extracted, "config.ini").writeText("modded") diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt index b48c698233..fc891fe87b 100644 --- a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -29,6 +29,24 @@ class ModOwnershipManifestTest { assertTrue(overlay.targets.values.single().hasCaseCollision) } + @Test + fun overlayTransition_comparesDesiredWinnerAgainstTheCurrentDeployedWinner() { + val target = temporaryFolder.newFile("shared.txt").apply { writeText("low") } + val low = manifest("low", target, ModOwnershipStore.sha256(target), priority = 20) + val high = manifest("high", target, "different", priority = 10) + + val transition = ModProfileOverlayPlanner.transition( + listOf(low, high), + desiredPriorities = mapOf("low" to 10, "high" to 20), + ) + + assertEquals("low", transition.current.targets.values.single().winner.installId) + assertEquals("high", transition.desired.targets.values.single().winner.installId) + assertEquals(1, transition.changedWinnerKeys.size) + assertTrue(transition.requiresRebuild) + assertTrue(transition.safeToRebuild) + } + @Test fun staleCleanup_removesOnlyUnchangedOwnedFiles() = runBlocking { val targetRoot = temporaryFolder.newFolder("game") @@ -62,8 +80,61 @@ class ModOwnershipManifestTest { assertEquals(listOf(modified.absolutePath), result.skippedPaths) } + @Test + fun reconfigurationDiff_reportsAddedMovedAndStaleOutputs() { + val previous = ModOwnershipManifest( + installId = "install", + appId = "game", + planDigest = "old", + files = listOf( + owned("A.txt", "Data/A.txt"), + owned("B.txt", "Data/B.txt"), + ), + ) + val next = ModInstallPlan( + files = listOf( + planned("A.txt", "Data/Moved/A.txt"), + planned("C.txt", "Data/C.txt"), + ), + producerId = "fixture", + ) + + val diff = ModOwnershipPlanDiffer.compare(previous, next) + + assertEquals(1, diff.added) + assertEquals(1, diff.moved) + assertEquals(1, diff.stale) + } + + private fun owned(source: String, target: String): ModOwnedFile = ModOwnedFile( + sourceRelativePath = source, + targetRoot = "GAME_DIR", + targetRelativePath = target, + targetPath = "C:/Game/$target", + normalizedTargetKey = WindowsPathIdentity.absoluteKey(File("C:/Game/$target")), + mode = ModPlacementMode.OVERWRITE_COPY.name, + installedHash = source, + installedSize = 1, + installedMtime = 1, + disposition = ModOwnedFileDisposition.CREATED, + ) + + private fun planned(source: String, target: String): PlannedModFile = PlannedModFile( + sourceRelativePath = source, + targetRoot = "GAME_DIR", + targetRelativePath = target, + normalizedTargetKey = WindowsPathIdentity.targetKey("GAME_DIR", target), + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.FOMOD_REQUIRED, + reason = "fixture", + ) + private fun manifest(installId: String, targetPath: String, hash: String, priority: Int): ModOwnershipManifest { val target = File("C:/Game/$targetPath") + return manifest(installId, target, hash, priority) + } + + private fun manifest(installId: String, target: File, hash: String, priority: Int): ModOwnershipManifest { return ModOwnershipManifest( installId = installId, appId = "game", @@ -72,7 +143,7 @@ class ModOwnershipManifestTest { ModOwnedFile( sourceRelativePath = "x.pex", targetRoot = "GAME_DIR", - targetRelativePath = targetPath, + targetRelativePath = target.name, targetPath = target.path, normalizedTargetKey = WindowsPathIdentity.absoluteKey(target), mode = ModPlacementMode.OVERWRITE_COPY.name, diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt index 55e5f2dd77..4386dae24a 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt @@ -2,6 +2,7 @@ package app.gamenative.ui.component.dialog import app.gamenative.data.ModInstall import app.gamenative.data.ModInstallStatus +import app.gamenative.data.ModPlacementRecipe import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.flow.MutableStateFlow @@ -70,6 +71,19 @@ class NexusModsDialogHelpersTest { assertEquals("PROFILE_DISABLED", install.profileStatus(enabledInProfile = false)) } + @Test + fun recipeRoundTrip_preservesFomodDestinationFileName() { + val recipe = ModPlacementRecipe( + installId = "mcm-helper", + sourceSubpath = "Data/MCM/Config/SkyUI_SE/config.json", + targetRelativePath = "Data/MCM/Config/SkyUI_SE", + targetFileName = "config.json", + ) + + assertEquals(recipe.targetFileName, recipe.toDraft().targetFileName) + assertEquals(recipe.targetFileName, recipe.toDraft().toRecipe(recipe.installId).targetFileName) + } + private fun install(status: ModInstallStatus): ModInstall = ModInstall( installId = "install", From d90ba533e0b7a509684d159fc02c52533f6eb64c Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 18:51:14 -0500 Subject: [PATCH 21/60] feat: preserve authoritative deployment plans --- .../app/gamenative/mods/ModInstallPlan.kt | 18 +++-- .../app/gamenative/mods/ModMaterializer.kt | 64 +++++++++++++++-- .../gamenative/mods/ModOwnershipManifest.kt | 67 +++++++++++++++++- .../app/gamenative/mods/NexusModManager.kt | 53 ++++++++++++-- .../gamenative/mods/PlacementRiskPolicy.kt | 69 +++++++++++++++++++ .../ui/component/dialog/NexusModsDialog.kt | 23 ++++++- .../mods/ModInstallPlanContractTest.kt | 19 +++++ .../gamenative/mods/ModMaterializerTest.kt | 25 +++++++ .../mods/ModOwnershipManifestTest.kt | 37 ++++++++++ 9 files changed, 352 insertions(+), 23 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/PlacementRiskPolicy.kt diff --git a/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt index a5ba2424fe..4e77501904 100644 --- a/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt +++ b/app/src/main/java/app/gamenative/mods/ModInstallPlan.kt @@ -145,17 +145,21 @@ data class ModInstallPlan( blockingIssues.sorted().forEach { appendLine("blocker: ${ModDiagnosticSanitizer.text(it)}") } } - fun withRiskyRootApproval(approved: Boolean): ModInstallPlan = copy( - files = files.map { file -> + fun withRiskApproval(approved: Boolean): ModInstallPlan = PlacementRiskPolicy.enforce(this).let { plan -> + plan.copy( + files = plan.files.map { file -> if (file.risk == PlacementRisk.UNSAFE) file.copy(riskApproved = approved) else file }, blockingIssues = when { - approved -> blockingIssues.filterNot { it == RISKY_ROOT_REVIEW_BLOCKER } - files.none { it.risk == PlacementRisk.UNSAFE } -> blockingIssues - RISKY_ROOT_REVIEW_BLOCKER in blockingIssues -> blockingIssues - else -> blockingIssues + RISKY_ROOT_REVIEW_BLOCKER + approved -> plan.blockingIssues.filterNot { it == RISKY_ROOT_REVIEW_BLOCKER } + plan.files.none { it.risk == PlacementRisk.UNSAFE } -> plan.blockingIssues + RISKY_ROOT_REVIEW_BLOCKER in plan.blockingIssues -> plan.blockingIssues + else -> plan.blockingIssues + RISKY_ROOT_REVIEW_BLOCKER }, - ) + ) + } + + fun withRiskyRootApproval(approved: Boolean): ModInstallPlan = withRiskApproval(approved) companion object { const val RISKY_ROOT_REVIEW_BLOCKER = "Risky game-root installer content requires review" diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index 90225ab553..2c30841979 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -38,6 +38,7 @@ data class ModPlannedEntry( val sourceRelativePath: String = "", val targetRelativePath: String = "", val normalizedTargetKey: String = WindowsPathIdentity.absoluteKey(target), + val targetExistedBefore: Boolean = target.exists() || Files.isSymbolicLink(target.toPath()), ) data class ModPlannedFile( @@ -241,10 +242,18 @@ object ModMaterializer { recipes: List, gameRootDir: File?, winePrefix: String, + reviewedPlan: ModInstallPlan? = null, ): ModPlacementResult = withContext(Dispatchers.IO) { var created = 0 var skipped = 0 - val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) + val plan = materializationPlan( + install, + recipes, + gameRootDir, + winePrefix, + captureTargetHashes = false, + reviewedPlan = reviewedPlan, + ) val errors = linkedMapOf().apply { putAll(plan.errors) } plan.operations.forEach { entry -> @@ -337,6 +346,47 @@ object ModMaterializer { skipped.distinct() } + /** Roll back only targets proven to have been absent before this exact plan. */ + suspend fun rollbackAppliedPlan( + plan: ModMaterializationPlan, + restoredOverwriteTargets: Set = emptySet(), + ): List = withContext(Dispatchers.IO) { + val skipped = mutableListOf() + val restoredKeys = restoredOverwriteTargets.mapTo(mutableSetOf()) { + WindowsPathIdentity.absoluteKey(File(it)) + } + + plan.operations + .filter { it.mode == ModPlacementMode.SYMLINK && !it.targetExistedBefore } + .sortedByDescending { it.target.absolutePath.length } + .forEach { operation -> + runCatching { removeSymlink(operation.target, operation.source, skipped) } + .onFailure { skipped += operation.target.absolutePath } + } + + plan.files.asReversed() + .filter { file -> + file.mode != ModPlacementMode.SYMLINK && + !file.targetExistedBefore && + file.normalizedTargetKey !in restoredKeys + } + .forEach { file -> + runCatching { + val target = file.target + if (!target.exists() && !Files.isSymbolicLink(target.toPath())) return@runCatching + val currentHash = if (target.isFile) sha256(target) else "" + val sourceHash = if (file.source.isFile) sha256(file.source) else "" + if (target.isFile && sourceHash.isNotBlank() && currentHash == sourceHash) { + target.delete() + target.parentFile?.let { deleteEmptyDirs(it, stopAt = target.parentFile?.parentFile) } + } else { + skipped += target.absolutePath + } + }.onFailure { skipped += file.target.absolutePath } + } + skipped.distinct() + } + fun materializationPlan( install: ModInstall, recipes: List, @@ -346,7 +396,13 @@ object ModMaterializer { reviewedPlan: ModInstallPlan? = null, ): ModMaterializationPlan { if (reviewedPlan != null) { - return resolveReviewedPlan(install, reviewedPlan, gameRootDir, winePrefix, captureTargetHashes) + return resolveReviewedPlan( + install, + PlacementRiskPolicy.enforce(reviewedPlan), + gameRootDir, + winePrefix, + captureTargetHashes, + ) } val operations = mutableListOf() val errors = linkedMapOf() @@ -391,7 +447,7 @@ object ModMaterializer { if (files.isEmpty()) { errors[install.modName] = "The reviewed placement does not contain any materialized files" } - val manualPlan = ModInstallPlan( + val manualPlan = PlacementRiskPolicy.enforce(ModInstallPlan( files = files.map { file -> PlannedModFile( sourceRelativePath = file.sourceRelativePath, @@ -408,7 +464,7 @@ object ModMaterializer { blockingIssues = errors.values.distinct(), producerId = "manual-recipes", producerVersion = 1, - ) + )) return ModMaterializationPlan(install.installId, operations, files, errors, manualPlan) } diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index 157749f5a5..c9473cf68c 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -69,11 +69,13 @@ data class ModInstallDecision( val outcome: String, val risk: String = PlacementRisk.SAFE.name, val riskApproved: Boolean = false, + val sizeBytes: Long = 0L, + val evidence: List = emptyList(), ) @Serializable data class ModOwnershipManifest( - val version: Int = 2, + val version: Int = 3, val installId: String, val appId: String, val profileId: String = "", @@ -84,9 +86,61 @@ data class ModOwnershipManifest( val decisions: List = emptyList(), val planProducerId: String = "legacy", val planProducerVersion: Int = 1, + val reviewedPlanDigest: String = "", + val planWarnings: List = emptyList(), val createdAt: Long = System.currentTimeMillis(), ) +fun ModOwnershipManifest.reviewedPlanOrNull(): ModInstallPlan? { + val ownedBySourceAndTarget = files.associateBy { it.sourceRelativePath to it.normalizedTargetKey } + val planned = if (decisions.isNotEmpty()) { + decisions.mapNotNull { decision -> + val status = runCatching { PlannedFileStatus.valueOf(decision.status) }.getOrNull() ?: return@mapNotNull null + val origin = runCatching { PlacementOrigin.valueOf(decision.origin) }.getOrDefault(PlacementOrigin.MANUAL_RECIPE) + val owned = ownedBySourceAndTarget[decision.sourceRelativePath to decision.normalizedTargetKey] + ?: files.firstOrNull { it.sourceRelativePath == decision.sourceRelativePath } + PlannedModFile( + sourceRelativePath = decision.sourceRelativePath, + targetRoot = decision.targetRoot.takeIf(String::isNotBlank) ?: owned?.targetRoot, + targetRelativePath = decision.targetRelativePath.takeIf(String::isNotBlank) ?: owned?.targetRelativePath, + normalizedTargetKey = decision.normalizedTargetKey.takeIf(String::isNotBlank) ?: owned?.normalizedTargetKey, + status = status, + origin = origin, + mode = decision.mode, + priority = decision.priority, + sizeBytes = decision.sizeBytes.takeIf { it > 0L } ?: owned?.installedSize ?: 0L, + reason = decision.reason.ifBlank { "Restored from the applied ownership manifest" }, + evidence = decision.evidence, + risk = runCatching { PlacementRisk.valueOf(decision.risk) }.getOrDefault(PlacementRisk.SAFE), + riskApproved = decision.riskApproved, + ) + } + } else { + files.filter { it.active }.map { owned -> + PlannedModFile( + sourceRelativePath = owned.sourceRelativePath, + targetRoot = owned.targetRoot, + targetRelativePath = owned.targetRelativePath, + normalizedTargetKey = owned.normalizedTargetKey, + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.MANUAL_RECIPE, + mode = owned.mode, + sizeBytes = owned.installedSize, + reason = "Conservatively adopted from a historical ownership manifest", + ) + } + } + if (planned.none { it.status == PlannedFileStatus.PLACED }) return null + return PlacementRiskPolicy.enforce( + ModInstallPlan( + files = planned, + warnings = planWarnings, + producerId = planProducerId, + producerVersion = planProducerVersion, + ), + ) +} + data class ModOverlayContribution( val installId: String, val priority: Int, @@ -262,6 +316,10 @@ object ModOwnershipStore { fun read(root: File, installId: String): ModOwnershipManifest? = readFile(currentFile(root, installId)) ?: readFile(previousFile(root, installId)) + fun readPrevious(root: File, installId: String): ModOwnershipManifest? = readFile(previousFile(root, installId)) + + fun reviewedPlan(root: File, installId: String): ModInstallPlan? = read(root, installId)?.reviewedPlanOrNull() + fun readAll(root: File): List = ownershipDir(root).listFiles() .orEmpty() @@ -286,7 +344,8 @@ object ModOwnershipStore { } fun commit(root: File, installId: String) { - previousFile(root, installId).delete() + // Keep one prior deployment so a successful reconfigure can be undone without + // retaining an unbounded history. The next write rotates it atomically. } fun delete(root: File, installId: String) { @@ -372,10 +431,14 @@ object ModOwnershipStore { }, risk = decision.risk.name, riskApproved = decision.riskApproved, + sizeBytes = decision.sizeBytes, + evidence = decision.evidence, ) }, planProducerId = plan.reviewedPlan.producerId, planProducerVersion = plan.reviewedPlan.producerVersion, + reviewedPlanDigest = plan.reviewedPlan.digest, + planWarnings = plan.reviewedPlan.warnings, ) } diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index f82cb7eb45..bdf6fc10cf 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -580,12 +580,13 @@ object NexusModManager { .toSet() val ownershipRoot = cacheRoot(context, install.appId) val previousOwnership = ModOwnershipStore.read(ownershipRoot, install.installId) + val authoritativePlan = reviewedPlan ?: previousOwnership?.reviewedPlanOrNull() val plan = ModMaterializer.materializationPlan( install = install, recipes = recipes, gameRootDir = gameRootDir, winePrefix = winePrefix, - reviewedPlan = reviewedPlan, + reviewedPlan = authoritativePlan, ) var journal = ModDeploymentJournalStore.begin(ownershipRoot, install.installId, install.appId, plan) checkpointHook(ModDeploymentCheckpoint.PLANNED) @@ -662,14 +663,12 @@ object NexusModManager { advance(ModDeploymentCheckpoint.ROLLING_BACK, "Apply or verification failed") val restoreSkipped = ModMaterializer.restoreBackups(result.manifests) val restoredTargets = result.manifests + .filter { it.backupPath.isNotBlank() } .map { it.targetPath } .filterNot { it in restoreSkipped } .toSet() - val removeSkipped = ModMaterializer.removeAppliedFiles( - install = install, - recipes = recipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, + val removeSkipped = ModMaterializer.rollbackAppliedPlan( + plan = plan, restoredOverwriteTargets = restoredTargets, ) result.manifests @@ -695,6 +694,7 @@ object NexusModManager { recipes: List, gameRootDir: File?, winePrefix: String, + reviewedPlan: ModInstallPlan? = null, ): ModPlacementResult = ModDeploymentCoordinator.withGameLock(install.appId) { ModMaterializer.repairMissingTargets( @@ -702,9 +702,45 @@ object NexusModManager { recipes = recipes, gameRootDir = gameRootDir, winePrefix = winePrefix, + reviewedPlan = reviewedPlan, ) } + suspend fun restorePreviousDeployment( + context: Context, + install: ModInstall, + recipes: List, + gameRootDir: File?, + winePrefix: String, + profileId: String = "", + priority: Int = 0, + ): ModPlacementResult { + val previous = withContext(Dispatchers.IO) { + ModOwnershipStore.readPrevious(cacheRoot(context, install.appId), install.installId) + } + val plan = previous?.reviewedPlanOrNull() + ?: return ModPlacementResult( + created = 0, + skipped = 0, + backedUp = 0, + errors = mapOf(install.modName to "No previous reviewed deployment is available"), + manifests = emptyList(), + ) + return applyInstall( + context = context, + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + allowOverwrite = true, + saveLastPlacement = false, + preserveStatusOnError = true, + profileId = profileId, + priority = priority, + reviewedPlan = plan, + ) + } + fun lastPlacementRecipesForApp(appId: String, installId: String): List { val root = runCatching { JSONObject(PrefManager.nexusLastPlacementJson) }.getOrElse { JSONObject() } val recipes = root.optJSONArray(appId) ?: return emptyList() @@ -1223,10 +1259,11 @@ object NexusModManager { recipes: List, gameRootDir: File?, winePrefix: String, + reviewedPlan: ModInstallPlan? = null, ): Boolean = install.status == ModInstallStatus.APPLIED.name && recipes.any { it.enabled } && - missingAppliedTargets(install, recipes, gameRootDir, winePrefix).isNotEmpty() + missingAppliedTargets(install, recipes, gameRootDir, winePrefix, reviewedPlan).isNotEmpty() suspend fun archiveEntries(install: ModInstall): List = withContext(Dispatchers.IO) { ModArchiveExtractor.listExtractedEntries(File(install.extractedPath)) } @@ -1422,6 +1459,7 @@ object NexusModManager { recipes: List, gameRootDir: File?, winePrefix: String, + reviewedPlan: ModInstallPlan? = null, ): List { val missing = mutableListOf() val plan = ModMaterializer.materializationPlan( @@ -1430,6 +1468,7 @@ object NexusModManager { gameRootDir, winePrefix, captureTargetHashes = false, + reviewedPlan = reviewedPlan, ) missing += plan.errors.values plan.operations.filter { it.mode == ModPlacementMode.SYMLINK }.forEach { entry -> diff --git a/app/src/main/java/app/gamenative/mods/PlacementRiskPolicy.kt b/app/src/main/java/app/gamenative/mods/PlacementRiskPolicy.kt new file mode 100644 index 0000000000..58932d1f42 --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/PlacementRiskPolicy.kt @@ -0,0 +1,69 @@ +package app.gamenative.mods + +import app.gamenative.data.ModTargetRoot +import java.util.Locale + +data class PlacementRiskAssessment( + val risk: PlacementRisk, + val evidence: String = "", +) + +/** + * One origin-independent policy for destinations that deserve extra review. + * Individual mods and archive names must never participate in this decision. + */ +object PlacementRiskPolicy { + private val executableExtensions = setOf( + "asi", "bat", "cmd", "com", "dll", "exe", "jar", "js", "msi", "ps1", "scr", "vbs", + ) + private val rootConfigurationExtensions = setOf("cfg", "conf", "ini", "json", "toml", "xml", "yaml", "yml") + + fun assess(targetRoot: String?, targetRelativePath: String?): PlacementRiskAssessment { + val root = runCatching { ModTargetRoot.valueOf(targetRoot.orEmpty()) }.getOrNull() + val path = normalizeArchiveDisplayPath(targetRelativePath.orEmpty()) + val extension = path.substringAfterLast('.', "").lowercase(Locale.ROOT) + val atRoot = '/' !in path.trim('/') + + return when { + root == ModTargetRoot.CUSTOM_ABSOLUTE -> PlacementRiskAssessment( + PlacementRisk.UNSAFE, + "Custom absolute destinations require explicit confirmation", + ) + root == ModTargetRoot.WINE_C -> PlacementRiskAssessment( + PlacementRisk.UNSAFE, + "Direct writes to the Wine C: drive require explicit confirmation", + ) + root == ModTargetRoot.GAME_DIR && atRoot && extension in executableExtensions -> PlacementRiskAssessment( + PlacementRisk.UNSAFE, + "Executable or loader content in the game directory requires explicit confirmation", + ) + root == ModTargetRoot.GAME_DIR && atRoot && extension in rootConfigurationExtensions -> PlacementRiskAssessment( + PlacementRisk.REVIEW, + "Game-directory configuration file should be reviewed", + ) + else -> PlacementRiskAssessment(PlacementRisk.SAFE) + } + } + + fun enforce(plan: ModInstallPlan): ModInstallPlan { + val files = plan.files.map { file -> + if (file.status != PlannedFileStatus.PLACED) return@map file + val assessment = assess(file.targetRoot, file.targetRelativePath) + if (assessment.risk <= file.risk) return@map file + file.copy( + risk = assessment.risk, + evidence = (file.evidence + assessment.evidence).filter(String::isNotBlank).distinct(), + ) + } + val needsApproval = files.any { it.risk == PlacementRisk.UNSAFE && !it.riskApproved } + return plan.copy( + files = files, + blockingIssues = when { + needsApproval && ModInstallPlan.RISKY_ROOT_REVIEW_BLOCKER !in plan.blockingIssues -> + plan.blockingIssues + ModInstallPlan.RISKY_ROOT_REVIEW_BLOCKER + !needsApproval -> plan.blockingIssues.filterNot { it == ModInstallPlan.RISKY_ROOT_REVIEW_BLOCKER } + else -> plan.blockingIssues + }, + ) + } +} diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index d18ed9f621..99e814fb16 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -110,6 +110,7 @@ import app.gamenative.mods.ModHealthSeverity import app.gamenative.mods.ModImportProgress import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.ModMaterializer +import app.gamenative.mods.PlannedFileStatus import app.gamenative.mods.ModPathDetector import app.gamenative.mods.ModPlacementConflict import app.gamenative.mods.ModPlacementPreset @@ -141,6 +142,7 @@ import app.gamenative.mods.NexusUserInfo import app.gamenative.mods.PendingNexusWebsiteDownload import app.gamenative.mods.NexusUrlParser import app.gamenative.mods.isPastPendingTtl +import app.gamenative.mods.reviewedPlanOrNull import app.gamenative.service.NexusModImportService import app.gamenative.ui.screen.auth.NexusOAuthBrowserLauncher import app.gamenative.ui.util.LocalSnackbarHostController @@ -356,6 +358,7 @@ private data class ProfileOrderPlan( val rebuildManagedOverlay: Boolean, val missingTargetRepairInstallIds: Set, val recipesByInstallId: Map>, + val reviewedPlansByInstallId: Map, val recipesToPersistByInstallId: Map>, val unconfiguredCount: Int, val unconfiguredNames: List, @@ -1557,14 +1560,20 @@ fun NexusModsDialog( } install.installId to effectiveRecipes } - val configuredInstalls = orderedInstalls.filter { recipesByInstallId[it.installId].orEmpty().isNotEmpty() } - val unconfiguredInstalls = orderedInstalls - configuredInstalls.toSet() val allOwnership = currentInstalls.mapNotNull { install -> app.gamenative.mods.ModOwnershipStore.read( NexusModManager.cacheRoot(context, libraryItem.appId), install.installId, ) } + val reviewedPlansByInstallId = allOwnership.mapNotNull { ownership -> + ownership.reviewedPlanOrNull()?.let { ownership.installId to it } + }.toMap() + val configuredInstalls = orderedInstalls.filter { install -> + recipesByInstallId[install.installId].orEmpty().isNotEmpty() || + install.installId in reviewedPlansByInstallId + } + val unconfiguredInstalls = orderedInstalls - configuredInstalls.toSet() val configuredOwnershipIds = allOwnership .filter { it.state == app.gamenative.mods.ModOwnershipState.ACTIVE } .mapTo(mutableSetOf()) { it.installId } @@ -1608,6 +1617,7 @@ fun NexusModsDialog( recipes = recipesByInstallId[install.installId].orEmpty(), gameRootDir = gameRootDir, winePrefix = winePrefix, + reviewedPlan = reviewedPlansByInstallId[install.installId], ) } .mapTo(mutableSetOf()) { it.installId } @@ -1630,6 +1640,7 @@ fun NexusModsDialog( rebuildManagedOverlay = rebuildManagedOverlay, missingTargetRepairInstallIds = missingTargetRepairInstallIds, recipesByInstallId = recipesByInstallId, + reviewedPlansByInstallId = reviewedPlansByInstallId, recipesToPersistByInstallId = recipesToPersistByInstallId, unconfiguredCount = unconfiguredInstalls.size, unconfiguredNames = unconfiguredInstalls.map { it.modName }, @@ -1662,12 +1673,16 @@ fun NexusModsDialog( recipes = plan.recipesByInstallId[install.installId].orEmpty(), gameRootDir = gameRootDir, winePrefix = winePrefix, + reviewedPlan = plan.reviewedPlansByInstallId[install.installId], ) } ProfileOrderConflictCheck( rawConflicts = rawConflicts, conflicts = ModMaterializer.filterUnapprovedConflicts(rawConflicts, overwriteManifests), - hasOverwriteRecipe = plan.recipesByInstallId.values.flatten().any { it.mode == ModPlacementMode.OVERWRITE_COPY.name }, + hasOverwriteRecipe = plan.recipesByInstallId.values.flatten().any { it.mode == ModPlacementMode.OVERWRITE_COPY.name } || + plan.reviewedPlansByInstallId.values.any { reviewed -> + reviewed.files.any { it.status == PlannedFileStatus.PLACED && it.mode == ModPlacementMode.OVERWRITE_COPY.name } + }, ) } if (check.conflicts.isNotEmpty() && check.hasOverwriteRecipe) { @@ -1747,6 +1762,7 @@ fun NexusModsDialog( recipes = recipes, gameRootDir = gameRootDir, winePrefix = winePrefix, + reviewedPlan = plan.reviewedPlansByInstallId[install.installId], ) } else { NexusModManager.applyInstall( @@ -1764,6 +1780,7 @@ fun NexusModsDialog( preserveStatusOnError = true, profileId = plan.profileId, priority = plan.stateByInstallId[install.installId]?.priority ?: 0, + reviewedPlan = plan.reviewedPlansByInstallId[install.installId], ) } errors += result.errors.size diff --git a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt index 1efa9b81da..73f9fe6d30 100644 --- a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt @@ -48,6 +48,25 @@ class ModInstallPlanContractTest { assertFalse("/data/user" in sanitized) } + @Test + fun oneRiskPolicy_protectsExecutableRootsRegardlessOfPlanOrigin() { + val rootDll = file("dxgi.dll", PlannedFileStatus.PLACED, "FOMOD mapping").copy( + targetRelativePath = "dxgi.dll", + origin = PlacementOrigin.FOMOD_OPTION, + ) + val dataDll = rootDll.copy( + sourceRelativePath = "MCMHelper.dll", + targetRelativePath = "Data/SKSE/Plugins/MCMHelper.dll", + ) + + val guarded = PlacementRiskPolicy.enforce(ModInstallPlan(listOf(rootDll, dataDll))) + + assertEquals(PlacementRisk.UNSAFE, guarded.files.first().risk) + assertEquals(PlacementRisk.SAFE, guarded.files.last().risk) + assertFalse(guarded.isComplete) + assertTrue(guarded.withRiskApproval(true).isComplete) + } + private fun plan( placed: List, ignored: List = emptyList(), diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index 1e5522dbf7..ab995e67c1 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -793,6 +793,31 @@ class ModMaterializerTest { assertEquals("modded", linkedFile.readText()) } + @Test + fun rollbackAppliedPlan_restoresExistingFilesAndRemovesOnlyNewPlanTargets() = runBlocking { + File(extracted, "Data/config.ini").apply { parentFile?.mkdirs(); writeText("modded") } + File(extracted, "Data/new.txt").writeText("new") + val existing = File(gameDir, "Data/config.ini").apply { parentFile?.mkdirs(); writeText("original") } + val created = File(gameDir, "Data/new.txt") + val plan = ModMaterializer.materializationPlan( + install(), + listOf(recipe(ModPlacementMode.OVERWRITE_COPY, "Data", "Data")), + gameDir, + "", + ) + val applied = ModMaterializer.apply(install(), plan, backupDir, allowOverwrite = true) + val restoreSkipped = ModMaterializer.restoreBackups(applied.manifests) + val restored = applied.manifests + .filter { it.backupPath.isNotBlank() && it.targetPath !in restoreSkipped } + .mapTo(mutableSetOf()) { it.targetPath } + + val rollbackSkipped = ModMaterializer.rollbackAppliedPlan(plan, restored) + + assertTrue(rollbackSkipped.toString(), rollbackSkipped.isEmpty()) + assertEquals("original", existing.readText()) + assertFalse(created.exists()) + } + private fun install() = ModInstall( installId = "install", appId = "STEAM_1", diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt index fc891fe87b..527debf63f 100644 --- a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -106,6 +106,43 @@ class ModOwnershipManifestTest { assertEquals(1, diff.stale) } + @Test + fun ownershipDecisions_restoreTheReviewedPlan_andKeepOneUndoGeneration() { + val root = temporaryFolder.newFolder("history") + val first = manifest("install", "Data/First.txt", "one", priority = 1).copy( + decisions = listOf( + ModInstallDecision( + sourceRelativePath = "First.txt", + targetRoot = "GAME_DIR", + targetRelativePath = "Data/First.txt", + normalizedTargetKey = "game_dir:data/first.txt", + status = PlannedFileStatus.PLACED.name, + origin = PlacementOrigin.FOMOD_REQUIRED.name, + mode = ModPlacementMode.OVERWRITE_COPY.name, + priority = 4, + reason = "Required installer file", + outcome = "CREATED", + sizeBytes = 3, + evidence = listOf("requiredFiles"), + ), + ), + planProducerId = "fomod", + planProducerVersion = 2, + ) + val second = first.copy(planDigest = "second", files = first.files.map { it.copy(installedHash = "two") }) + ModOwnershipStore.writePending(root, first) + ModOwnershipStore.commit(root, first.installId) + ModOwnershipStore.writePending(root, second) + ModOwnershipStore.commit(root, second.installId) + + val restored = ModOwnershipStore.reviewedPlan(root, "install") + + assertEquals("fomod", restored?.producerId) + assertEquals("Data/First.txt", restored?.files?.single()?.targetRelativePath) + assertEquals(listOf("requiredFiles"), restored?.files?.single()?.evidence) + assertEquals(first, ModOwnershipStore.readPrevious(root, "install")) + } + private fun owned(source: String, target: String): ModOwnedFile = ModOwnedFile( sourceRelativePath = source, targetRoot = "GAME_DIR", From 43283ce09368b09fc7e8bce6f0610cafce2109df Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 18:56:49 -0500 Subject: [PATCH 22/60] feat: serialize profile deployment transactions --- .../mods/ModDeploymentCoordinator.kt | 13 +- .../ui/component/dialog/NexusModsDialog.kt | 225 ++++++++++-------- .../dialog/NexusModsPlacementSections.kt | 26 +- .../mods/ModDeploymentCoordinatorTest.kt | 14 ++ 4 files changed, 168 insertions(+), 110 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt index f3e5361409..c814a55c7b 100644 --- a/app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentCoordinator.kt @@ -1,20 +1,31 @@ package app.gamenative.mods +import kotlin.coroutines.AbstractCoroutineContextElement +import kotlin.coroutines.CoroutineContext +import kotlinx.coroutines.currentCoroutineContext +import kotlinx.coroutines.withContext import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock object ModDeploymentCoordinator { private data class Entry(val mutex: Mutex = Mutex(), var users: Int = 0) + private class HeldGameLocks(val keys: Set) : AbstractCoroutineContextElement(Key) { + companion object Key : CoroutineContext.Key + } private val entries = mutableMapOf() suspend fun withGameLock(appId: String, block: suspend () -> T): T { val key = appId.ifBlank { "unknown-game" } + val held = currentCoroutineContext()[HeldGameLocks] + if (key in held?.keys.orEmpty()) return block() val entry = synchronized(entries) { entries.getOrPut(key, ::Entry).also { it.users++ } } return try { - entry.mutex.withLock { block() } + entry.mutex.withLock { + withContext(HeldGameLocks(held?.keys.orEmpty() + key)) { block() } + } } finally { synchronized(entries) { entry.users-- diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 99e814fb16..3b670abbb0 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -103,6 +103,7 @@ import app.gamenative.mods.ModArchiveInstallAssessor import app.gamenative.mods.ModConflictAnalyzer import app.gamenative.mods.ModDownloadInfo import app.gamenative.mods.ModDownloadRegistry +import app.gamenative.mods.ModDeploymentCoordinator import app.gamenative.mods.ModFileConflictReport import app.gamenative.mods.ModHealthAction import app.gamenative.mods.ModHealthReport @@ -111,6 +112,7 @@ import app.gamenative.mods.ModImportProgress import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.ModMaterializer import app.gamenative.mods.PlannedFileStatus +import app.gamenative.mods.PlacementRiskPolicy import app.gamenative.mods.ModPathDetector import app.gamenative.mods.ModPlacementConflict import app.gamenative.mods.ModPlacementPreset @@ -380,6 +382,7 @@ private data class ProfileOrderApplyResult( val plugins: List, val pluginIssues: List, val pluginAssetIssues: List, + val disabledSkipped: Int = 0, ) @Composable @@ -1712,10 +1715,10 @@ fun NexusModsDialog( } } - if (plan.disabledInstalls.isNotEmpty()) { - loadingMessage = context.getString(R.string.nexus_applying_mod_order) - disabledSkipped = withContext(Dispatchers.IO) { - plan.disabledInstalls.sumOf { install -> + loadingMessage = context.getString(R.string.nexus_applying_mod_order) + val result = withContext(Dispatchers.IO) { + ModDeploymentCoordinator.withGameLock(libraryItem.appId) { + var transactionDisabledSkipped = plan.disabledInstalls.sumOf { install -> NexusModManager.disableInstall( context = context, install = install, @@ -1724,110 +1727,116 @@ fun NexusModsDialog( winePrefix = winePrefix, ).size } - } - } - - if (plan.rebuildManagedOverlay) { - loadingMessage = context.getString(R.string.nexus_applying_mod_order) - disabledSkipped += withContext(Dispatchers.IO) { - plan.configuredInstalls.asReversed().sumOf { install -> - NexusModManager.disableInstall( - context = context, - install = install, - restoreBackups = true, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - ).size + if (plan.rebuildManagedOverlay) { + transactionDisabledSkipped += plan.configuredInstalls.asReversed().sumOf { install -> + NexusModManager.disableInstall( + context = context, + install = install, + restoreBackups = true, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + ).size + } + effectiveAllowOverwrite = true } - } - if (disabledSkipped > 0) { - SnackbarManager.show(context.getString(R.string.nexus_changed_disabled_files_left_in_place, disabledSkipped)) - return@launch - } - effectiveAllowOverwrite = true - } - - loadingMessage = context.getString(R.string.nexus_applying_mod_order) - val result = withContext(Dispatchers.IO) { - var errors = 0 - plan.installsToApply.forEach { install -> - val recipes = plan.recipesByInstallId[install.installId].orEmpty() - val result = if ( - !effectiveAllowOverwrite && - install.status == ModInstallStatus.APPLIED.name && - install.installId in plan.missingTargetRepairInstallIds - ) { - NexusModManager.repairMissingAppliedTargets( - install = install, - recipes = recipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - reviewedPlan = plan.reviewedPlansByInstallId[install.installId], - ) - } else { - NexusModManager.applyInstall( - context = context, - install = if (plan.rebuildManagedOverlay) { - install.copy(status = ModInstallStatus.DISABLED.name) - } else { - install - }, - recipes = recipes, - gameRootDir = gameRootDir, - winePrefix = winePrefix, - allowOverwrite = effectiveAllowOverwrite, - saveLastPlacement = false, - preserveStatusOnError = true, - profileId = plan.profileId, - priority = plan.stateByInstallId[install.installId]?.priority ?: 0, - reviewedPlan = plan.reviewedPlansByInstallId[install.installId], + if (plan.rebuildManagedOverlay && transactionDisabledSkipped > 0) { + return@withGameLock ProfileOrderApplyResult( + errors = 0, + bethesdaGame = null, + plugins = emptyList(), + pluginIssues = emptyList(), + pluginAssetIssues = emptyList(), + disabledSkipped = transactionDisabledSkipped, ) } - errors += result.errors.size - } - val game = BethesdaPluginManager.detectGame(libraryItem.name) - if (errors == 0 && game != null) { - val pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game) - if (pluginsFile != null) { - val appliedInstalls = plan.configuredInstalls.map { it.copy(status = ModInstallStatus.APPLIED.name) } - val detectedPlugins = applyCollectionPluginOrder( - BethesdaPluginManager.detectPlugins( - installs = appliedInstalls, - recipesByInstallId = plan.recipesByInstallId, - prioritiesByInstallId = plan.stateByInstallId.mapValues { it.value.priority }, + + var errors = 0 + for (install in plan.installsToApply) { + val recipes = plan.recipesByInstallId[install.installId].orEmpty() + val applyResult = if ( + !effectiveAllowOverwrite && + install.status == ModInstallStatus.APPLIED.name && + install.installId in plan.missingTargetRepairInstallIds + ) { + NexusModManager.repairMissingAppliedTargets( + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + reviewedPlan = plan.reviewedPlansByInstallId[install.installId], + ) + } else { + NexusModManager.applyInstall( + context = context, + install = if (plan.rebuildManagedOverlay) { + install.copy(status = ModInstallStatus.DISABLED.name) + } else { + install + }, + recipes = recipes, gameRootDir = gameRootDir, winePrefix = winePrefix, + allowOverwrite = effectiveAllowOverwrite, + saveLastPlacement = false, + preserveStatusOnError = true, + profileId = plan.profileId, + priority = plan.stateByInstallId[install.installId]?.priority ?: 0, + reviewedPlan = plan.reviewedPlansByInstallId[install.installId], + ) + } + errors += applyResult.errors.size + if (applyResult.errors.isNotEmpty()) break + } + val game = BethesdaPluginManager.detectGame(libraryItem.name) + if (errors == 0 && game != null) { + val pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game) + if (pluginsFile != null) { + val appliedInstalls = plan.configuredInstalls.map { it.copy(status = ModInstallStatus.APPLIED.name) } + val detectedPlugins = applyCollectionPluginOrder( + BethesdaPluginManager.detectPlugins( + installs = appliedInstalls, + recipesByInstallId = plan.recipesByInstallId, + prioritiesByInstallId = plan.stateByInstallId.mapValues { it.value.priority }, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + pluginsFile = pluginsFile, + defaultEnabled = true, + ), + collectionPluginOrder, + ) + BethesdaPluginManager.updateManagedPluginsTxt( + file = pluginsFile, + managedPlugins = detectedPlugins, + game = game, + gameRootDir = gameRootDir, + ) + val issues = BethesdaPluginManager.diagnosePluginMasters( + managedPlugins = detectedPlugins, + game = game, + gameRootDir = gameRootDir, pluginsFile = pluginsFile, - defaultEnabled = true, - ), - collectionPluginOrder, - ) - BethesdaPluginManager.updateManagedPluginsTxt( - file = pluginsFile, - managedPlugins = detectedPlugins, - game = game, - gameRootDir = gameRootDir, - ) - val issues = BethesdaPluginManager.diagnosePluginMasters( - managedPlugins = detectedPlugins, - game = game, - gameRootDir = gameRootDir, - pluginsFile = pluginsFile, - ) - ProfileOrderApplyResult( - errors = errors, - bethesdaGame = game, - plugins = detectedPlugins, - pluginIssues = issues, - pluginAssetIssues = BethesdaPluginManager.diagnosePluginAssets(detectedPlugins), - ) + ) + ProfileOrderApplyResult( + errors = errors, + bethesdaGame = game, + plugins = detectedPlugins, + pluginIssues = issues, + pluginAssetIssues = BethesdaPluginManager.diagnosePluginAssets(detectedPlugins), + disabledSkipped = transactionDisabledSkipped, + ) + } else { + ProfileOrderApplyResult(errors, null, emptyList(), emptyList(), emptyList(), transactionDisabledSkipped) + } } else { - ProfileOrderApplyResult(errors, null, emptyList(), emptyList(), emptyList()) + ProfileOrderApplyResult(errors, null, emptyList(), emptyList(), emptyList(), transactionDisabledSkipped) } - } else { - ProfileOrderApplyResult(errors, null, emptyList(), emptyList(), emptyList()) } } + disabledSkipped = result.disabledSkipped + if (plan.rebuildManagedOverlay && disabledSkipped > 0) { + SnackbarManager.show(context.getString(R.string.nexus_changed_disabled_files_left_in_place, disabledSkipped)) + return@launch + } result.bethesdaGame?.let { bethesdaGame = it bethesdaPlugins = result.plugins @@ -3062,7 +3071,7 @@ fun NexusModsDialog( return } } - val reviewedPlan = automaticPlan ?: reviewedPlacementPlan + val initialReviewedPlan = automaticPlan ?: reviewedPlacementPlan if ( selectedFomodInstaller != null && placementChoice != PlacementChoice.CUSTOM && @@ -3081,6 +3090,23 @@ fun NexusModsDialog( try { placementApplyStatusMessage = null loadingMessage = context.getString(R.string.nexus_checking_target_files) + val reviewedPlan = withContext(Dispatchers.IO) { + val base = initialReviewedPlan ?: ModMaterializer.materializationPlan( + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + captureTargetHashes = false, + ).reviewedPlan + PlacementRiskPolicy.enforce(base).withRiskApproval(riskyAutomaticPlanApproved) + } + if (!reviewedPlan.isComplete) { + reviewedPlacementPlan = reviewedPlan + val message = context.getString(R.string.nexus_plan_blocked) + placementApplyStatusMessage = message + SnackbarManager.show(message) + return@launch + } val (rawConflicts, conflicts) = withContext(Dispatchers.IO) { val raw = ModMaterializer.scanConflicts( install = install, @@ -3418,7 +3444,6 @@ fun NexusModsDialog( riskyAutomaticPlanApproved = riskyAutomaticPlanApproved, onRiskyAutomaticPlanApprovalChange = { approved -> placementApplyStatusMessage = null - reviewedPlacementPlan = null riskyAutomaticPlanApproved = approved }, reviewedPlan = reviewedPlacementPlan, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index b3d52f2ee3..56fb2a5964 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -81,6 +81,7 @@ import app.gamenative.mods.ModPlacementSources import app.gamenative.mods.ModTargetResolver import app.gamenative.mods.PlannedFileStatus import app.gamenative.mods.PlacementRisk +import app.gamenative.mods.PlacementRiskPolicy import app.gamenative.mods.ResolvedModTargetRoot import app.gamenative.ui.component.NoExtractOutlinedTextField import app.gamenative.utils.StorageUtils @@ -147,7 +148,12 @@ internal fun PlacementSection( var showFomodWizard by remember(install.installId, fomodInstaller) { mutableStateOf(false) } val destinationsValid = drafts.all { draft -> roots.any { it.type.name == draft.targetRoot } } val automaticPlan = automaticPlacement.recommended?.plan - val visiblePlan = if (placementChoice == PlacementChoice.AUTOMATIC) automaticPlan else reviewedPlan + ?.let(PlacementRiskPolicy::enforce) + ?.withRiskApproval(riskyAutomaticPlanApproved) + val configuredPlan = reviewedPlan + ?.let(PlacementRiskPolicy::enforce) + ?.withRiskApproval(riskyAutomaticPlanApproved) + val visiblePlan = if (placementChoice == PlacementChoice.AUTOMATIC) automaticPlan else configuredPlan val reconfigurationDiff = remember(previousOwnership, visiblePlan) { visiblePlan?.let { ModOwnershipPlanDiffer.compare(previousOwnership, it) } ?.takeIf { previousOwnership != null && it.hasChanges } @@ -155,10 +161,13 @@ internal fun PlacementSection( val targetInspection = remember(automaticPlan, roots) { automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } } - val automaticBlocked = placementChoice == PlacementChoice.AUTOMATIC && - (automaticPlanLoading || - (automaticPlan?.isComplete != true || targetInspection?.ambiguousPaths?.isNotEmpty() == true) - ) + val applyBlocked = when { + placementChoice == PlacementChoice.AUTOMATIC -> automaticPlanLoading || + automaticPlan?.isComplete != true || + targetInspection?.ambiguousPaths?.isNotEmpty() == true + visiblePlan != null -> !visiblePlan.isComplete + else -> false + } Surface( modifier = Modifier.fillMaxWidth(), @@ -261,8 +270,7 @@ internal fun PlacementSection( } if ( - placementChoice == PlacementChoice.AUTOMATIC && - automaticPlan?.files.orEmpty().any { it.risk == PlacementRisk.UNSAFE } + visiblePlan?.files.orEmpty().any { it.risk == PlacementRisk.UNSAFE } ) { Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.errorContainer) { Row( @@ -369,7 +377,7 @@ internal fun PlacementSection( } Button( onClick = onSaveAndApply, - enabled = roots.isNotEmpty() && destinationsValid && !automaticBlocked, + enabled = roots.isNotEmpty() && destinationsValid && !applyBlocked, modifier = Modifier.fillMaxWidth(), ) { Icon(Icons.Default.Save, contentDescription = null, modifier = Modifier.size(18.dp)) @@ -388,7 +396,7 @@ internal fun PlacementSection( } Button( onClick = onSaveAndApply, - enabled = roots.isNotEmpty() && destinationsValid && !automaticBlocked, + enabled = roots.isNotEmpty() && destinationsValid && !applyBlocked, ) { Icon(Icons.Default.Save, contentDescription = null, modifier = Modifier.size(18.dp)) Spacer(Modifier.size(8.dp)) diff --git a/app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt b/app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt index 0aae8af9ad..5a49ea3792 100644 --- a/app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModDeploymentCoordinatorTest.kt @@ -6,6 +6,7 @@ import kotlinx.coroutines.awaitAll import kotlinx.coroutines.delay import kotlinx.coroutines.runBlocking import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue import org.junit.Test class ModDeploymentCoordinatorTest { @@ -26,4 +27,17 @@ class ModDeploymentCoordinatorTest { assertEquals(1, maximum.get()) } + + @Test + fun oneProfileTransactionCanCallNestedGameMutations() = runBlocking { + var nestedCompleted = false + + ModDeploymentCoordinator.withGameLock("game") { + ModDeploymentCoordinator.withGameLock("game") { + nestedCompleted = true + } + } + + assertTrue(nestedCompleted) + } } From c8eef3c67e893b328aa232db72b825338079b309 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 19:03:49 -0500 Subject: [PATCH 23/60] feat: resume installer configuration safely --- .../gamenative/mods/FomodInstallPlanner.kt | 4 +- .../mods/GenericOptionSetDetector.kt | 40 +++++-- .../gamenative/mods/ModConfigurationDraft.kt | 108 ++++++++++++++++++ .../ui/component/dialog/NexusModsDialog.kt | 60 +++++++++- .../dialog/NexusModsFomodSections.kt | 21 ++++ .../dialog/NexusModsPlacementSections.kt | 4 + .../mods/AutomaticPlacementPlannerTest.kt | 18 +++ .../mods/ModConfigurationDraftTest.kt | 45 ++++++++ 8 files changed, 285 insertions(+), 15 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt create mode 100644 app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 2110046527..968ccc2286 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -146,7 +146,7 @@ object FomodPlanExpander { if (missing.isNotEmpty()) add("${missing.size} selected FOMOD mapping(s) have missing or mismatched sources") if (planned.any { it.status == PlannedFileStatus.UNSUPPORTED }) add("Some selected FOMOD destinations are invalid") } - return ModInstallPlan( + return PlacementRiskPolicy.enforce(ModInstallPlan( files = planned.sortedWith( compareBy { it.normalizedTargetKey.orEmpty() } .thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) } @@ -155,7 +155,7 @@ object FomodPlanExpander { blockingIssues = blockers.distinct(), producerId = "fomod", producerVersion = 1, - ) + )) } private data class ExpandedFomodFile( diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt index 5d98dbff91..e62dede151 100644 --- a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -17,14 +17,38 @@ data class GenericOptionGroup( object GenericOptionSetDetector { fun detect(index: ModArchiveIndex): List { if (index.hasFomod) return emptyList() - val roots = index.nodes.filter { '/' !in it.displayPath && it.descendantFileCount > 0 } - val signatures = roots.associateWith { root -> - index.filesUnder(root.displayPath).mapTo(mutableSetOf()) { file -> - file.normalizedKey.removePrefix("${root.normalizedKey}/") + val directories = index.nodes.filter { it.descendantFileCount > 0 } + val siblingsByParent = directories.groupBy { node -> node.normalizedKey.substringBeforeLast('/', "") } + val detected = siblingsByParent.values.flatMap { siblings -> detectSiblingGroups(index, siblings) } + .sortedWith(compareBy { it.choices.first().sourceDirectory.count { char -> char == '/' } }.thenBy { it.stableId }) + val accepted = mutableListOf() + detected.forEach { group -> + val nestedInsideAcceptedChoice = accepted.any { outer -> + outer.choices.any { choice -> + group.choices.all { nested -> + val path = normalizeArchiveDisplayPath(nested.sourceDirectory) + val root = normalizeArchiveDisplayPath(choice.sourceDirectory) + path.equals(root, ignoreCase = true) || path.startsWith("$root/", ignoreCase = true) + } + } } + if (!nestedInsideAcceptedChoice) accepted += group } - val related = roots.associateWith { root -> - roots.filter { other -> + return accepted + } + + private fun detectSiblingGroups( + index: ModArchiveIndex, + siblings: List, + ): List { + if (siblings.size < 2) return emptyList() + val signatures = siblings.associateWith { node -> + index.filesUnder(node.displayPath).mapTo(mutableSetOf()) { file -> + file.normalizedKey.removePrefix("${node.normalizedKey}/") + } + } + val related = siblings.associateWith { root -> + siblings.filter { other -> if (root == other) return@filter false val overlap = signatures.getValue(root).intersect(signatures.getValue(other)).size val smaller = minOf(signatures.getValue(root).size, signatures.getValue(other).size).coerceAtLeast(1) @@ -33,7 +57,7 @@ object GenericOptionSetDetector { } val visited = mutableSetOf() val groups = mutableListOf>() - roots.forEach { root -> + siblings.forEach { root -> if (!visited.add(root.normalizedKey)) return@forEach val component = mutableListOf(root) val queue = ArrayDeque(related.getValue(root)) @@ -46,7 +70,7 @@ object GenericOptionSetDetector { if (component.size > 1) groups += component } val optionRootKeys = groups.flatten().mapTo(mutableSetOf()) { it.normalizedKey } - val common = roots.filter { it.normalizedKey !in optionRootKeys }.map { it.displayPath }.sorted() + val common = siblings.filter { it.normalizedKey !in optionRootKeys }.map { it.displayPath }.sorted() return groups.map { choices -> GenericOptionGroup( stableId = choices.map { it.normalizedKey }.sorted().joinToString("|").hashCode().toUInt().toString(16), diff --git a/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt b/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt new file mode 100644 index 0000000000..662cbc461f --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt @@ -0,0 +1,108 @@ +package app.gamenative.mods + +import app.gamenative.data.ModInstall +import app.gamenative.data.ModPlacementMode +import app.gamenative.data.ModPlacementRecipe +import app.gamenative.data.ModTargetRoot +import java.io.File +import java.io.FileOutputStream +import java.nio.file.Files +import java.nio.file.StandardCopyOption +import java.util.Locale +import kotlinx.serialization.Serializable +import kotlinx.serialization.decodeFromString +import kotlinx.serialization.encodeToString +import kotlinx.serialization.json.Json + +@Serializable +data class ModConfigurationDraft( + val version: Int = 1, + val installId: String, + val archiveIdentity: String, + val placementChoice: String, + val automaticOptions: Map = emptyMap(), + val riskyTargetsApproved: Boolean = false, + val fomodSelections: Map> = emptyMap(), + val recipes: List = emptyList(), + val updatedAt: Long = System.currentTimeMillis(), +) + +@Serializable +data class ModConfigurationRecipe( + val sourceSubpath: String = "", + val targetRoot: String = ModTargetRoot.GAME_DIR.name, + val targetRelativePath: String = "", + val targetFileName: String = "", + val mode: String = ModPlacementMode.SYMLINK.name, + val stripPrefixSegments: Int = 0, + val includeSourceDirectory: Boolean = false, + val enabled: Boolean = true, +) { + fun toRecipe(installId: String) = ModPlacementRecipe( + installId = installId, + sourceSubpath = sourceSubpath, + targetRoot = targetRoot, + targetRelativePath = targetRelativePath, + targetFileName = targetFileName, + mode = mode, + stripPrefixSegments = stripPrefixSegments, + includeSourceDirectory = includeSourceDirectory, + enabled = enabled, + ) + + companion object { + fun from(recipe: ModPlacementRecipe) = ModConfigurationRecipe( + sourceSubpath = recipe.sourceSubpath, + targetRoot = recipe.targetRoot, + targetRelativePath = recipe.targetRelativePath, + targetFileName = recipe.targetFileName, + mode = recipe.mode, + stripPrefixSegments = recipe.stripPrefixSegments, + includeSourceDirectory = recipe.includeSourceDirectory, + enabled = recipe.enabled, + ) + } +} + +object ModConfigurationDraftStore { + private val json = Json { ignoreUnknownKeys = true; encodeDefaults = true } + + fun archiveIdentity(install: ModInstall): String = install.archiveSha256.ifBlank { + listOf(install.fileName.lowercase(Locale.ROOT), install.sizeBytes.toString(), install.nexusFileId?.toString().orEmpty()) + .joinToString("|") + } + + fun read(root: File, install: ModInstall): ModConfigurationDraft? { + val file = file(root, install.installId) + if (!file.isFile) return null + val draft = runCatching { json.decodeFromString(file.readText()) }.getOrNull() + ?: return null + return draft.takeIf { + it.installId == install.installId && it.archiveIdentity == archiveIdentity(install) + } + } + + fun write(root: File, draft: ModConfigurationDraft) { + val target = file(root, draft.installId) + val temp = File(target.parentFile, "${target.name}.tmp") + target.parentFile?.mkdirs() + FileOutputStream(temp).use { output -> + output.write(json.encodeToString(draft.copy(updatedAt = System.currentTimeMillis())).toByteArray(Charsets.UTF_8)) + output.fd.sync() + } + runCatching { + Files.move(temp.toPath(), target.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING) + }.getOrElse { + temp.copyTo(target, overwrite = true) + temp.delete() + } + } + + fun delete(root: File, installId: String) { + file(root, installId).delete() + File(file(root, installId).parentFile, "${file(root, installId).name}.tmp").delete() + } + + private fun file(root: File, installId: String): File = + File(File(root, "configuration"), "${installId.replace(Regex("[^A-Za-z0-9._-]"), "_")}.json") +} diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 3b670abbb0..2193748c36 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -101,6 +101,9 @@ import app.gamenative.mods.truncateAtCodePointBoundary import app.gamenative.mods.ModArchiveEntry import app.gamenative.mods.ModArchiveInstallAssessor import app.gamenative.mods.ModConflictAnalyzer +import app.gamenative.mods.ModConfigurationDraft +import app.gamenative.mods.ModConfigurationDraftStore +import app.gamenative.mods.ModConfigurationRecipe import app.gamenative.mods.ModDownloadInfo import app.gamenative.mods.ModDownloadRegistry import app.gamenative.mods.ModDeploymentCoordinator @@ -151,6 +154,7 @@ import app.gamenative.ui.util.LocalSnackbarHostController import app.gamenative.ui.util.SnackbarManager import app.gamenative.utils.StorageUtils import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.delay @@ -830,6 +834,8 @@ fun NexusModsDialog( var reviewedPlacementPlan by remember { mutableStateOf(null) } var automaticOptionSelections by remember { mutableStateOf>(emptyMap()) } var riskyAutomaticPlanApproved by remember { mutableStateOf(false) } + var fomodSelectionDraft by remember { mutableStateOf>>(emptyMap()) } + var configurationDraftLoaded by remember { mutableStateOf(false) } var automaticPlacementResult by remember { mutableStateOf(null) } var automaticPlacementLoading by remember { mutableStateOf(false) } var selectedOwnership by remember { mutableStateOf(null) } @@ -1919,9 +1925,11 @@ fun NexusModsDialog( } fun loadRecipes(install: ModInstall?) { + configurationDraftLoaded = false reviewedPlacementPlan = null automaticOptionSelections = emptyMap() riskyAutomaticPlanApproved = false + fomodSelectionDraft = emptyMap() automaticPlacementResult = null recipeDrafts.clear() if (install == null || !install.canPlaceFiles()) { @@ -1929,18 +1937,29 @@ fun NexusModsDialog( return } scope.launch { - val recipes = withContext(Dispatchers.IO) { dao.getRecipesForInstall(install.installId) } + val (recipes, savedDraft) = withContext(Dispatchers.IO) { + dao.getRecipesForInstall(install.installId) to + ModConfigurationDraftStore.read(NexusModManager.cacheRoot(context, install.appId), install) + } + val restoredRecipes = savedDraft?.recipes.orEmpty().map { it.toRecipe(install.installId) } + automaticOptionSelections = savedDraft?.automaticOptions.orEmpty() + riskyAutomaticPlanApproved = savedDraft?.riskyTargetsApproved == true + fomodSelectionDraft = savedDraft?.fomodSelections.orEmpty().mapValues { it.value.toSet() } recipeDrafts.clear() - if (recipes.isEmpty()) { - placementChoice = PlacementChoice.AUTOMATIC + val selectedRecipes = restoredRecipes.ifEmpty { recipes } + val restoredChoice = savedDraft?.placementChoice + ?.let { runCatching { PlacementChoice.valueOf(it) }.getOrNull() } + if (selectedRecipes.isEmpty()) { + placementChoice = restoredChoice ?: PlacementChoice.AUTOMATIC recipeDrafts += automaticPlacementResult ?.let { automaticDraftsFor(it, libraryItem.name, archiveEntries, defaultDraft) } .orEmpty() .ifEmpty { listOf(defaultDraft) } } else { - placementChoice = PlacementChoice.CUSTOM - recipeDrafts += recipes.map { it.toDraft() } + placementChoice = restoredChoice ?: PlacementChoice.CUSTOM + recipeDrafts += selectedRecipes.map { it.toDraft() } } + configurationDraftLoaded = true } } @@ -2976,6 +2995,35 @@ fun NexusModsDialog( recipes = recipeDrafts.map { draft -> draft.toRecipe(install.installId) }, ) + LaunchedEffect( + selectedInstall?.installId, + configurationDraftLoaded, + placementChoice, + automaticOptionSelections, + riskyAutomaticPlanApproved, + fomodSelectionDraft, + recipeDrafts.toList(), + ) { + val install = selectedInstall ?: return@LaunchedEffect + if (!configurationDraftLoaded || !install.canPlaceFiles()) return@LaunchedEffect + delay(200) + val recipes = recipeDrafts.map { it.toRecipe(install.installId) } + withContext(Dispatchers.IO) { + ModConfigurationDraftStore.write( + NexusModManager.cacheRoot(context, install.appId), + ModConfigurationDraft( + installId = install.installId, + archiveIdentity = ModConfigurationDraftStore.archiveIdentity(install), + placementChoice = placementChoice.name, + automaticOptions = automaticOptionSelections, + riskyTargetsApproved = riskyAutomaticPlanApproved, + fomodSelections = fomodSelectionDraft.mapValues { (_, values) -> values.sorted() }, + recipes = recipes.map(ModConfigurationRecipe::from), + ), + ) + } + } + suspend fun applyRecipesInternal( install: ModInstall, recipes: List, @@ -3447,6 +3495,8 @@ fun NexusModsDialog( riskyAutomaticPlanApproved = approved }, reviewedPlan = reviewedPlacementPlan, + initialFomodSelections = fomodSelectionDraft, + onFomodSelectionsChanged = { fomodSelectionDraft = it }, previousOwnership = selectedOwnership, placementChoice = placementChoice, canUseLastPlacement = lastPlacementDrafts.isNotEmpty(), diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index c1a4350829..cdd090f3fc 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -30,10 +30,12 @@ import androidx.compose.material3.Surface import androidx.compose.material3.Text import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateMapOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.snapshotFlow import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier @@ -57,6 +59,7 @@ import app.gamenative.mods.effectiveType import com.skydoves.landscapist.ImageOptions import com.skydoves.landscapist.coil.CoilImage import java.io.File +import kotlinx.coroutines.flow.distinctUntilChanged @Composable internal fun FomodSummarySection( installer: FomodInstaller, @@ -103,6 +106,8 @@ internal fun FomodWizardDialog( environment: FomodEnvironmentSnapshot, extractedRoot: File, baseDraft: RecipeDraft, + initialSelections: Map> = emptyMap(), + onSelectionsChanged: (Map>) -> Unit = {}, onApply: (List, ModInstallPlan?, Int) -> Unit, onDismiss: () -> Unit, ) { @@ -152,9 +157,25 @@ internal fun FomodWizardDialog( put("$stepIndex:$groupIndex", defaults) } } + initialSelections.forEach { (groupKey, selected) -> + val parts = groupKey.split(':').mapNotNull(String::toIntOrNull) + val group = parts.takeIf { it.size == 2 } + ?.let { installer.steps.getOrNull(it[0])?.groups?.getOrNull(it[1]) } + ?: return@forEach + val allowed = group.plugins.indices.mapTo(mutableSetOf()) { pluginIndex -> + FomodRecipeGenerator.pluginKey(parts[0], parts[1], pluginIndex) + } + put(groupKey, selected.intersect(allowed)) + } } } + LaunchedEffect(selectedByGroup) { + snapshotFlow { selectedByGroup.toMap() } + .distinctUntilChanged() + .collect(onSelectionsChanged) + } + val selectedFlags = fomodSelectedFlags(installer, selectedByGroup) val fallbackStepNames = installer.steps.indices.map { index -> stringResource(R.string.nexus_fomod_step, index + 1) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 56fb2a5964..eca02d9bcf 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -130,6 +130,8 @@ internal fun PlacementSection( riskyAutomaticPlanApproved: Boolean, onRiskyAutomaticPlanApprovalChange: (Boolean) -> Unit, reviewedPlan: ModInstallPlan?, + initialFomodSelections: Map>, + onFomodSelectionsChanged: (Map>) -> Unit, previousOwnership: ModOwnershipManifest?, placementChoice: PlacementChoice, canUseLastPlacement: Boolean, @@ -428,6 +430,8 @@ internal fun PlacementSection( // first generated mapping here recursively prefixes that mapping whenever // an installer is reconfigured. baseDraft = fomodBaseDraft, + initialSelections = initialFomodSelections, + onSelectionsChanged = onFomodSelectionsChanged, onApply = { generatedDrafts, plan, unsupportedCount -> showFomodWizard = false onFomodRecipes(generatedDrafts, plan, unsupportedCount) diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index c6e02a08d0..c0547b9b73 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -85,6 +85,24 @@ class AutomaticPlacementPlannerTest { assertTrue(selected.files.any { it.sourceRelativePath.startsWith("Option A/") && it.status == PlannedFileStatus.INTENTIONALLY_IGNORED }) } + @Test + fun nestedStructuralVariants_areDetectedWithoutDependingOnFolderNames() { + val entries = archive( + "Package/Choices/Blue/Data/textures/x.dds", + "Package/Choices/Red/Data/textures/x.dds", + "Package/Choices/Common/Data/scripts/y.pex", + ) + val result = AutomaticPlacementPlanner.plan("Skyrim Special Edition", entries) + val group = result.optionGroups.single() + + assertEquals( + setOf("Package/Choices/Blue", "Package/Choices/Red"), + group.choices.mapTo(mutableSetOf()) { it.sourceDirectory }, + ) + assertEquals(listOf("Package/Choices/Common"), group.commonSourceDirectories) + assertFalse(result.recommended!!.plan.isComplete) + } + @Test fun mixedDataAndRootBinary_areSeparatedAndRootBinaryRequiresReview() { val plan = AutomaticPlacementPlanner.plan( diff --git a/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt b/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt new file mode 100644 index 0000000000..4a97027c86 --- /dev/null +++ b/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt @@ -0,0 +1,45 @@ +package app.gamenative.mods + +import app.gamenative.data.ModInstall +import java.io.File +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder + +class ModConfigurationDraftTest { + @get:Rule + val temporaryFolder = TemporaryFolder() + + @Test + fun draftRoundTrip_isScopedToTheExactArchive_andCanBeCleared() { + val root = temporaryFolder.newFolder("cache") + val install = install("hash-one") + val draft = ModConfigurationDraft( + installId = install.installId, + archiveIdentity = ModConfigurationDraftStore.archiveIdentity(install), + placementChoice = "CUSTOM", + automaticOptions = mapOf("runtime" to "x64"), + fomodSelections = mapOf("0:0" to listOf("0:0:1")), + recipes = listOf(ModConfigurationRecipe(sourceSubpath = "Data", targetRelativePath = "Data")), + ) + + ModConfigurationDraftStore.write(root, draft) + + assertEquals(draft.copy(updatedAt = ModConfigurationDraftStore.read(root, install)!!.updatedAt), ModConfigurationDraftStore.read(root, install)) + assertNull(ModConfigurationDraftStore.read(root, install("different-hash"))) + ModConfigurationDraftStore.delete(root, install.installId) + assertNull(ModConfigurationDraftStore.read(root, install)) + } + + private fun install(hash: String) = ModInstall( + installId = "install", + appId = "game", + modName = "Mod", + fileName = "mod.zip", + archivePath = File(temporaryFolder.root, "mod.zip").absolutePath, + extractedPath = File(temporaryFolder.root, "extracted").absolutePath, + archiveSha256 = hash, + ) +} From e3b63cee2c251e90c9730ed9864c38044b6df836 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 19:16:27 -0500 Subject: [PATCH 24/60] feat: add safe deployment recovery --- .../app/gamenative/mods/NexusModManager.kt | 97 ++++++++++++++- .../ui/component/dialog/NexusModsDialog.kt | 110 +++++++++++++++--- .../dialog/NexusModsPlacementSections.kt | 13 +++ app/src/main/res/values-da/strings.xml | 8 ++ app/src/main/res/values-de/strings.xml | 8 ++ app/src/main/res/values-es/strings.xml | 8 ++ app/src/main/res/values-fr/strings.xml | 8 ++ app/src/main/res/values-it/strings.xml | 8 ++ app/src/main/res/values-ja/strings.xml | 8 ++ app/src/main/res/values-ko/strings.xml | 8 ++ app/src/main/res/values-pl/strings.xml | 8 ++ app/src/main/res/values-pt-rBR/strings.xml | 8 ++ app/src/main/res/values-ro/strings.xml | 8 ++ app/src/main/res/values-ru/strings.xml | 8 ++ app/src/main/res/values-uk/strings.xml | 8 ++ app/src/main/res/values-zh-rCN/strings.xml | 8 ++ app/src/main/res/values-zh-rTW/strings.xml | 8 ++ app/src/main/res/values/strings.xml | 8 ++ .../mods/ModInstallPlanContractTest.kt | 20 ++++ 19 files changed, 343 insertions(+), 17 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index bdf6fc10cf..11b587a5bb 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -70,6 +70,8 @@ enum class ModHealthAction { REAPPLY_MISSING, RECONFIGURE, REBUILD_PROFILE, + ADOPT_OWNERSHIP, + RESTORE_PREVIOUS, } data class ModHealthIssue( @@ -83,6 +85,7 @@ data class ModHealthIssue( data class ModHealthReport( val issues: List, + val facts: List = emptyList(), ) { val errorCount: Int get() = issues.count { it.severity == ModHealthSeverity.ERROR } val warningCount: Int get() = issues.count { it.severity == ModHealthSeverity.WARNING } @@ -91,6 +94,7 @@ data class ModHealthReport( appendLine("health-version: 1") appendLine("errors: $errorCount") appendLine("warnings: $warningCount") + facts.forEach { fact -> appendLine("fact: ${ModDiagnosticSanitizer.text(fact)}") } issues.forEach { issue -> append(issue.severity.name) append(' ') @@ -741,6 +745,58 @@ object NexusModManager { ) } + suspend fun adoptHistoricalDeployment( + context: Context, + install: ModInstall, + recipes: List, + gameRootDir: File?, + winePrefix: String, + profileId: String = "", + priority: Int = 0, + ): ModPlacementResult = ModDeploymentCoordinator.withGameLock(install.appId) { + withContext(Dispatchers.IO) { + val root = cacheRoot(context, install.appId) + if (install.status != ModInstallStatus.APPLIED.name || ModOwnershipStore.read(root, install.installId) != null) { + return@withContext ModPlacementResult( + created = 0, + skipped = 0, + backedUp = 0, + errors = mapOf(install.modName to "Ownership adoption is only available for an applied historical install without an ownership manifest"), + manifests = emptyList(), + ) + } + val plan = ModMaterializer.materializationPlan( + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + ) + val verification = ModDeploymentVerifier.verify(plan) + if (!plan.isComplete || !verification.successful) { + return@withContext ModPlacementResult( + created = 0, + skipped = 0, + backedUp = 0, + errors = plan.errors + verification.issues.associate { issue -> + issue.targetPath to "${issue.type}: ${issue.detail}" + }, + manifests = emptyList(), + ) + } + val manifests = dao(context).getOverwriteManifests(install.installId) + val ownership = ModOwnershipStore.create( + appId = install.appId, + plan = plan, + overwriteManifests = manifests, + profileId = profileId, + priority = priority, + ) + ModOwnershipStore.writePending(root, ownership) + ModOwnershipStore.commit(root, install.installId) + ModPlacementResult(0, plan.files.size, 0, emptyMap(), emptyList()) + } + } + fun lastPlacementRecipesForApp(appId: String, installId: String): List { val root = runCatching { JSONObject(PrefManager.nexusLastPlacementJson) }.getOrElse { JSONObject() } val recipes = root.optJSONArray(appId) ?: return emptyList() @@ -1126,7 +1182,14 @@ object NexusModManager { val journal = journals[install.installId] if (journal?.checkpoint == ModDeploymentCheckpoint.RECOVERY_REQUIRED) { - add(ModHealthSeverity.ERROR, "Deployment recovery is required", journal.detail, install, ModHealthAction.RECONFIGURE) + val canRestore = ModOwnershipStore.readPrevious(ownershipRoot, install.installId)?.reviewedPlanOrNull() != null + add( + ModHealthSeverity.ERROR, + "Deployment recovery is required", + journal.detail, + install, + if (canRestore) ModHealthAction.RESTORE_PREVIOUS else ModHealthAction.RECONFIGURE, + ) } if (status == null) { @@ -1147,9 +1210,9 @@ object NexusModManager { add( ModHealthSeverity.WARNING, "Ownership adoption is required", - "This historical install remains usable, but destructive cleanup is blocked until it is safely reapplied.", + "This historical install remains usable. Verify its current files to adopt conservative ownership without changing them.", install, - ModHealthAction.RECONFIGURE, + ModHealthAction.ADOPT_OWNERSHIP, ) } else if (ownership.state != ModOwnershipState.ACTIVE) { add(ModHealthSeverity.ERROR, "Ownership state does not match the applied mod", ownership.state.name, install) @@ -1248,7 +1311,33 @@ object NexusModManager { .take(3) .forEach { add(ModHealthSeverity.WARNING, "Orphaned extracted cache", it.name) } - ModHealthReport(issues) + val ownershipProducers = ownershipByInstallId.values + .groupingBy { "${it.planProducerId}@${it.planProducerVersion}" } + .eachCount() + .entries + .sortedBy { it.key } + .joinToString(",") { "${it.key}:${it.value}" } + .ifBlank { "none" } + val journalCheckpoints = journals.values + .groupingBy { it.checkpoint.name } + .eachCount() + .entries + .sortedBy { it.key } + .joinToString(",") { "${it.key}:${it.value}" } + .ifBlank { "none" } + + ModHealthReport( + issues = issues, + facts = listOf( + "installs=${installs.size}", + "ownership-manifests=${ownershipByInstallId.size}", + "ownership-producers=$ownershipProducers", + "deployment-journals=${journals.size}", + "journal-checkpoints=$journalCheckpoints", + "profile-enabled=${enabledPriorities.size}", + "overlay-targets=${ModProfileOverlayPlanner.build(ownershipByInstallId.values.toList(), enabledPriorities).targets.size}", + ), + ) } suspend fun reconcilePendingDeploymentsForApp(context: Context, appId: String): List = diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 2193748c36..aeddab79c2 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -671,6 +671,8 @@ private fun InstallHealthSection( onCheck: () -> Unit, onRebuild: () -> Unit, onReconfigure: (String) -> Unit, + onAdoptOwnership: (String) -> Unit, + onRestorePrevious: (String) -> Unit, onExport: (ModHealthReport) -> Unit, ) { NexusSectionCard { @@ -700,19 +702,24 @@ private fun InstallHealthSection( if (issue.installId.isNotBlank()) { TextButton( onClick = { - if (issue.recommendedAction == ModHealthAction.REAPPLY_MISSING) { - onRebuild() - } else { - onReconfigure(issue.installId) + when (issue.recommendedAction) { + ModHealthAction.REAPPLY_MISSING, + ModHealthAction.REBUILD_PROFILE, + -> onRebuild() + ModHealthAction.ADOPT_OWNERSHIP -> onAdoptOwnership(issue.installId) + ModHealthAction.RESTORE_PREVIOUS -> onRestorePrevious(issue.installId) + ModHealthAction.RECONFIGURE -> onReconfigure(issue.installId) } }, ) { Text( stringResource( - if (issue.recommendedAction == ModHealthAction.REAPPLY_MISSING) { - R.string.nexus_reapply_missing_files - } else { - R.string.nexus_configure + when (issue.recommendedAction) { + ModHealthAction.REAPPLY_MISSING -> R.string.nexus_reapply_missing_files + ModHealthAction.REBUILD_PROFILE -> R.string.nexus_apply_order + ModHealthAction.ADOPT_OWNERSHIP -> R.string.nexus_adopt_ownership + ModHealthAction.RESTORE_PREVIOUS -> R.string.nexus_restore_previous_deployment + ModHealthAction.RECONFIGURE -> R.string.nexus_configure }, ), ) @@ -839,6 +846,7 @@ fun NexusModsDialog( var automaticPlacementResult by remember { mutableStateOf(null) } var automaticPlacementLoading by remember { mutableStateOf(false) } var selectedOwnership by remember { mutableStateOf(null) } + var selectedPreviousOwnership by remember { mutableStateOf(null) } var lastPlacementDrafts by remember(libraryItem.appId) { mutableStateOf>(emptyList()) } var detectedDefaultDraft by remember(libraryItem.appId) { mutableStateOf(null) } val defaultDraft = detectedDefaultDraft ?: fallbackDefaultDraft @@ -1924,6 +1932,77 @@ fun NexusModsDialog( } } + fun adoptInstallOwnership(installId: String) { + val install = installs.firstOrNull { it.installId == installId } ?: return + scope.launch { + healthLoading = true + try { + val profile = activeProfile ?: ModProfileManager.ensureActiveProfile(dao, libraryItem.appId) + val state = ModProfileManager.ensureStateForInstall(dao, profile, install.installId) + val result = NexusModManager.adoptHistoricalDeployment( + context = context, + install = install, + recipes = dao.getRecipesForInstall(install.installId), + gameRootDir = gameRootDir, + winePrefix = winePrefix, + profileId = profile.profileId, + priority = state.priority, + ) + SnackbarManager.show( + if (result.errors.isEmpty()) { + context.getString(R.string.nexus_ownership_adopted) + } else { + context.getString(R.string.nexus_ownership_adoption_failed, result.errors.size) + }, + ) + healthReport = NexusModManager.checkInstallHealthForApp(context, libraryItem.appId, gameRootDir, winePrefix) + } finally { + healthLoading = false + } + } + } + + fun restorePreviousDeployment(installId: String) { + val install = installs.firstOrNull { it.installId == installId } ?: return + if (modApplyInProgress || profileApplyInProgress) return + scope.launch { + modApplyInProgress = true + try { + loadingMessage = context.getString(R.string.nexus_restoring_previous_deployment) + val profile = activeProfile ?: ModProfileManager.ensureActiveProfile(dao, libraryItem.appId) + val state = ModProfileManager.ensureStateForInstall(dao, profile, install.installId) + val result = NexusModManager.restorePreviousDeployment( + context = context, + install = install, + recipes = dao.getRecipesForInstall(install.installId), + gameRootDir = gameRootDir, + winePrefix = winePrefix, + profileId = profile.profileId, + priority = state.priority, + ) + val root = NexusModManager.cacheRoot(context, install.appId) + if (result.errors.isEmpty() && selectedInstall?.installId == install.installId) { + selectedOwnership = app.gamenative.mods.ModOwnershipStore.read(root, install.installId) + selectedPreviousOwnership = app.gamenative.mods.ModOwnershipStore.readPrevious(root, install.installId) + reviewedPlacementPlan = selectedOwnership?.reviewedPlanOrNull() + } + SnackbarManager.show( + if (result.errors.isEmpty()) { + context.getString(R.string.nexus_previous_deployment_restored) + } else { + context.getString(R.string.nexus_previous_deployment_restore_failed, result.errors.size) + }, + ) + if (healthReport != null) { + healthReport = NexusModManager.checkInstallHealthForApp(context, libraryItem.appId, gameRootDir, winePrefix) + } + } finally { + modApplyInProgress = false + loadingMessage = null + } + } + } + fun loadRecipes(install: ModInstall?) { configurationDraftLoaded = false reviewedPlacementPlan = null @@ -3195,14 +3274,15 @@ fun NexusModsDialog( } LaunchedEffect(selectedInstall?.installId) { - selectedOwnership = selectedInstall?.let { install -> + val ownership = selectedInstall?.let { install -> withContext(Dispatchers.IO) { - app.gamenative.mods.ModOwnershipStore.read( - NexusModManager.cacheRoot(context, install.appId), - install.installId, - ) + val root = NexusModManager.cacheRoot(context, install.appId) + app.gamenative.mods.ModOwnershipStore.read(root, install.installId) to + app.gamenative.mods.ModOwnershipStore.readPrevious(root, install.installId) } } + selectedOwnership = ownership?.first + selectedPreviousOwnership = ownership?.second } fun shareDiagnostic(fileName: String, content: String) { @@ -3498,6 +3578,8 @@ fun NexusModsDialog( initialFomodSelections = fomodSelectionDraft, onFomodSelectionsChanged = { fomodSelectionDraft = it }, previousOwnership = selectedOwnership, + canRestorePrevious = selectedPreviousOwnership?.reviewedPlanOrNull() != null, + onRestorePrevious = { restorePreviousDeployment(install.installId) }, placementChoice = placementChoice, canUseLastPlacement = lastPlacementDrafts.isNotEmpty(), onPlacementChoiceChange = { choice -> @@ -3577,6 +3659,8 @@ fun NexusModsDialog( installs.firstOrNull { it.installId == installId }?.let(::selectInstallForPlacement) selectedTab = ManageModsTab.PLACEMENT }, + onAdoptOwnership = ::adoptInstallOwnership, + onRestorePrevious = ::restorePreviousDeployment, onExport = ::exportHealthReport, ) StorageCleanupSection( diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index eca02d9bcf..59d80d2fb3 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -133,6 +133,8 @@ internal fun PlacementSection( initialFomodSelections: Map>, onFomodSelectionsChanged: (Map>) -> Unit, previousOwnership: ModOwnershipManifest?, + canRestorePrevious: Boolean, + onRestorePrevious: () -> Unit, placementChoice: PlacementChoice, canUseLastPlacement: Boolean, onPlacementChoiceChange: (PlacementChoice) -> Unit, @@ -366,6 +368,17 @@ internal fun PlacementSection( ) } + if (canRestorePrevious) { + OutlinedButton(onClick = onRestorePrevious, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.nexus_restore_previous_deployment)) + } + Text( + stringResource(R.string.nexus_restore_previous_deployment_description), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + BoxWithConstraints(Modifier.fillMaxWidth()) { val compactActions = maxWidth < 420.dp if (compactActions) { diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 49c22f8e6c..4fd02e6c31 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2247,4 +2247,12 @@ DLL-, EXE- og indlæserfiler kan ændre, hvordan spillet starter. Bekræft kun, når arkivet er betroet, og forhåndsvisningen matcher installationsvejledningen. Opretter filplaceringsplan… Genanvend manglende filer + Registrer filejerskab + Filejerskab blev registreret uden at ændre spilfilerne. + Filejerskab kunne ikke registreres (%1$d problem(er)) + Gendan forrige udrulning + Erstatter den aktuelle filplaceringsplan med den senest fungerende plan for dette mod. + Gendanner forrige udrulning… + Den forrige udrulning blev gendannet. + Den forrige udrulning kunne ikke gendannes (%1$d problem(er)) diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 92b340b21c..d5f895d3c4 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2317,4 +2317,12 @@ DLL-, EXE- und Loader-Dateien können den Spielstart verändern. Nur bestätigen, wenn das Archiv vertrauenswürdig ist und die Vorschau der Installationsanleitung entspricht. Dateiplatzierungsplan wird erstellt… Fehlende Dateien erneut anwenden + Dateibesitz übernehmen + Der Dateibesitz wurde erfasst, ohne Spieldateien zu ändern. + Dateibesitz konnte nicht übernommen werden (%1$d Problem(e)) + Vorherige Bereitstellung wiederherstellen + Ersetzt den aktuellen Dateiplatzierungsplan durch den letzten funktionierenden Plan dieses Mods. + Vorherige Bereitstellung wird wiederhergestellt… + Die vorherige Bereitstellung wurde wiederhergestellt. + Die vorherige Bereitstellung konnte nicht wiederhergestellt werden (%1$d Problem(e)) diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 347d93e64f..0802ae23e4 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2375,4 +2375,12 @@ Los archivos DLL, EXE y de carga pueden cambiar el inicio del juego. Confirma solo si confías en el archivo y la vista previa coincide con sus instrucciones de instalación. Creando el plan de ubicación de archivos… Reaplicar archivos que faltan + Adoptar propiedad de archivos + La propiedad de los archivos se registró sin modificar los archivos del juego. + No se pudo adoptar la propiedad de los archivos (%1$d problema(s)) + Restaurar despliegue anterior + Sustituye el plan de ubicación actual por el último plan funcional de este mod. + Restaurando el despliegue anterior… + Se restauró el despliegue anterior. + No se pudo restaurar el despliegue anterior (%1$d problema(s)) diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 8fef8a2b47..3e476e1757 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2377,4 +2377,12 @@ Les fichiers DLL, EXE et de chargement peuvent modifier le démarrage du jeu. Confirmez uniquement si l’archive est fiable et si l’aperçu correspond à ses instructions d’installation. Création du plan de placement des fichiers… Réappliquer les fichiers manquants + Adopter la propriété des fichiers + La propriété des fichiers a été enregistrée sans modifier les fichiers du jeu. + Impossible d’adopter la propriété des fichiers (%1$d problème(s)) + Restaurer le déploiement précédent + Remplace le plan de placement actuel par le dernier plan fonctionnel de ce mod. + Restauration du déploiement précédent… + Le déploiement précédent a été restauré. + Impossible de restaurer le déploiement précédent (%1$d problème(s)) diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index c2e08c399f..0cc6ef0031 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2368,4 +2368,12 @@ I file DLL, EXE e loader possono cambiare il modo in cui si avvia il gioco. Conferma solo se l’archivio è attendibile e l’anteprima corrisponde alle istruzioni di installazione. Creazione del piano di posizionamento dei file… Riapplica i file mancanti + Acquisisci proprietà dei file + La proprietà dei file è stata registrata senza modificare i file di gioco. + Impossibile acquisire la proprietà dei file (%1$d problema/i) + Ripristina distribuzione precedente + Sostituisce il piano di posizionamento corrente con l’ultimo piano funzionante di questa mod. + Ripristino della distribuzione precedente… + La distribuzione precedente è stata ripristinata. + Impossibile ripristinare la distribuzione precedente (%1$d problema/i) diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 86a8468a4a..5da555e756 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2331,4 +2331,12 @@ DLL、EXE、ローダーファイルはゲームの起動方法を変更することがあります。信頼できるアーカイブで、プレビューがインストール手順と一致する場合のみ確認してください。 ファイル配置プランを作成中… 不足しているファイルを再適用 + ファイル所有情報を登録 + ゲームファイルを変更せずに所有情報を登録しました。 + ファイル所有情報を登録できませんでした（問題 %1$d 件） + 以前の配置を復元 + 現在のファイル配置プランを、この Mod で最後に動作したプランに置き換えます。 + 以前の配置を復元中… + 以前の配置を復元しました。 + 以前の配置を復元できませんでした（問題 %1$d 件） diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 49f557c4d3..cedcf5c340 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2372,4 +2372,12 @@ DLL, EXE 및 로더 파일은 게임 시작 방식을 바꿀 수 있습니다. 아카이브를 신뢰할 수 있고 미리보기가 설치 안내와 일치할 때만 확인하세요. 파일 배치 계획 생성 중… 누락된 파일 다시 적용 + 파일 소유권 등록 + 게임 파일을 변경하지 않고 파일 소유권을 등록했습니다. + 파일 소유권을 등록하지 못했습니다(문제 %1$d개) + 이전 배포 복원 + 현재 파일 배치 계획을 이 모드에서 마지막으로 작동한 계획으로 바꿉니다. + 이전 배포 복원 중… + 이전 배포를 복원했습니다. + 이전 배포를 복원하지 못했습니다(문제 %1$d개) diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 8dc2ed3fa6..1efae11dfd 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2381,4 +2381,12 @@ Pliki DLL, EXE i moduły ładujące mogą zmienić sposób uruchamiania gry. Potwierdź tylko wtedy, gdy archiwum jest zaufane, a podgląd odpowiada instrukcji instalacji. Tworzenie planu rozmieszczenia plików… Zastosuj ponownie brakujące pliki + Przejmij własność plików + Własność plików została zapisana bez zmiany plików gry. + Nie udało się przejąć własności plików (%1$d problem(y)) + Przywróć poprzednie wdrożenie + Zastępuje bieżący plan rozmieszczenia ostatnim działającym planem tego moda. + Przywracanie poprzedniego wdrożenia… + Poprzednie wdrożenie zostało przywrócone. + Nie udało się przywrócić poprzedniego wdrożenia (%1$d problem(y)) diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index dbe172f2ce..dde9220709 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2247,4 +2247,12 @@ Arquivos DLL, EXE e de carregamento podem mudar como o jogo inicia. Confirme somente se o arquivo for confiável e a prévia corresponder às instruções de instalação. Criando o plano de posicionamento de arquivos… Reaplicar arquivos ausentes + Adotar propriedade dos arquivos + A propriedade dos arquivos foi registrada sem alterar os arquivos do jogo. + Não foi possível adotar a propriedade dos arquivos (%1$d problema(s)) + Restaurar implantação anterior + Substitui o plano de posicionamento atual pelo último plano funcional deste mod. + Restaurando a implantação anterior… + A implantação anterior foi restaurada. + Não foi possível restaurar a implantação anterior (%1$d problema(s)) diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 4e254b5920..96502a4e49 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2381,4 +2381,12 @@ Fișierele DLL, EXE și de încărcare pot schimba modul în care pornește jocul. Confirmă numai dacă arhiva este de încredere, iar previzualizarea corespunde instrucțiunilor de instalare. Se creează planul de amplasare a fișierelor… Reaplică fișierele lipsă + Preia proprietatea fișierelor + Proprietatea fișierelor a fost înregistrată fără modificarea fișierelor jocului. + Proprietatea fișierelor nu a putut fi preluată (%1$d problemă(e)) + Restaurează implementarea anterioară + Înlocuiește planul curent de amplasare cu ultimul plan funcțional al acestui mod. + Se restaurează implementarea anterioară… + Implementarea anterioară a fost restaurată. + Implementarea anterioară nu a putut fi restaurată (%1$d problemă(e)) diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index ea424eac93..291640d0db 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2309,4 +2309,12 @@ https://gamenative.app Файлы DLL, EXE и загрузчики могут изменить запуск игры. Подтверждайте, только если архиву можно доверять, а предпросмотр совпадает с инструкцией по установке. Создание плана размещения файлов… Повторно применить отсутствующие файлы + Принять владение файлами + Владение файлами зарегистрировано без изменения файлов игры. + Не удалось принять владение файлами (проблем: %1$d) + Восстановить предыдущее развёртывание + Заменяет текущий план размещения последним рабочим планом этого мода. + Восстановление предыдущего развёртывания… + Предыдущее развёртывание восстановлено. + Не удалось восстановить предыдущее развёртывание (проблем: %1$d) diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index b1ca95184b..edcb0fa0fb 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2377,4 +2377,12 @@ Файли DLL, EXE та завантажувачі можуть змінити запуск гри. Підтверджуйте, лише якщо архіву можна довіряти, а попередній перегляд відповідає інструкції зі встановлення. Створення плану розміщення файлів… Повторно застосувати відсутні файли + Прийняти володіння файлами + Володіння файлами зареєстровано без зміни файлів гри. + Не вдалося прийняти володіння файлами (проблем: %1$d) + Відновити попереднє розгортання + Замінює поточний план розміщення останнім робочим планом цього мода. + Відновлення попереднього розгортання… + Попереднє розгортання відновлено. + Не вдалося відновити попереднє розгортання (проблем: %1$d) diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 2c3731c5f2..08ff1f8ca2 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2392,4 +2392,12 @@ DLL、EXE 和加载器文件可能改变游戏的启动方式。仅当压缩包可信且预览与安装说明一致时才确认。 正在生成文件放置计划… 重新应用缺失文件 + 接管文件所有权 + 已记录文件所有权，未更改游戏文件。 + 无法接管文件所有权（%1$d 个问题） + 恢复上一次部署 + 将当前文件放置计划替换为此模组上一次正常工作的计划。 + 正在恢复上一次部署… + 已恢复上一次部署。 + 无法恢复上一次部署（%1$d 个问题） diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 34c086375c..f41f2fcb01 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2383,4 +2383,12 @@ DLL、EXE 和載入器檔案可能改變遊戲的啟動方式。僅在壓縮檔可信且預覽與安裝說明一致時確認。 正在建立檔案放置計畫… 重新套用遺失檔案 + 接管檔案所有權 + 已記錄檔案所有權，未變更遊戲檔案。 + 無法接管檔案所有權（%1$d 個問題） + 還原上一次部署 + 將目前檔案放置計畫替換為此模組上一次正常運作的計畫。 + 正在還原上一次部署… + 已還原上一次部署。 + 無法還原上一次部署（%1$d 個問題） diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index bf732fa204..930a659d3f 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2062,6 +2062,14 @@ DLL, EXE, and loader files can change how the game starts. Confirm only when this archive is trusted and the preview matches its installation instructions. Building the file placement plan… Reapply missing files + Adopt verified files + Verified files were adopted without changing them + Could not safely adopt ownership (%1$d issue(s)) + Restore previous deployment + Returns this mod to its previous reviewed file plan. Externally modified files are preserved. + Restoring previous deployment + Previous deployment restored + Could not restore the previous deployment (%1$d issue(s)) Mod order applied%1$s%2$s Mod order applied with %1$d error(s)%2$s%3$s Failed to apply mod order diff --git a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt index 73f9fe6d30..a7219dd13b 100644 --- a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt @@ -48,6 +48,26 @@ class ModInstallPlanContractTest { assertFalse("/data/user" in sanitized) } + @Test + fun healthManifest_includesSupportFactsWithoutLeakingPaths() { + val report = ModHealthReport( + issues = listOf( + ModHealthIssue( + severity = ModHealthSeverity.WARNING, + title = "Managed files changed", + detail = "C:\\Games\\Example\\Data\\changed.esp", + ), + ), + facts = listOf("ownership-producers=automatic@3:2", "cache=C:\\private\\mods"), + ) + + val manifest = report.sanitizedManifest() + + assertTrue("fact: ownership-producers=automatic@3:2" in manifest) + assertFalse("C:\\Games" in manifest) + assertFalse("C:\\private" in manifest) + } + @Test fun oneRiskPolicy_protectsExecutableRootsRegardlessOfPlanOrigin() { val rootDll = file("dxgi.dll", PlannedFileStatus.PLACED, "FOMOD mapping").copy( From 6c465549307bc90e38d23a000bada0d804fe3c44 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 19:17:59 -0500 Subject: [PATCH 25/60] test: cover large deployment planning --- .../mods/ModArchiveIndexPerformanceTest.kt | 50 +++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt index a994becb81..c2c2543456 100644 --- a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt @@ -1,5 +1,11 @@ package app.gamenative.mods +import app.gamenative.data.ModInstall +import app.gamenative.data.ModPlacementMode +import app.gamenative.data.ModPlacementRecipe +import app.gamenative.data.ModTargetRoot +import java.io.File +import kotlin.io.path.createTempDirectory import kotlin.system.measureTimeMillis import org.junit.Assert.assertEquals import org.junit.Assert.assertTrue @@ -43,4 +49,48 @@ class ModArchiveIndexPerformanceTest { assertEquals(50_000, plan.placedCount) assertTrue("Planning took ${elapsed}ms", elapsed < 20_000) } + + @Test + fun twoThousandNestedFiles_materializeWithinGenerousRegressionBudget() { + val root = createTempDirectory("materialization_performance").toFile() + try { + val extracted = File(root, "extracted").apply { mkdirs() } + val game = File(root, "game").apply { mkdirs() } + repeat(2_000) { index -> + File(extracted, "Data/Textures/Set${index / 20}/texture$index.dds").apply { + parentFile?.mkdirs() + createNewFile() + } + } + val install = ModInstall( + installId = "performance", + appId = "STEAM_1", + nexusGameDomain = "game", + nexusModId = 1, + nexusFileId = 2, + modName = "Large tree", + fileName = "large.zip", + archivePath = File(root, "large.zip").absolutePath, + extractedPath = extracted.absolutePath, + ) + val recipe = ModPlacementRecipe( + installId = install.installId, + sourceSubpath = "Data", + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "Data", + mode = ModPlacementMode.OVERWRITE_COPY.name, + ) + lateinit var plan: ModMaterializationPlan + + val elapsed = measureTimeMillis { + plan = ModMaterializer.materializationPlan(install, listOf(recipe), game, "", captureTargetHashes = false) + } + + assertTrue(plan.errors.toString(), plan.isComplete) + assertEquals(2_000, plan.files.size) + assertTrue("Materialization planning took ${elapsed}ms", elapsed < 15_000) + } finally { + root.deleteRecursively() + } + } } From 8824619755e1ad538eba8ebe5accf14d5f3002e1 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 19:19:53 -0500 Subject: [PATCH 26/60] test: cover deployment recovery action --- .../ui/component/dialog/PlacementReviewAndroidTest.kt | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt index 2f4bf5da27..3eebeac438 100644 --- a/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt +++ b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt @@ -66,7 +66,11 @@ class PlacementReviewAndroidTest { riskyAutomaticPlanApproved = false, onRiskyAutomaticPlanApprovalChange = {}, reviewedPlan = null, + initialFomodSelections = emptyMap(), + onFomodSelectionsChanged = {}, previousOwnership = null, + canRestorePrevious = true, + onRestorePrevious = {}, placementChoice = PlacementChoice.AUTOMATIC, canUseLastPlacement = false, onPlacementChoiceChange = {}, @@ -87,5 +91,8 @@ class PlacementReviewAndroidTest { compose.onNodeWithText(compose.activity.getString(R.string.nexus_plan_export)) .assertExists() .assertHasClickAction() + compose.onNodeWithText(compose.activity.getString(R.string.nexus_restore_previous_deployment)) + .assertExists() + .assertHasClickAction() } } From 0e769e7451ad3f86688c48f0575be6ef3c479c1b Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 19:24:26 -0500 Subject: [PATCH 27/60] fix: guard deployment recovery actions --- .../app/gamenative/ui/component/dialog/NexusModsDialog.kt | 7 +++++++ .../ui/component/dialog/NexusModsPlacementSections.kt | 6 +++++- 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index aeddab79c2..e36b1605c0 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -701,6 +701,7 @@ private fun InstallHealthSection( Text(issue.detail, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant) if (issue.installId.isNotBlank()) { TextButton( + enabled = !loading, onClick = { when (issue.recommendedAction) { ModHealthAction.REAPPLY_MISSING, @@ -1956,6 +1957,9 @@ fun NexusModsDialog( }, ) healthReport = NexusModManager.checkInstallHealthForApp(context, libraryItem.appId, gameRootDir, winePrefix) + } catch (error: Throwable) { + if (error is kotlinx.coroutines.CancellationException) throw error + SnackbarManager.show(context.getString(R.string.nexus_ownership_adoption_failed, 1)) } finally { healthLoading = false } @@ -1996,6 +2000,9 @@ fun NexusModsDialog( if (healthReport != null) { healthReport = NexusModManager.checkInstallHealthForApp(context, libraryItem.appId, gameRootDir, winePrefix) } + } catch (error: Throwable) { + if (error is kotlinx.coroutines.CancellationException) throw error + SnackbarManager.show(context.getString(R.string.nexus_previous_deployment_restore_failed, 1)) } finally { modApplyInProgress = false loadingMessage = null diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 59d80d2fb3..67667717e9 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -369,7 +369,11 @@ internal fun PlacementSection( } if (canRestorePrevious) { - OutlinedButton(onClick = onRestorePrevious, modifier = Modifier.fillMaxWidth()) { + OutlinedButton( + onClick = onRestorePrevious, + enabled = applyStatusMessage == null, + modifier = Modifier.fillMaxWidth(), + ) { Text(stringResource(R.string.nexus_restore_previous_deployment)) } Text( From 4c8cca9db79fd98763fc25dee118d4f91d164707 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:07:24 -0500 Subject: [PATCH 28/60] feat: add placement workspace read models --- .../dialog/PlacementWorkspaceModels.kt | 242 ++++++++++++++++++ .../dialog/PlacementWorkspaceModelsTest.kt | 186 ++++++++++++++ 2 files changed, 428 insertions(+) create mode 100644 app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt create mode 100644 app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt new file mode 100644 index 0000000000..e5da8f62ca --- /dev/null +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -0,0 +1,242 @@ +package app.gamenative.ui.component.dialog + +import app.gamenative.data.ModPlacementMode +import app.gamenative.mods.ModInstallPlan +import app.gamenative.mods.ModOwnershipManifest +import app.gamenative.mods.ModOwnershipState +import app.gamenative.mods.ModPlacementSources +import app.gamenative.mods.ModPlanChangeType +import app.gamenative.mods.ModReconfigurationDiff +import app.gamenative.mods.PlannedFileStatus +import app.gamenative.mods.PlannedModFile +import app.gamenative.mods.ResolvedModTargetRoot +import app.gamenative.mods.WindowsPathIdentity +import java.io.File +import java.util.Locale + +internal data class PlacementLayoutModel( + val visible: Boolean, + val multipleFolders: Boolean, + val selectedNames: List, + val resultExample: String, + val duplicateFolderWarning: Boolean, +) + +internal fun placementLayoutModel( + draft: RecipeDraft, + entries: List, +): PlacementLayoutModel { + val sources = ModPlacementSources.decode(draft.sourceSubpath).filter(String::isNotBlank) + val folders = sources.filter { source -> + entries.any { entry -> + val path = normalizeArchivePath(entry.path) + path.equals(source, ignoreCase = true) && entry.directory || + path.startsWith("${normalizeArchivePath(source)}/", ignoreCase = true) + } + } + val selectedNames = folders.map { it.substringAfterLast('/') }.distinct() + val destination = draft.targetRelativePath.trim('/').ifBlank { "" } + val result = when { + selectedNames.isEmpty() || !draft.includeSourceDirectory -> "$destination/" + selectedNames.size == 1 -> "$destination/${selectedNames.single()}/" + else -> "$destination/{${selectedNames.take(3).joinToString(", ")}${if (selectedNames.size > 3) ", ..." else ""}}/" + } + return PlacementLayoutModel( + visible = folders.isNotEmpty(), + multipleFolders = folders.size > 1, + selectedNames = selectedNames, + resultExample = result, + duplicateFolderWarning = draft.includeSourceDirectory && selectedNames.any { selected -> + destination.substringAfterLast('/').equals(selected, ignoreCase = true) + }, + ) +} + +internal enum class DestinationEntryImpact { + WILL_ADD, + WILL_REPLACE, + WILL_BACK_UP, + PLAN_CONFLICT, + MANAGED_BY_THIS_MOD, + MANAGED_BY_ANOTHER_MOD, + MODIFIED, + GAME_OR_UNMANAGED, + WILL_RECEIVE_FILES, +} + +internal data class DestinationBrowserEntry( + val file: File, + val directory: Boolean, + val sizeBytes: Long, + val modifiedAt: Long, + val impacts: Set, + val ownerInstallIds: Set, + val virtual: Boolean = false, +) + +internal fun destinationBrowserEntries( + directory: File, + root: ResolvedModTargetRoot, + plan: ModInstallPlan?, + ownership: List, + selectedInstallId: String, + showHidden: Boolean, + query: String, + virtualFolderName: String? = null, +): List { + val planFiles = plan?.files.orEmpty() + val activeOwnership = ownership.filter { it.state == ModOwnershipState.ACTIVE } + val normalizedQuery = query.trim().lowercase(Locale.ROOT) + val children = directory.listFiles().orEmpty() + .asSequence() + .filter { showHidden || !it.name.startsWith('.') } + .filter { normalizedQuery.isBlank() || normalizedQuery in it.name.lowercase(Locale.ROOT) } + .map { child -> + destinationBrowserEntry(child, root, planFiles, activeOwnership, selectedInstallId) + } + .toMutableList() + virtualFolderName?.takeIf { name -> + name.isNotBlank() && (normalizedQuery.isBlank() || normalizedQuery in name.lowercase(Locale.ROOT)) + }?.let { name -> + children += DestinationBrowserEntry( + file = File(directory, name), + directory = true, + sizeBytes = 0L, + modifiedAt = 0L, + impacts = setOf(DestinationEntryImpact.WILL_RECEIVE_FILES), + ownerInstallIds = emptySet(), + virtual = true, + ) + } + return children.sortedWith(compareByDescending { it.directory }.thenBy { it.file.name.lowercase(Locale.ROOT) }) +} + +private fun destinationBrowserEntry( + file: File, + root: ResolvedModTargetRoot, + planFiles: List, + ownership: List, + selectedInstallId: String, +): DestinationBrowserEntry { + val relative = runCatching { + file.canonicalFile.relativeTo(root.dir.canonicalFile).path.replace(File.separatorChar, '/') + }.getOrDefault("") + val logicalKey = WindowsPathIdentity.targetKey(root.type.name, relative) + val absoluteKey = WindowsPathIdentity.absoluteKey(file) + val exactPlan = planFiles.filter { it.normalizedTargetKey == logicalKey } + val directoryPrefix = logicalKey?.let { "$it/" } + val receivesFiles = file.isDirectory && directoryPrefix != null && planFiles.any { + it.status == PlannedFileStatus.PLACED && it.normalizedTargetKey?.startsWith(directoryPrefix) == true + } + val ownedFiles = ownership.flatMap { manifest -> + manifest.files.filter { it.active && it.normalizedTargetKey == absoluteKey }.map { manifest.installId to it } + } + val impacts = linkedSetOf() + if (receivesFiles) impacts += DestinationEntryImpact.WILL_RECEIVE_FILES + if (exactPlan.any { it.status == PlannedFileStatus.CONFLICTED }) impacts += DestinationEntryImpact.PLAN_CONFLICT + exactPlan.filter { it.status == PlannedFileStatus.PLACED }.forEach { planned -> + if (!file.exists()) { + impacts += DestinationEntryImpact.WILL_ADD + } else { + impacts += DestinationEntryImpact.WILL_REPLACE + if (planned.mode == ModPlacementMode.OVERWRITE_COPY.name) impacts += DestinationEntryImpact.WILL_BACK_UP + } + } + if (ownedFiles.any { it.first == selectedInstallId }) impacts += DestinationEntryImpact.MANAGED_BY_THIS_MOD + if (ownedFiles.any { it.first != selectedInstallId }) impacts += DestinationEntryImpact.MANAGED_BY_ANOTHER_MOD + if (ownedFiles.any { (_, owned) -> file.isFile && (file.length() != owned.installedSize || file.lastModified() != owned.installedMtime) }) { + impacts += DestinationEntryImpact.MODIFIED + } + if (file.isFile && ownedFiles.isEmpty() && exactPlan.isEmpty()) impacts += DestinationEntryImpact.GAME_OR_UNMANAGED + return DestinationBrowserEntry( + file = file, + directory = file.isDirectory, + sizeBytes = if (file.isFile) file.length() else 0L, + modifiedAt = file.lastModified(), + impacts = impacts, + ownerInstallIds = ownedFiles.mapTo(linkedSetOf()) { it.first }, + ) +} + +internal fun validVirtualDestinationFolderName(value: String): Boolean { + val name = value.trim() + return name.isNotEmpty() && + '/' !in name && '\\' !in name && + WindowsPathIdentity.normalizedRelativeKey(name) != null +} + +internal enum class PlacementReviewCategory { + ADDED, + REPLACED, + MOVED, + REMOVED, + IGNORED, + BLOCKED, + UNCHANGED, +} + +internal data class PlacementReviewRow( + val category: PlacementReviewCategory, + val source: String, + val previousTarget: String = "", + val target: String = "", + val reason: String = "", + val sizeBytes: Long = 0L, +) { + fun matches(query: String): Boolean { + val needle = query.trim().lowercase(Locale.ROOT) + return needle.isBlank() || listOf(source, previousTarget, target, reason).any { needle in it.lowercase(Locale.ROOT) } + } +} + +internal fun placementReviewRows( + plan: ModInstallPlan, + diff: ModReconfigurationDiff?, + roots: List, +): List { + val changesBySource = diff?.changes.orEmpty().groupBy { it.sourceRelativePath } + val rows = plan.files.map { file -> + val change = changesBySource[file.sourceRelativePath].orEmpty().firstOrNull { it.type != ModPlanChangeType.UNCHANGED } + val category = when (file.status) { + PlannedFileStatus.INTENTIONALLY_IGNORED -> PlacementReviewCategory.IGNORED + PlannedFileStatus.UNSUPPORTED, PlannedFileStatus.MISSING, PlannedFileStatus.CONFLICTED -> PlacementReviewCategory.BLOCKED + PlannedFileStatus.PLACED -> when (change?.type) { + ModPlanChangeType.MOVED -> PlacementReviewCategory.MOVED + ModPlanChangeType.CHANGED -> PlacementReviewCategory.REPLACED + ModPlanChangeType.STALE -> PlacementReviewCategory.REMOVED + ModPlanChangeType.ADDED -> if (plannedTargetExists(file, roots)) PlacementReviewCategory.REPLACED else PlacementReviewCategory.ADDED + ModPlanChangeType.UNCHANGED, null -> if (plannedTargetExists(file, roots) && diff == null) { + PlacementReviewCategory.REPLACED + } else { + PlacementReviewCategory.UNCHANGED + } + } + } + PlacementReviewRow( + category = category, + source = file.sourceRelativePath, + previousTarget = change?.previousTarget.orEmpty(), + target = file.targetDisplay(), + reason = file.reason, + sizeBytes = file.sizeBytes, + ) + }.toMutableList() + diff?.changes.orEmpty().filter { it.type == ModPlanChangeType.STALE }.forEach { change -> + rows += PlacementReviewRow( + category = PlacementReviewCategory.REMOVED, + source = change.sourceRelativePath, + previousTarget = change.previousTarget, + reason = "No longer produced by this placement", + ) + } + return rows.sortedWith(compareBy { it.category.ordinal }.thenBy { it.source.lowercase(Locale.ROOT) }) +} + +private fun plannedTargetExists(file: PlannedModFile, roots: List): Boolean { + val root = roots.firstOrNull { it.type.name == file.targetRoot } ?: return false + val relative = file.targetRelativePath ?: return false + return app.gamenative.mods.ModTargetResolver.resolveWithin(root.dir, relative)?.exists() == true +} + +private fun PlannedModFile.targetDisplay(): String = + listOfNotNull(targetRoot, targetRelativePath).filter(String::isNotBlank).joinToString("/") diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt new file mode 100644 index 0000000000..1f10ccc226 --- /dev/null +++ b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt @@ -0,0 +1,186 @@ +package app.gamenative.ui.component.dialog + +import app.gamenative.data.ModPlacementMode +import app.gamenative.data.ModTargetRoot +import app.gamenative.mods.ModArchiveEntry +import app.gamenative.mods.ModInstallPlan +import app.gamenative.mods.ModOwnedFile +import app.gamenative.mods.ModOwnedFileDisposition +import app.gamenative.mods.ModOwnershipManifest +import app.gamenative.mods.ModPlanChange +import app.gamenative.mods.ModPlanChangeType +import app.gamenative.mods.ModReconfigurationDiff +import app.gamenative.mods.PlacementOrigin +import app.gamenative.mods.PlannedFileStatus +import app.gamenative.mods.PlannedModFile +import app.gamenative.mods.ResolvedModTargetRoot +import app.gamenative.mods.WindowsPathIdentity +import java.io.File +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder + +class PlacementWorkspaceModelsTest { + @get:Rule + val temporaryFolder = TemporaryFolder() + + @Test + fun layoutChoice_isHiddenWhenItCannotChangeTheResult() { + val entries = listOf(ModArchiveEntry("readme.txt", directory = false, sizeBytes = 1)) + + assertFalse(placementLayoutModel(RecipeDraft(), entries).visible) + assertFalse(placementLayoutModel(RecipeDraft(sourceSubpath = "readme.txt"), entries).visible) + } + + @Test + fun layoutChoice_explainsFolderAndContentsResults() { + val entries = listOf(ModArchiveEntry("Data/file.txt", directory = false, sizeBytes = 1)) + val contents = placementLayoutModel( + RecipeDraft(sourceSubpath = "Data", targetRelativePath = "Data"), + entries, + ) + val folder = placementLayoutModel( + RecipeDraft(sourceSubpath = "Data", targetRelativePath = "Data", includeSourceDirectory = true), + entries, + ) + + assertEquals("Data/", contents.resultExample) + assertEquals("Data/Data/", folder.resultExample) + assertTrue(folder.duplicateFolderWarning) + } + + @Test + fun virtualFolderName_rejectsTraversalReservedAndSeparators() { + assertTrue(validVirtualDestinationFolderName("New Mods")) + assertFalse(validVirtualDestinationFolderName("../escape")) + assertFalse(validVirtualDestinationFolderName("Data/Plugins")) + assertFalse(validVirtualDestinationFolderName("CON")) + } + + @Test + fun destinationBrowser_showsFilesAndClassifiesPlanAndOwnership() { + val rootDir = temporaryFolder.newFolder("game") + val dataDir = File(rootDir, "Data").apply { mkdirs() } + val replace = File(dataDir, "replace.txt").apply { writeText("old") } + val managed = File(dataDir, "managed.txt").apply { writeText("managed") } + File(dataDir, ".hidden.txt").writeText("hidden") + val root = ResolvedModTargetRoot(ModTargetRoot.GAME_DIR, "Game", rootDir) + val plan = ModInstallPlan( + files = listOf( + planned("Data/replace.txt", ModPlacementMode.OVERWRITE_COPY), + planned("Data/new.txt", ModPlacementMode.COPY), + ), + ) + val ownership = ModOwnershipManifest( + installId = "selected", + appId = "app", + planDigest = "digest", + files = listOf( + ModOwnedFile( + sourceRelativePath = "managed.txt", + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "Data/managed.txt", + targetPath = managed.absolutePath, + normalizedTargetKey = WindowsPathIdentity.absoluteKey(managed), + mode = ModPlacementMode.COPY.name, + installedHash = "hash", + installedSize = managed.length(), + installedMtime = managed.lastModified(), + disposition = ModOwnedFileDisposition.CREATED, + ), + ), + ) + + val entries = destinationBrowserEntries(dataDir, root, plan, listOf(ownership), "selected", false, "") + val replaceEntry = entries.single { it.file == replace } + val managedEntry = entries.single { it.file == managed } + + assertTrue(DestinationEntryImpact.WILL_REPLACE in replaceEntry.impacts) + assertTrue(DestinationEntryImpact.WILL_BACK_UP in replaceEntry.impacts) + assertTrue(DestinationEntryImpact.MANAGED_BY_THIS_MOD in managedEntry.impacts) + assertTrue(entries.none { it.file.name.startsWith('.') }) + } + + @Test + fun destinationBrowser_searchesAndIncludesVirtualFolder() { + val rootDir = temporaryFolder.newFolder("search-game") + File(rootDir, "Data").mkdirs() + File(rootDir, "BepInEx").mkdirs() + val root = ResolvedModTargetRoot(ModTargetRoot.GAME_DIR, "Game", rootDir) + + val entries = destinationBrowserEntries( + rootDir, + root, + null, + emptyList(), + "selected", + false, + "mod", + virtualFolderName = "Mods", + ) + + assertEquals(listOf("Mods"), entries.map { it.file.name }) + assertTrue(entries.single().virtual) + } + + @Test + fun reviewRows_groupPlanAndReconfigurationChanges() { + val rootDir = temporaryFolder.newFolder("review-game") + File(rootDir, "Data/existing.txt").apply { parentFile?.mkdirs(); writeText("old") } + val root = ResolvedModTargetRoot(ModTargetRoot.GAME_DIR, "Game", rootDir) + val plan = ModInstallPlan( + files = listOf( + planned("Data/new.txt"), + planned("Data/existing.txt"), + planned("Data/moved.txt"), + PlannedModFile( + sourceRelativePath = "docs/readme.txt", + status = PlannedFileStatus.INTENTIONALLY_IGNORED, + origin = PlacementOrigin.GAME_RULE, + reason = "Documentation", + ), + PlannedModFile( + sourceRelativePath = "unknown/file.bin", + status = PlannedFileStatus.UNSUPPORTED, + origin = PlacementOrigin.GAME_RULE, + reason = "No safe destination", + ), + ), + ) + val diff = ModReconfigurationDiff( + listOf( + ModPlanChange(ModPlanChangeType.ADDED, "Data/new.txt", newTarget = "GAME_DIR:data/new.txt"), + ModPlanChange(ModPlanChangeType.ADDED, "Data/existing.txt", newTarget = "GAME_DIR:data/existing.txt"), + ModPlanChange(ModPlanChangeType.MOVED, "Data/moved.txt", "GAME_DIR:old.txt", "GAME_DIR:data/moved.txt"), + ModPlanChange(ModPlanChangeType.STALE, "Data/removed.txt", "GAME_DIR:data/removed.txt"), + ), + ) + + val categories = placementReviewRows(plan, diff, listOf(root)).groupingBy { it.category }.eachCount() + + assertEquals(1, categories[PlacementReviewCategory.ADDED]) + assertEquals(1, categories[PlacementReviewCategory.REPLACED]) + assertEquals(1, categories[PlacementReviewCategory.MOVED]) + assertEquals(1, categories[PlacementReviewCategory.REMOVED]) + assertEquals(1, categories[PlacementReviewCategory.IGNORED]) + assertEquals(1, categories[PlacementReviewCategory.BLOCKED]) + } + + private fun planned( + relative: String, + mode: ModPlacementMode = ModPlacementMode.COPY, + ) = PlannedModFile( + sourceRelativePath = relative, + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = relative, + normalizedTargetKey = WindowsPathIdentity.targetKey(ModTargetRoot.GAME_DIR.name, relative), + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.GAME_RULE, + mode = mode.name, + sizeBytes = 1, + reason = "Test", + ) +} From 3a89e768252713ed87befe467b8862236d341c39 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:11:15 -0500 Subject: [PATCH 29/60] feat: upgrade placement destination browser --- .../ui/component/dialog/NexusModsDialog.kt | 16 ++ .../dialog/NexusModsPlacementSections.kt | 249 ++++++++++++++++-- app/src/main/res/values/strings.xml | 18 ++ 3 files changed, 259 insertions(+), 24 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index e36b1605c0..936f4940a1 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -114,6 +114,8 @@ import app.gamenative.mods.ModHealthSeverity import app.gamenative.mods.ModImportProgress import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.ModMaterializer +import app.gamenative.mods.ModOwnershipManifest +import app.gamenative.mods.ModOwnershipStore import app.gamenative.mods.PlannedFileStatus import app.gamenative.mods.PlacementRiskPolicy import app.gamenative.mods.ModPathDetector @@ -848,6 +850,7 @@ fun NexusModsDialog( var automaticPlacementLoading by remember { mutableStateOf(false) } var selectedOwnership by remember { mutableStateOf(null) } var selectedPreviousOwnership by remember { mutableStateOf(null) } + var placementOwnershipManifests by remember(libraryItem.appId) { mutableStateOf>(emptyList()) } var lastPlacementDrafts by remember(libraryItem.appId) { mutableStateOf>(emptyList()) } var detectedDefaultDraft by remember(libraryItem.appId) { mutableStateOf(null) } val defaultDraft = detectedDefaultDraft ?: fallbackDefaultDraft @@ -3292,6 +3295,17 @@ fun NexusModsDialog( selectedPreviousOwnership = ownership?.second } + LaunchedEffect( + libraryItem.appId, + installs.map { it.installId to it.status }, + selectedOwnership?.planDigest, + ) { + placementOwnershipManifests = withContext(Dispatchers.IO) { + val root = NexusModManager.cacheRoot(context, libraryItem.appId) + installs.mapNotNull { install -> ModOwnershipStore.read(root, install.installId) } + } + } + fun shareDiagnostic(fileName: String, content: String) { scope.launch { val file = withContext(Dispatchers.IO) { @@ -3585,6 +3599,8 @@ fun NexusModsDialog( initialFomodSelections = fomodSelectionDraft, onFomodSelectionsChanged = { fomodSelectionDraft = it }, previousOwnership = selectedOwnership, + ownershipManifests = placementOwnershipManifests, + installNamesById = installs.associate { it.installId to it.modName }, canRestorePrevious = selectedPreviousOwnership?.reviewedPlanOrNull() != null, onRestorePrevious = { restorePreviousDeployment(install.installId) }, placementChoice = placementChoice, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 67667717e9..e10a6fb552 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -2,8 +2,10 @@ package app.gamenative.ui.component.dialog import androidx.compose.foundation.background import androidx.compose.foundation.clickable +import androidx.compose.foundation.horizontalScroll import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.BoxWithConstraints @@ -29,6 +31,8 @@ import androidx.compose.material.icons.filled.FolderOff import androidx.compose.material.icons.filled.FolderOpen import androidx.compose.material.icons.filled.Gamepad import androidx.compose.material.icons.filled.Link +import androidx.compose.material.icons.filled.CreateNewFolder +import androidx.compose.material.icons.filled.Search import androidx.compose.material.icons.filled.Save import androidx.compose.material.icons.filled.Settings import androidx.compose.material.icons.filled.SnippetFolder @@ -88,6 +92,8 @@ import app.gamenative.utils.StorageUtils import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext import java.io.File +import java.text.DateFormat +import java.util.Date @Composable internal fun StatusChip(status: String) { val (label, color, contentColor) = when (status) { @@ -133,6 +139,8 @@ internal fun PlacementSection( initialFomodSelections: Map>, onFomodSelectionsChanged: (Map>) -> Unit, previousOwnership: ModOwnershipManifest?, + ownershipManifests: List, + installNamesById: Map, canRestorePrevious: Boolean, onRestorePrevious: () -> Unit, placementChoice: PlacementChoice, @@ -345,6 +353,10 @@ internal fun PlacementSection( draft = draft, entries = entries, roots = roots, + plan = visiblePlan, + ownershipManifests = ownershipManifests, + selectedInstallId = install.installId, + installNamesById = installNamesById, canRemove = drafts.size > 1, onUpdate = { onUpdateDraft(index, it) }, onRemove = { onRemoveDraft(index) }, @@ -724,6 +736,10 @@ private fun PlacementDraftEditor( draft: RecipeDraft, entries: List, roots: List, + plan: ModInstallPlan?, + ownershipManifests: List, + selectedInstallId: String, + installNamesById: Map, canRemove: Boolean, onUpdate: (RecipeDraft) -> Unit, onRemove: () -> Unit, @@ -856,6 +872,10 @@ private fun PlacementDraftEditor( ContainerDestinationPickerDialog( roots = roots, currentDraft = draft, + plan = plan, + ownershipManifests = ownershipManifests, + selectedInstallId = selectedInstallId, + installNamesById = installNamesById, onSelect = { onUpdate(it) showDestinationPicker = false @@ -1112,15 +1132,19 @@ private fun ArchiveBrowserDialog( private fun ContainerDestinationPickerDialog( roots: List, currentDraft: RecipeDraft, + plan: ModInstallPlan?, + ownershipManifests: List, + selectedInstallId: String, + installNamesById: Map, onSelect: (RecipeDraft) -> Unit, onDismiss: () -> Unit, ) { var currentRootName by remember(currentDraft.targetRoot, roots) { mutableStateOf(roots.firstOrNull { it.type.name == currentDraft.targetRoot }?.type?.name.orEmpty()) } - var currentDir by remember(currentDraft.targetRoot, currentDraft.targetRelativePath, roots) { + var selectedDestination by remember(currentDraft.targetRoot, currentDraft.targetRelativePath, roots) { val root = roots.firstOrNull { it.type.name == currentDraft.targetRoot } - val current = root?.let { targetRoot -> + mutableStateOf(root?.let { targetRoot -> val candidate = if (currentDraft.targetRelativePath.isBlank()) { targetRoot.dir } else { @@ -1128,38 +1152,59 @@ private fun ContainerDestinationPickerDialog( } runCatching { candidate.canonicalFile } .getOrNull() - ?.takeIf { it.isDirectory && it.isInsideOrEqual(targetRoot.dir) } + ?.takeIf { it.isInsideOrEqual(targetRoot.dir) } + }) + } + var currentDir by remember(currentDraft.targetRoot, currentDraft.targetRelativePath, roots) { + val root = roots.firstOrNull { it.type.name == currentDraft.targetRoot } + val desired = root?.let { targetRoot -> + if (currentDraft.targetRelativePath.isBlank()) targetRoot.dir else File(targetRoot.dir, currentDraft.targetRelativePath) } - mutableStateOf(current) + var existing = desired + while (existing != null && !existing.isDirectory) existing = existing.parentFile + mutableStateOf(existing?.takeIf { root != null && it.isInsideOrEqual(root.dir) }) } - var subDirs by remember { mutableStateOf>(emptyList()) } + var browserEntries by remember { mutableStateOf>(emptyList()) } var loading by remember { mutableStateOf(false) } + var query by remember { mutableStateOf("") } + var showHidden by remember { mutableStateOf(false) } + var showNewFolderDialog by remember { mutableStateOf(false) } + var newFolderName by remember { mutableStateOf("") } val currentRoot = roots.firstOrNull { it.type.name == currentRootName } - LaunchedEffect(currentDir, currentRoot) { + LaunchedEffect(currentDir, currentRoot, plan, ownershipManifests, query, showHidden, selectedDestination) { val dir = currentDir if (dir != null && dir.isDirectory) { loading = true try { val root = currentRoot - subDirs = withContext(Dispatchers.IO) { - dir.listFiles() - ?.filter { - it.isDirectory && - !it.name.startsWith(".") && - (root == null || it.isInsideOrEqual(root.dir)) - } - ?.sortedBy { it.name.lowercase() } - ?: emptyList() + browserEntries = withContext(Dispatchers.IO) { + if (root == null) { + emptyList() + } else { + val virtualName = selectedDestination + ?.takeIf { !it.exists() && it.parentFile?.canonicalFile == dir.canonicalFile } + ?.name + destinationBrowserEntries( + directory = dir, + root = root, + plan = plan, + ownership = ownershipManifests, + selectedInstallId = selectedInstallId, + showHidden = showHidden, + query = query, + virtualFolderName = virtualName, + ) + } } } catch (e: Exception) { if (e is kotlinx.coroutines.CancellationException) throw e - subDirs = emptyList() + browserEntries = emptyList() } finally { loading = false } } else { - subDirs = emptyList() + browserEntries = emptyList() } } @@ -1193,6 +1238,25 @@ private fun ContainerDestinationPickerDialog( maxLines = 1, overflow = TextOverflow.Ellipsis, ) + if (roots.isNotEmpty()) { + Row( + modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), + horizontalArrangement = Arrangement.spacedBy(6.dp), + ) { + roots.forEach { root -> + OutlinedButton( + onClick = { + currentRootName = root.type.name + currentDir = root.dir + selectedDestination = root.dir + query = "" + }, + ) { + Text(root.label, maxLines = 1) + } + } + } + } } if (currentDir != null) { @@ -1207,6 +1271,8 @@ private fun ContainerDestinationPickerDialog( } else { null } + selectedDestination = currentDir + query = "" } .padding(horizontal = 20.dp, vertical = 10.dp), verticalAlignment = Alignment.CenterVertically, @@ -1217,6 +1283,32 @@ private fun ContainerDestinationPickerDialog( } } HorizontalDivider() + Column( + modifier = Modifier.padding(horizontal = 20.dp, vertical = 10.dp), + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + NoExtractOutlinedTextField( + value = query, + onValueChange = { query = it }, + modifier = Modifier.fillMaxWidth(), + label = { Text(stringResource(R.string.nexus_search_destination)) }, + leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) }, + singleLine = true, + ) + Row(verticalAlignment = Alignment.CenterVertically) { + Checkbox(checked = showHidden, onCheckedChange = { showHidden = it }) + Text(stringResource(R.string.nexus_show_hidden_files), modifier = Modifier.weight(1f)) + TextButton(onClick = { + newFolderName = "" + showNewFolderDialog = true + }) { + Icon(Icons.Default.CreateNewFolder, contentDescription = null, modifier = Modifier.size(18.dp)) + Spacer(Modifier.width(6.dp)) + Text(stringResource(R.string.nexus_new_destination_folder)) + } + } + } + HorizontalDivider() } if (currentDir == null) { @@ -1228,6 +1320,8 @@ private fun ContainerDestinationPickerDialog( .clickable { currentRootName = root.type.name currentDir = root.dir + selectedDestination = root.dir + query = "" } .padding(horizontal = 20.dp, vertical = 12.dp), verticalAlignment = Alignment.CenterVertically, @@ -1263,7 +1357,7 @@ private fun ContainerDestinationPickerDialog( Box(modifier = Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { CircularProgressIndicator(modifier = Modifier.size(28.dp), strokeWidth = 3.dp) } - } else if (subDirs.isEmpty()) { + } else if (browserEntries.isEmpty()) { Box(modifier = Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(8.dp)) { Icon( @@ -1272,22 +1366,41 @@ private fun ContainerDestinationPickerDialog( modifier = Modifier.size(32.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant, ) - Text(stringResource(R.string.nexus_no_subdirectories), color = MaterialTheme.colorScheme.onSurfaceVariant) + Text(stringResource(R.string.nexus_destination_folder_empty), color = MaterialTheme.colorScheme.onSurfaceVariant) } } } else { LazyColumn(modifier = Modifier.weight(1f).fillMaxWidth()) { - items(subDirs, key = { it.absolutePath }) { dir -> + items(browserEntries, key = { "${it.file.absolutePath}:${it.virtual}" }) { entry -> Row( modifier = Modifier .fillMaxWidth() - .clickable { currentDir = dir } + .clickable(enabled = entry.directory && !entry.virtual) { + currentDir = entry.file + selectedDestination = entry.file + query = "" + } .padding(horizontal = 20.dp, vertical = 12.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp), ) { - Icon(Icons.Default.Folder, contentDescription = null, tint = MaterialTheme.colorScheme.primary) - Text(dir.name, modifier = Modifier.weight(1f), maxLines = 1, overflow = TextOverflow.Ellipsis) + Icon( + if (entry.directory) Icons.Default.Folder else Icons.Default.Description, + contentDescription = null, + tint = if (entry.directory) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant, + ) + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) { + Text(entry.file.name, maxLines = 1, overflow = TextOverflow.Ellipsis) + DestinationEntryMetadata(entry, installNamesById, selectedInstallId) + } + if (entry.directory && !entry.virtual) { + Icon( + Icons.AutoMirrored.Filled.ArrowForward, + contentDescription = null, + modifier = Modifier.size(18.dp), + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } } HorizontalDivider( modifier = Modifier.padding(horizontal = 20.dp), @@ -1310,7 +1423,7 @@ private fun ContainerDestinationPickerDialog( Text(stringResource(R.string.cancel)) } val selectedRoot = currentRoot - val selectedDir = currentDir + val selectedDir = selectedDestination ?: currentDir if (selectedRoot != null && selectedDir != null) { Button( onClick = { @@ -1336,6 +1449,94 @@ private fun ContainerDestinationPickerDialog( } } } + + if (showNewFolderDialog) { + val validName = validVirtualDestinationFolderName(newFolderName) + AlertDialog( + onDismissRequest = { showNewFolderDialog = false }, + title = { Text(stringResource(R.string.nexus_new_destination_folder)) }, + text = { + Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { + Text(stringResource(R.string.nexus_new_destination_folder_description)) + NoExtractOutlinedTextField( + value = newFolderName, + onValueChange = { newFolderName = it }, + modifier = Modifier.fillMaxWidth(), + label = { Text(stringResource(R.string.nexus_folder_name)) }, + isError = newFolderName.isNotBlank() && !validName, + singleLine = true, + ) + Text( + stringResource(R.string.nexus_folder_created_when_applied), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + }, + confirmButton = { + Button( + onClick = { + selectedDestination = File(currentDir, newFolderName.trim()) + showNewFolderDialog = false + }, + enabled = validName, + ) { Text(stringResource(R.string.nexus_use_folder)) } + }, + dismissButton = { + TextButton(onClick = { showNewFolderDialog = false }) { Text(stringResource(R.string.cancel)) } + }, + ) + } +} + +@Composable +private fun DestinationEntryMetadata( + entry: DestinationBrowserEntry, + installNamesById: Map, + selectedInstallId: String, +) { + val details = listOfNotNull( + StorageUtils.formatBinarySize(entry.sizeBytes).takeIf { !entry.directory && entry.sizeBytes > 0L }, + DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT) + .format(Date(entry.modifiedAt)).takeIf { entry.modifiedAt > 0L }, + stringResource(R.string.nexus_will_be_created).takeIf { entry.virtual }, + ) + if (details.isNotEmpty()) { + Text( + details.joinToString(" • "), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 1, + overflow = TextOverflow.Ellipsis, + ) + } + entry.impacts.forEach { impact -> + val label = when (impact) { + DestinationEntryImpact.WILL_ADD -> stringResource(R.string.nexus_impact_will_add) + DestinationEntryImpact.WILL_REPLACE -> stringResource(R.string.nexus_impact_will_replace) + DestinationEntryImpact.WILL_BACK_UP -> stringResource(R.string.nexus_impact_will_backup) + DestinationEntryImpact.PLAN_CONFLICT -> stringResource(R.string.nexus_impact_plan_conflict) + DestinationEntryImpact.MANAGED_BY_THIS_MOD -> stringResource(R.string.nexus_impact_managed_by_this_mod) + DestinationEntryImpact.MANAGED_BY_ANOTHER_MOD -> { + val names = entry.ownerInstallIds.filterNot { it == selectedInstallId } + .map { installNamesById[it] ?: it } + .take(2) + .joinToString(", ") + stringResource(R.string.nexus_impact_managed_by_mod, names) + } + DestinationEntryImpact.MODIFIED -> stringResource(R.string.nexus_impact_modified) + DestinationEntryImpact.GAME_OR_UNMANAGED -> stringResource(R.string.nexus_impact_game_or_unmanaged) + DestinationEntryImpact.WILL_RECEIVE_FILES -> stringResource(R.string.nexus_impact_will_receive_files) + } + Surface(shape = RoundedCornerShape(999.dp), color = MaterialTheme.colorScheme.secondaryContainer) { + Text( + label, + modifier = Modifier.padding(horizontal = 7.dp, vertical = 2.dp), + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSecondaryContainer, + ) + } + } } @Composable diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 930a659d3f..2f26457e9d 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1958,6 +1958,24 @@ Remove placement row Folder/file from the mod Destination Folder + Search this folder + Show hidden files and folders + New folder + Choose a folder name inside the current destination. + Folder name + Nothing is changed yet. The folder will be created only when the reviewed plan is applied. + Use folder + Will be created + No matching files or folders + Will add + Will replace + Will back up + Plan conflict + Managed by this mod + Managed by %1$s + Changed since deployment + Game or unmanaged file + Will receive files Install method Create a folder for the selection On: The selected folder is installed into the destination. Off: Only its contents are placed there. From 79413add03ef8b8ac3e2c37ddedd8f505bc391f4 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:14:59 -0500 Subject: [PATCH 30/60] feat: simplify placement choices --- .../dialog/NexusModsPlacementSections.kt | 144 +++++++++++++----- app/src/main/res/values/strings.xml | 13 ++ 2 files changed, 121 insertions(+), 36 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index e10a6fb552..266d4f47a8 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -139,8 +139,8 @@ internal fun PlacementSection( initialFomodSelections: Map>, onFomodSelectionsChanged: (Map>) -> Unit, previousOwnership: ModOwnershipManifest?, - ownershipManifests: List, - installNamesById: Map, + ownershipManifests: List = emptyList(), + installNamesById: Map = emptyMap(), canRestorePrevious: Boolean, onRestorePrevious: () -> Unit, placementChoice: PlacementChoice, @@ -158,6 +158,10 @@ internal fun PlacementSection( ) { var showArchiveBrowser by remember(install.installId, entries) { mutableStateOf(false) } var showFomodWizard by remember(install.installId, fomodInstaller) { mutableStateOf(false) } + var showAdvancedPlacement by remember(install.installId) { mutableStateOf(placementChoice != PlacementChoice.AUTOMATIC) } + LaunchedEffect(placementChoice) { + if (placementChoice != PlacementChoice.AUTOMATIC) showAdvancedPlacement = true + } val destinationsValid = drafts.all { draft -> roots.any { it.type.name == draft.targetRoot } } val automaticPlan = automaticPlacement.recommended?.plan ?.let(PlacementRiskPolicy::enforce) @@ -232,10 +236,29 @@ internal fun PlacementSection( selected = placementChoice, hasPresets = presetOptions.isNotEmpty(), canUseLastPlacement = canUseLastPlacement, + showAdvanced = showAdvancedPlacement, onSelect = { if (it == PlacementChoice.LAST_USED) onUseLastPlacement() else onPlacementChoiceChange(it) }, ) + TextButton(onClick = { showAdvancedPlacement = !showAdvancedPlacement }) { + Icon(Icons.Default.Settings, contentDescription = null, modifier = Modifier.size(18.dp)) + Spacer(Modifier.width(6.dp)) + Text( + if (showAdvancedPlacement) { + stringResource(R.string.nexus_hide_advanced_placement) + } else { + stringResource(R.string.nexus_advanced_placement) + }, + ) + } + if (!showAdvancedPlacement) { + Text( + stringResource(R.string.nexus_advanced_placement_description), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } if (placementChoice == PlacementChoice.AUTOMATIC && automaticPlanLoading) { Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { @@ -357,6 +380,7 @@ internal fun PlacementSection( ownershipManifests = ownershipManifests, selectedInstallId = install.installId, installNamesById = installNamesById, + showAdvanced = showAdvancedPlacement, canRemove = drafts.size > 1, onUpdate = { onUpdateDraft(index, it) }, onRemove = { onRemoveDraft(index) }, @@ -478,6 +502,7 @@ private fun PlacementPlanReview( ambiguousPaths: List, onExport: () -> Unit, ) { + var showWhy by remember(plan.digest) { mutableStateOf(false) } Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { Text(stringResource(R.string.nexus_plan_review_title), style = MaterialTheme.typography.labelLarge) @@ -491,21 +516,26 @@ private fun PlacementPlanReview( ), style = MaterialTheme.typography.bodySmall, ) - automaticPlacement.recommended?.evidence.orEmpty().forEach { evidence -> - Text("• $evidence", style = MaterialTheme.typography.bodySmall) + TextButton(onClick = { showWhy = !showWhy }) { + Text(if (showWhy) stringResource(R.string.nexus_hide_placement_reason) else stringResource(R.string.nexus_why_this_placement)) } - if (automaticPlacement.candidates.size > 1) { - Text(stringResource(R.string.nexus_plan_ranked), style = MaterialTheme.typography.labelMedium) - automaticPlacement.candidates.take(3).forEachIndexed { index, candidate -> - Text( - stringResource( - R.string.nexus_plan_score, - index + 1, - candidate.label, - (candidate.plan.coverage * 100).toInt(), - ), - style = MaterialTheme.typography.bodySmall, - ) + if (showWhy) { + automaticPlacement.recommended?.evidence.orEmpty().forEach { evidence -> + Text("\u2022 $evidence", style = MaterialTheme.typography.bodySmall) + } + if (automaticPlacement.candidates.size > 1) { + Text(stringResource(R.string.nexus_plan_ranked), style = MaterialTheme.typography.labelMedium) + automaticPlacement.candidates.take(3).forEachIndexed { index, candidate -> + Text( + stringResource( + R.string.nexus_plan_score, + index + 1, + candidate.label, + (candidate.plan.coverage * 100).toInt(), + ), + style = MaterialTheme.typography.bodySmall, + ) + } } } caseMerges.take(5).forEach { merge -> @@ -578,18 +608,20 @@ private fun PlacementChoiceSelector( selected: PlacementChoice, hasPresets: Boolean, canUseLastPlacement: Boolean, + showAdvanced: Boolean, onSelect: (PlacementChoice) -> Unit, ) { Column(verticalArrangement = Arrangement.spacedBy(8.dp)) { Text(stringResource(R.string.nexus_placement_label), style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.primary) BoxWithConstraints(Modifier.fillMaxWidth()) { val compact = maxWidth < 420.dp - val choices = listOf( + val allChoices = listOf( Triple(PlacementChoice.AUTOMATIC, stringResource(R.string.nexus_placement_automatic), true), Triple(PlacementChoice.PRESET, stringResource(R.string.nexus_placement_preset), hasPresets), Triple(PlacementChoice.LAST_USED, stringResource(R.string.nexus_placement_last_used), canUseLastPlacement), Triple(PlacementChoice.CUSTOM, stringResource(R.string.nexus_placement_custom), true), ) + val choices = if (showAdvanced || selected != PlacementChoice.AUTOMATIC) allChoices else allChoices.take(1) val rows = if (compact) choices.chunked(2) else listOf(choices) Column(verticalArrangement = Arrangement.spacedBy(8.dp), modifier = Modifier.fillMaxWidth()) { rows.forEach { rowChoices -> @@ -740,6 +772,7 @@ private fun PlacementDraftEditor( ownershipManifests: List, selectedInstallId: String, installNamesById: Map, + showAdvanced: Boolean, canRemove: Boolean, onUpdate: (RecipeDraft) -> Unit, onRemove: () -> Unit, @@ -747,6 +780,16 @@ private fun PlacementDraftEditor( var showSourcePicker by remember(index) { mutableStateOf(false) } var showDestinationPicker by remember(index) { mutableStateOf(false) } var showManualPaths by remember(index) { mutableStateOf(false) } + val layout = remember(draft.sourceSubpath, draft.targetRelativePath, draft.includeSourceDirectory, entries) { + placementLayoutModel(draft, entries) + } + val recommendedKeepFolder = remember(draft.sourceSubpath, draft.targetRelativePath, entries) { + AutomaticPlacementPlanner.inferIncludeSourceDirectory( + ModPlacementSources.decode(draft.sourceSubpath), + entries, + draft.targetRelativePath, + ) + } Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) { @@ -774,34 +817,63 @@ private fun PlacementDraftEditor( ) DestinationScopeText(draft, roots) - DropdownField( - label = stringResource(R.string.nexus_install_method), - value = placementModeLabelText(draft.mode), - options = ModPlacementMode.entries.map { placementModeLabelText(it.name) to it.name }, - onSelect = { onUpdate(draft.copy(mode = it)) }, - modifier = Modifier.fillMaxWidth(), - ) - - Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(10.dp)) { - Checkbox( - checked = draft.includeSourceDirectory, - onCheckedChange = { onUpdate(draft.copy(includeSourceDirectory = it)) }, - ) - Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) { - Text(stringResource(R.string.nexus_create_folder_for_selection)) + if (layout.visible) { + Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { + Text(stringResource(R.string.nexus_folder_layout), style = MaterialTheme.typography.labelLarge) + val names = layout.selectedNames.take(2).joinToString(", ") + if (layout.selectedNames.size > 2) ", ..." else "" + val contentsLabel = if (layout.multipleFolders) { + stringResource(R.string.nexus_merge_selected_folder_contents) + } else { + stringResource(R.string.nexus_install_contents_of, names) + } + val folderLabel = if (layout.multipleFolders) { + stringResource(R.string.nexus_keep_selected_folder_names) + } else { + stringResource(R.string.nexus_install_folder_and_contents, names) + } + PlacementChoiceButton( + text = contentsLabel + if (!recommendedKeepFolder) stringResource(R.string.nexus_recommended_suffix) else "", + selected = !draft.includeSourceDirectory, + onClick = { onUpdate(draft.copy(includeSourceDirectory = false)) }, + modifier = Modifier.fillMaxWidth(), + ) + PlacementChoiceButton( + text = folderLabel + if (recommendedKeepFolder) stringResource(R.string.nexus_recommended_suffix) else "", + selected = draft.includeSourceDirectory, + onClick = { onUpdate(draft.copy(includeSourceDirectory = true)) }, + modifier = Modifier.fillMaxWidth(), + ) Text( - text = stringResource(R.string.nexus_create_folder_for_selection_description), + stringResource(R.string.nexus_folder_layout_result, layout.resultExample), style = MaterialTheme.typography.bodySmall, + fontFamily = FontFamily.Monospace, color = MaterialTheme.colorScheme.onSurfaceVariant, ) + if (layout.duplicateFolderWarning) { + Text( + stringResource(R.string.nexus_duplicate_folder_warning), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } } } - TextButton(onClick = { showManualPaths = !showManualPaths }) { - Text(if (showManualPaths) stringResource(R.string.nexus_hide_manual_paths) else stringResource(R.string.nexus_manual_paths)) + if (showAdvanced) { + DropdownField( + label = stringResource(R.string.nexus_install_method), + value = placementModeLabelText(draft.mode), + options = ModPlacementMode.entries.map { placementModeLabelText(it.name) to it.name }, + onSelect = { onUpdate(draft.copy(mode = it)) }, + modifier = Modifier.fillMaxWidth(), + ) + + TextButton(onClick = { showManualPaths = !showManualPaths }) { + Text(if (showManualPaths) stringResource(R.string.nexus_hide_manual_paths) else stringResource(R.string.nexus_manual_paths)) + } } - if (showManualPaths) { + if (showAdvanced && showManualPaths) { NoExtractOutlinedTextField( value = sourceManualText(draft.sourceSubpath), onValueChange = { value -> diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 2f26457e9d..d4394c096e 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1979,6 +1979,19 @@ Install method Create a folder for the selection On: The selected folder is installed into the destination. Off: Only its contents are placed there. + Advanced placement + Hide advanced placement + Automatic placement is recommended. Open advanced placement only to choose presets, reuse an earlier layout, or map files yourself. + At the destination, install + Contents of %1$s + %1$s folder and its contents + Merge selected folder contents + Keep each selected folder name + (Recommended) + Result: %1$s + This creates a repeated folder name such as Data/Data. Choose contents unless the mod specifically requires the extra folder. + Why this placement? + Hide placement details Hide manual paths Manual paths Folders/files from the mod From 7b82718cf392f890183bd546d8c894e1814fec0e Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:20:10 -0500 Subject: [PATCH 31/60] feat: add complete placement review --- .../dialog/PlacementReviewAndroidTest.kt | 3 + .../ui/component/dialog/NexusModsDialog.kt | 60 +++- .../dialog/NexusModsPlacementSections.kt | 299 +++++++++++++++--- .../dialog/PlacementWorkspaceModels.kt | 4 + app/src/main/res/values/strings.xml | 19 ++ 5 files changed, 338 insertions(+), 47 deletions(-) diff --git a/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt index 3eebeac438..fae3ca2e87 100644 --- a/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt +++ b/app/src/androidTest/java/app/gamenative/ui/component/dialog/PlacementReviewAndroidTest.kt @@ -91,6 +91,9 @@ class PlacementReviewAndroidTest { compose.onNodeWithText(compose.activity.getString(R.string.nexus_plan_export)) .assertExists() .assertHasClickAction() + compose.onNodeWithText(compose.activity.getString(R.string.nexus_review_all_files, recommended.plan.files.size)) + .assertExists() + .assertHasClickAction() compose.onNodeWithText(compose.activity.getString(R.string.nexus_restore_previous_deployment)) .assertExists() .assertHasClickAction() diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 936f4940a1..6d909eca10 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -85,6 +85,7 @@ import app.gamenative.mods.BethesdaPluginDependencyIssue import app.gamenative.mods.BethesdaPluginManager import app.gamenative.mods.AuthorizedNexusWebsiteDownload import app.gamenative.mods.AutomaticPlacementPlanner +import app.gamenative.mods.AutomaticPlacementCandidate import app.gamenative.mods.AutomaticPlacementResult import app.gamenative.mods.BrowserFirstNexusWebsiteDownload import app.gamenative.mods.FomodInstaller @@ -185,6 +186,12 @@ internal enum class PlacementChoice { CUSTOM, } +private data class PlacementPlanPreview( + val installId: String, + val drafts: List, + val plan: ModInstallPlan, +) + private enum class ManageModsTab { IMPORT, MODS, @@ -842,6 +849,7 @@ fun NexusModsDialog( var pendingProfileDelete by remember { mutableStateOf(null) } var placementChoice by remember { mutableStateOf(PlacementChoice.AUTOMATIC) } var reviewedPlacementPlan by remember { mutableStateOf(null) } + var placementPlanPreview by remember { mutableStateOf(null) } var automaticOptionSelections by remember { mutableStateOf>(emptyMap()) } var riskyAutomaticPlanApproved by remember { mutableStateOf(false) } var fomodSelectionDraft by remember { mutableStateOf>>(emptyMap()) } @@ -3084,6 +3092,37 @@ fun NexusModsDialog( recipes = recipeDrafts.map { draft -> draft.toRecipe(install.installId) }, ) + LaunchedEffect( + selectedInstall?.installId, + placementChoice, + recipeDrafts.toList(), + ) { + val install = selectedInstall + val snapshot = recipeDrafts.toList() + if (install == null || !install.canPlaceFiles() || placementChoice == PlacementChoice.AUTOMATIC || snapshot.isEmpty()) { + placementPlanPreview = null + return@LaunchedEffect + } + delay(200) + val recipes = BethesdaPlacementRecipeExpander.expand( + gameName = libraryItem.name, + install = install, + recipes = snapshot.map { it.toRecipe(install.installId) }, + ) + val preview = withContext(Dispatchers.IO) { + runCatching { + ModMaterializer.materializationPlan( + install = install, + recipes = recipes, + gameRootDir = gameRootDir, + winePrefix = winePrefix, + captureTargetHashes = false, + ).reviewedPlan + }.getOrNull() + } + placementPlanPreview = preview?.let { PlacementPlanPreview(install.installId, snapshot, it) } + } + LaunchedEffect( selectedInstall?.installId, configurationDraftLoaded, @@ -3208,7 +3247,10 @@ fun NexusModsDialog( return } } - val initialReviewedPlan = automaticPlan ?: reviewedPlacementPlan + val currentPreview = placementPlanPreview?.takeIf { + it.installId == install.installId && it.drafts == recipeDrafts.toList() + }?.plan + val initialReviewedPlan = automaticPlan ?: reviewedPlacementPlan ?: currentPreview if ( selectedFomodInstaller != null && placementChoice != PlacementChoice.CUSTOM && @@ -3595,7 +3637,9 @@ fun NexusModsDialog( placementApplyStatusMessage = null riskyAutomaticPlanApproved = approved }, - reviewedPlan = reviewedPlacementPlan, + reviewedPlan = reviewedPlacementPlan ?: placementPlanPreview?.takeIf { + it.installId == install.installId && it.drafts == recipeDrafts.toList() + }?.plan, initialFomodSelections = fomodSelectionDraft, onFomodSelectionsChanged = { fomodSelectionDraft = it }, previousOwnership = selectedOwnership, @@ -3665,6 +3709,18 @@ fun NexusModsDialog( SnackbarManager.show(context.getString(R.string.nexus_fomod_choices_added)) } }, + onUseAutomaticCandidate = { candidate: AutomaticPlacementCandidate -> + placementApplyStatusMessage = null + placementChoice = PlacementChoice.CUSTOM + reviewedPlacementPlan = candidate.plan + recipeDrafts.clear() + recipeDrafts += automaticDraftsFor( + AutomaticPlacementResult(listOf(candidate), candidate), + libraryItem.name, + archiveEntries, + defaultDraft, + ) + }, applyStatusMessage = placementApplyStatusMessage, onExportPlan = { plan -> exportPlacementPlan(install, plan) }, onSaveAndApply = ::saveAndApply, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 266d4f47a8..1cd3b644bf 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -73,6 +73,7 @@ import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementMode import app.gamenative.data.ModTargetRoot import app.gamenative.mods.AutomaticPlacementPlanner +import app.gamenative.mods.AutomaticPlacementCandidate import app.gamenative.mods.AutomaticPlacementResult import app.gamenative.mods.FomodInstaller import app.gamenative.mods.FomodEnvironmentSnapshot @@ -80,6 +81,7 @@ import app.gamenative.mods.ModArchiveEntry import app.gamenative.mods.ModInstallPlan import app.gamenative.mods.ModOwnershipManifest import app.gamenative.mods.ModOwnershipPlanDiffer +import app.gamenative.mods.ModReconfigurationDiff import app.gamenative.mods.ModPlacementPreset import app.gamenative.mods.ModPlacementSources import app.gamenative.mods.ModTargetResolver @@ -146,6 +148,7 @@ internal fun PlacementSection( placementChoice: PlacementChoice, canUseLastPlacement: Boolean, onPlacementChoiceChange: (PlacementChoice) -> Unit, + onUseAutomaticCandidate: (AutomaticPlacementCandidate) -> Unit = {}, onUseLastPlacement: () -> Unit, onPresetSelected: (List) -> Unit, onUpdateDraft: (Int, RecipeDraft) -> Unit, @@ -269,8 +272,15 @@ internal fun PlacementSection( PlacementPlanReview( automaticPlacement = automaticPlacement, plan = automaticPlan, + roots = roots, + diff = reconfigurationDiff, caseMerges = targetInspection?.caseMerges.orEmpty(), ambiguousPaths = targetInspection?.ambiguousPaths.orEmpty(), + ownershipManifests = ownershipManifests, + selectedInstallId = install.installId, + installNamesById = installNamesById, + onResolve = { onPlacementChoiceChange(PlacementChoice.CUSTOM) }, + onUseCandidate = onUseAutomaticCandidate, onExport = { onExportPlan(automaticPlan) }, ) } else if (placementChoice == PlacementChoice.AUTOMATIC) { @@ -279,6 +289,21 @@ internal fun PlacementSection( style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.error, ) + } else if (configuredPlan != null) { + PlacementPlanReview( + automaticPlacement = null, + plan = configuredPlan, + roots = roots, + diff = reconfigurationDiff, + caseMerges = emptyList(), + ambiguousPaths = emptyList(), + ownershipManifests = ownershipManifests, + selectedInstallId = install.installId, + installNamesById = installNamesById, + onResolve = null, + onUseCandidate = onUseAutomaticCandidate, + onExport = { onExportPlan(configuredPlan) }, + ) } if (placementChoice == PlacementChoice.AUTOMATIC && automaticPlacement.optionGroups.isNotEmpty()) { @@ -335,24 +360,6 @@ internal fun PlacementSection( } } - reconfigurationDiff?.let { diff -> - Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { - Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) { - Text(stringResource(R.string.nexus_reconfiguration_preview), style = MaterialTheme.typography.labelLarge) - Text( - stringResource( - R.string.nexus_reconfiguration_summary, - diff.added, - diff.changed, - diff.moved, - diff.stale, - ), - style = MaterialTheme.typography.bodySmall, - ) - } - } - } - if (placementChoice == PlacementChoice.PRESET && presetOptions.isNotEmpty()) { PresetSelectionSection( presets = presetOptions, @@ -496,13 +503,23 @@ internal fun PlacementSection( @Composable private fun PlacementPlanReview( - automaticPlacement: AutomaticPlacementResult, + automaticPlacement: AutomaticPlacementResult?, plan: ModInstallPlan, + roots: List, + diff: ModReconfigurationDiff?, caseMerges: List, ambiguousPaths: List, + ownershipManifests: List, + selectedInstallId: String, + installNamesById: Map, + onResolve: (() -> Unit)?, + onUseCandidate: (AutomaticPlacementCandidate) -> Unit, onExport: () -> Unit, ) { var showWhy by remember(plan.digest) { mutableStateOf(false) } + var showAllFiles by remember(plan.digest) { mutableStateOf(false) } + var browseTarget by remember(plan.digest) { mutableStateOf(null) } + val rows = remember(plan, diff, roots) { placementReviewRows(plan, diff, roots) } Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { Text(stringResource(R.string.nexus_plan_review_title), style = MaterialTheme.typography.labelLarge) @@ -520,21 +537,28 @@ private fun PlacementPlanReview( Text(if (showWhy) stringResource(R.string.nexus_hide_placement_reason) else stringResource(R.string.nexus_why_this_placement)) } if (showWhy) { - automaticPlacement.recommended?.evidence.orEmpty().forEach { evidence -> + automaticPlacement?.recommended?.evidence.orEmpty().forEach { evidence -> Text("\u2022 $evidence", style = MaterialTheme.typography.bodySmall) } - if (automaticPlacement.candidates.size > 1) { + if (automaticPlacement?.candidates.orEmpty().size > 1) { Text(stringResource(R.string.nexus_plan_ranked), style = MaterialTheme.typography.labelMedium) - automaticPlacement.candidates.take(3).forEachIndexed { index, candidate -> - Text( - stringResource( - R.string.nexus_plan_score, - index + 1, - candidate.label, - (candidate.plan.coverage * 100).toInt(), - ), - style = MaterialTheme.typography.bodySmall, - ) + automaticPlacement?.candidates.orEmpty().take(3).forEachIndexed { index, candidate -> + Column(verticalArrangement = Arrangement.spacedBy(3.dp)) { + Text( + stringResource( + R.string.nexus_plan_score, + index + 1, + candidate.label, + (candidate.plan.coverage * 100).toInt(), + ), + style = MaterialTheme.typography.bodySmall, + ) + if (candidate.plan.digest != plan.digest) { + TextButton(onClick = { onUseCandidate(candidate) }) { + Text(stringResource(R.string.nexus_use_this_placement)) + } + } + } } } } @@ -565,14 +589,187 @@ private fun PlacementPlanReview( style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.error, ) + if (onResolve != null) { + Button(onClick = onResolve, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.nexus_resolve_files, plan.unresolvedCount + ambiguousPaths.size)) + } + Text( + stringResource(R.string.nexus_resolve_files_description), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + if (diff?.hasChanges == true) { + Text( + stringResource(R.string.nexus_reconfiguration_summary, diff.added, diff.changed, diff.moved, diff.stale), + style = MaterialTheme.typography.bodySmall, + ) + } + plan.warnings.take(5).forEach { warning -> + Text("\u2022 $warning", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.tertiary) } - TextButton(onClick = onExport) { - Text(stringResource(R.string.nexus_plan_export)) + Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { + OutlinedButton(onClick = { showAllFiles = true }) { + Text(stringResource(R.string.nexus_review_all_files, rows.size)) + } + TextButton(onClick = onExport) { + Text(stringResource(R.string.nexus_plan_export)) + } + } + } + } + + if (showAllFiles) { + PlacementPlanFilesDialog( + rows = rows, + onBrowseDestination = { row -> + browseTarget = RecipeDraft(targetRoot = row.targetRoot, targetRelativePath = row.targetRelativePath) + }, + onDismiss = { showAllFiles = false }, + ) + } + + browseTarget?.let { target -> + ContainerDestinationPickerDialog( + roots = roots, + currentDraft = target, + plan = plan, + ownershipManifests = ownershipManifests, + selectedInstallId = selectedInstallId, + installNamesById = installNamesById, + readOnly = true, + onSelect = {}, + onDismiss = { browseTarget = null }, + ) + } +} + +@Composable +private fun PlacementPlanFilesDialog( + rows: List, + onBrowseDestination: (PlacementReviewRow) -> Unit, + onDismiss: () -> Unit, +) { + var query by remember(rows) { mutableStateOf("") } + var category by remember(rows) { mutableStateOf(null) } + val categories = remember(rows) { rows.map { it.category }.distinct() } + val filtered = remember(rows, query, category) { + rows.filter { (category == null || it.category == category) && it.matches(query) } + } + Dialog(onDismissRequest = onDismiss, properties = DialogProperties(usePlatformDefaultWidth = false)) { + Surface( + modifier = Modifier.fillMaxWidth(0.96f).height(640.dp), + shape = RoundedCornerShape(12.dp), + color = MaterialTheme.colorScheme.surface, + ) { + Column(Modifier.fillMaxSize()) { + Column(Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) { + Text(stringResource(R.string.nexus_all_planned_files), style = MaterialTheme.typography.headlineSmall) + NoExtractOutlinedTextField( + value = query, + onValueChange = { query = it }, + modifier = Modifier.fillMaxWidth(), + label = { Text(stringResource(R.string.nexus_search_planned_files)) }, + leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) }, + singleLine = true, + ) + Row( + modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), + horizontalArrangement = Arrangement.spacedBy(6.dp), + ) { + PlacementChoiceButton( + text = stringResource(R.string.nexus_all_files_count, rows.size), + selected = category == null, + onClick = { category = null }, + ) + categories.forEach { option -> + PlacementChoiceButton( + text = "${placementReviewCategoryLabel(option)} (${rows.count { it.category == option }})", + selected = category == option, + onClick = { category = option }, + ) + } + } + } + HorizontalDivider() + if (filtered.isEmpty()) { + Box(Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { + Text(stringResource(R.string.nexus_no_matching_planned_files), color = MaterialTheme.colorScheme.onSurfaceVariant) + } + } else { + LazyColumn(Modifier.weight(1f).fillMaxWidth()) { + filtered.groupBy { it.category }.forEach { (group, groupRows) -> + item(key = "header:${group.name}") { + Surface(Modifier.fillMaxWidth(), color = MaterialTheme.colorScheme.surfaceVariant) { + Text( + "${placementReviewCategoryLabel(group)} (${groupRows.size})", + modifier = Modifier.padding(horizontal = 20.dp, vertical = 8.dp), + style = MaterialTheme.typography.labelLarge, + ) + } + } + items(groupRows, key = { "${group.name}:${it.source}:${it.target}:${it.previousTarget}" }) { row -> + Column( + modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 10.dp), + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Text(row.source, style = MaterialTheme.typography.bodyMedium, fontFamily = FontFamily.Monospace) + if (row.previousTarget.isNotBlank()) { + Text( + stringResource(R.string.nexus_previous_destination_value, row.previousTarget), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + } + if (row.target.isNotBlank()) { + Text( + stringResource(R.string.nexus_destination_value, row.target), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.primary, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + } + if (row.reason.isNotBlank()) { + Text(row.reason, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + if (row.sizeBytes > 0L) { + Text(StorageUtils.formatBinarySize(row.sizeBytes), style = MaterialTheme.typography.labelSmall) + } + if (row.targetRoot.isNotBlank()) { + TextButton(onClick = { onBrowseDestination(row) }) { + Text(stringResource(R.string.nexus_browse_destination)) + } + } + } + HorizontalDivider(modifier = Modifier.padding(horizontal = 20.dp), thickness = 0.5.dp) + } + } + } + } + HorizontalDivider() + Row(Modifier.fillMaxWidth().padding(12.dp), horizontalArrangement = Arrangement.End) { + Button(onClick = onDismiss) { Text(stringResource(R.string.close)) } + } } } } } +@Composable +private fun placementReviewCategoryLabel(category: PlacementReviewCategory): String = when (category) { + PlacementReviewCategory.ADDED -> stringResource(R.string.nexus_plan_group_added) + PlacementReviewCategory.REPLACED -> stringResource(R.string.nexus_plan_group_replaced) + PlacementReviewCategory.MOVED -> stringResource(R.string.nexus_plan_group_moved) + PlacementReviewCategory.REMOVED -> stringResource(R.string.nexus_plan_group_removed) + PlacementReviewCategory.IGNORED -> stringResource(R.string.nexus_plan_group_ignored) + PlacementReviewCategory.BLOCKED -> stringResource(R.string.nexus_plan_group_blocked) + PlacementReviewCategory.UNCHANGED -> stringResource(R.string.nexus_plan_group_unchanged) +} + @Composable private fun PresetSelectionSection( presets: List, @@ -1208,6 +1405,7 @@ private fun ContainerDestinationPickerDialog( ownershipManifests: List, selectedInstallId: String, installNamesById: Map, + readOnly: Boolean = false, onSelect: (RecipeDraft) -> Unit, onDismiss: () -> Unit, ) { @@ -1302,7 +1500,10 @@ private fun ContainerDestinationPickerDialog( ) { Column(modifier = Modifier.fillMaxSize()) { Column(Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) { - Text(stringResource(R.string.nexus_destination_folder), style = MaterialTheme.typography.headlineSmall) + Text( + stringResource(if (readOnly) R.string.nexus_destination_contents else R.string.nexus_destination_folder), + style = MaterialTheme.typography.headlineSmall, + ) Text( text = if (currentDir == null) stringResource(R.string.nexus_choose_game_container_location) else breadcrumb, style = MaterialTheme.typography.bodySmall, @@ -1370,13 +1571,15 @@ private fun ContainerDestinationPickerDialog( Row(verticalAlignment = Alignment.CenterVertically) { Checkbox(checked = showHidden, onCheckedChange = { showHidden = it }) Text(stringResource(R.string.nexus_show_hidden_files), modifier = Modifier.weight(1f)) - TextButton(onClick = { - newFolderName = "" - showNewFolderDialog = true - }) { - Icon(Icons.Default.CreateNewFolder, contentDescription = null, modifier = Modifier.size(18.dp)) - Spacer(Modifier.width(6.dp)) - Text(stringResource(R.string.nexus_new_destination_folder)) + if (!readOnly) { + TextButton(onClick = { + newFolderName = "" + showNewFolderDialog = true + }) { + Icon(Icons.Default.CreateNewFolder, contentDescription = null, modifier = Modifier.size(18.dp)) + Spacer(Modifier.width(6.dp)) + Text(stringResource(R.string.nexus_new_destination_folder)) + } } } } @@ -1491,12 +1694,18 @@ private fun ContainerDestinationPickerDialog( horizontalArrangement = Arrangement.End, verticalAlignment = Alignment.CenterVertically, ) { - TextButton(onClick = onDismiss) { - Text(stringResource(R.string.cancel)) + if (!readOnly) { + TextButton(onClick = onDismiss) { + Text(stringResource(R.string.cancel)) + } } val selectedRoot = currentRoot val selectedDir = selectedDestination ?: currentDir - if (selectedRoot != null && selectedDir != null) { + if (readOnly) { + Button(onClick = onDismiss, modifier = Modifier.padding(start = 8.dp)) { + Text(stringResource(R.string.close)) + } + } else if (selectedRoot != null && selectedDir != null) { Button( onClick = { val relative = runCatching { @@ -1522,7 +1731,7 @@ private fun ContainerDestinationPickerDialog( } } - if (showNewFolderDialog) { + if (showNewFolderDialog && !readOnly) { val validName = validVirtualDestinationFolderName(newFolderName) AlertDialog( onDismissRequest = { showNewFolderDialog = false }, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index e5da8f62ca..302a6d15e5 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -180,6 +180,8 @@ internal data class PlacementReviewRow( val source: String, val previousTarget: String = "", val target: String = "", + val targetRoot: String = "", + val targetRelativePath: String = "", val reason: String = "", val sizeBytes: Long = 0L, ) { @@ -217,6 +219,8 @@ internal fun placementReviewRows( source = file.sourceRelativePath, previousTarget = change?.previousTarget.orEmpty(), target = file.targetDisplay(), + targetRoot = file.targetRoot.orEmpty(), + targetRelativePath = file.targetRelativePath.orEmpty(), reason = file.reason, sizeBytes = file.sizeBytes, ) diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index d4394c096e..1e5a0c8adc 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1992,6 +1992,25 @@ This creates a repeated folder name such as Data/Data. Choose contents unless the mod specifically requires the extra folder. Why this placement? Hide placement details + Use this placement + Resolve %1$d files + Switches to custom placement with the recommended mappings preserved so unresolved files can be assigned safely. + Review all files (%1$d) + All planned files + Search source, destination, or reason + All (%1$d) + No planned files match this filter + Previous: %1$s + Destination: %1$s + Browse destination + Destination contents + Added + Replaced + Moved + Removed + Ignored + Blocked + Unchanged Hide manual paths Manual paths Folders/files from the mod From 7909d37202769c2bb06e57d6a7bc3b5579445a89 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:29:39 -0500 Subject: [PATCH 32/60] fix: preserve unresolved placement files --- .../ui/component/dialog/NexusModsDialog.kt | 8 +++++ .../dialog/NexusModsDialogHelpers.kt | 17 +++++++++++ .../dialog/NexusModsPlacementSections.kt | 29 ++++++++++++++----- .../dialog/NexusModsDialogHelpersTest.kt | 12 ++++++++ 4 files changed, 58 insertions(+), 8 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 6d909eca10..6b2faa0fbb 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -3721,6 +3721,14 @@ fun NexusModsDialog( defaultDraft, ) }, + onResolveAutomaticPlan = { unresolvedSources -> + placementApplyStatusMessage = null + reviewedPlacementPlan = null + placementChoice = PlacementChoice.CUSTOM + val resolvedDrafts = draftsWithUnresolvedSources(recipeDrafts.toList(), unresolvedSources, defaultDraft) + recipeDrafts.clear() + recipeDrafts += resolvedDrafts + }, applyStatusMessage = placementApplyStatusMessage, onExportPlan = { plan -> exportPlacementPlan(install, plan) }, onSaveAndApply = ::saveAndApply, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt index 3e435fe2d8..0093db5fbe 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt @@ -346,6 +346,23 @@ internal fun compatibleLastPlacementDrafts( } } +internal fun draftsWithUnresolvedSources( + current: List, + unresolvedSources: List, + fallback: RecipeDraft, +): List { + val existingSources = current.flatMap { ModPlacementSources.decode(it.sourceSubpath) }.toSet() + val unresolvedDrafts = unresolvedSources.distinct().filterNot { it in existingSources }.map { source -> + fallback.copy( + sourceSubpath = ModPlacementSources.encode(listOf(source)), + targetRoot = "", + targetRelativePath = "", + includeSourceDirectory = false, + ) + } + return current + unresolvedDrafts +} + internal fun archiveContainsSource(entries: List, source: String): Boolean { val normalizedSource = normalizeArchivePath(source) if (normalizedSource.isBlank()) return true diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 1cd3b644bf..058d9ac1af 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -149,6 +149,7 @@ internal fun PlacementSection( canUseLastPlacement: Boolean, onPlacementChoiceChange: (PlacementChoice) -> Unit, onUseAutomaticCandidate: (AutomaticPlacementCandidate) -> Unit = {}, + onResolveAutomaticPlan: (List) -> Unit = {}, onUseLastPlacement: () -> Unit, onPresetSelected: (List) -> Unit, onUpdateDraft: (Int, RecipeDraft) -> Unit, @@ -174,8 +175,7 @@ internal fun PlacementSection( ?.withRiskApproval(riskyAutomaticPlanApproved) val visiblePlan = if (placementChoice == PlacementChoice.AUTOMATIC) automaticPlan else configuredPlan val reconfigurationDiff = remember(previousOwnership, visiblePlan) { - visiblePlan?.let { ModOwnershipPlanDiffer.compare(previousOwnership, it) } - ?.takeIf { previousOwnership != null && it.hasChanges } + visiblePlan?.takeIf { previousOwnership != null }?.let { ModOwnershipPlanDiffer.compare(previousOwnership, it) } } val targetInspection = remember(automaticPlan, roots) { automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } @@ -279,16 +279,29 @@ internal fun PlacementSection( ownershipManifests = ownershipManifests, selectedInstallId = install.installId, installNamesById = installNamesById, - onResolve = { onPlacementChoiceChange(PlacementChoice.CUSTOM) }, + onResolve = { + val unresolvedSources = automaticPlan.files.filter { + it.status == PlannedFileStatus.UNSUPPORTED || + it.status == PlannedFileStatus.MISSING || + it.status == PlannedFileStatus.CONFLICTED || + it.targetRelativePath in targetInspection?.ambiguousPaths.orEmpty() + }.map { it.sourceRelativePath }.distinct() + onResolveAutomaticPlan(unresolvedSources) + }, onUseCandidate = onUseAutomaticCandidate, onExport = { onExportPlan(automaticPlan) }, ) } else if (placementChoice == PlacementChoice.AUTOMATIC) { - Text( - stringResource(R.string.nexus_plan_blocked), - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.error, - ) + Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { + Text( + stringResource(R.string.nexus_plan_blocked), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + OutlinedButton(onClick = { onResolveAutomaticPlan(emptyList()) }, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.nexus_placement_custom)) + } + } } else if (configuredPlan != null) { PlacementPlanReview( automaticPlacement = null, diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt index 4386dae24a..fce4759375 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt @@ -84,6 +84,18 @@ class NexusModsDialogHelpersTest { assertEquals(recipe.targetFileName, recipe.toDraft().toRecipe(recipe.installId).targetFileName) } + @Test + fun unresolvedSources_requireAnExplicitDestinationWithoutDroppingExistingMappings() { + val current = listOf(RecipeDraft(sourceSubpath = "Data", targetRelativePath = "Data")) + + val drafts = draftsWithUnresolvedSources(current, listOf("Docs/readme.txt", "Docs/readme.txt"), RecipeDraft()) + + assertEquals(2, drafts.size) + assertEquals(current.single(), drafts.first()) + assertEquals("Docs/readme.txt", drafts.last().sourceSubpath) + assertEquals("", drafts.last().targetRoot) + } + private fun install(status: ModInstallStatus): ModInstall = ModInstall( installId = "install", From f42f44e35018f0b38cdef2dfca998747d718ab00 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:29:44 -0500 Subject: [PATCH 33/60] feat: localize placement workspace --- app/src/main/res/values-da/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-de/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-es/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-fr/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-it/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-ja/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-ko/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-pl/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-pt-rBR/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-ro/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-ru/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-uk/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-zh-rCN/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values-zh-rTW/strings.xml | 52 +++++++++++++++++++++- app/src/main/res/values/strings.xml | 2 - 15 files changed, 700 insertions(+), 30 deletions(-) diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 4fd02e6c31..9eaaf1f88a 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -1790,8 +1790,6 @@ Mappe/fil fra mod Destinationsmappe Installationsmetode - Opret en mappe til valget - Til: Den valgte mappe er installeret på destinationen. Fra: Kun dens indhold placeres der. Skjul manuelle stier Manuelle stier Mapper/filer fra mod @@ -2255,4 +2253,54 @@ Gendanner forrige udrulning… Den forrige udrulning blev gendannet. Den forrige udrulning kunne ikke gendannes (%1$d problem(er)) + Søg i denne mappe + Vis skjulte filer og mapper + Ny mappe + Vælg et mappenavn i den aktuelle destination. + Mappenavn + Intet ændres endnu. Mappen oprettes først, når den gennemgåede plan anvendes. + Brug mappe + Oprettes + Ingen matchende filer eller mapper + Tilføjes + Erstattes + Sikkerhedskopieres + Plankonflikt + Administreret af dette mod + Administreret af %1$s + Ændret siden installation + Spilfil eller ikke-administreret fil + Modtager filer + Avanceret placering + Skjul avanceret placering + Automatisk placering anbefales. Åbn kun avanceret placering for at vælge forudindstillinger, genbruge et layout eller tilknytte filer manuelt. + Installer på destinationen + Indholdet af %1$s + Mappen %1$s og dens indhold + Flet indholdet af valgte mapper + Behold navnene på hver valgt mappe + (Anbefalet) + Resultat: %1$s + Dette opretter et gentaget mappenavn som Data/Data. Vælg indhold, medmindre moddet kræver den ekstra mappe. + Hvorfor denne placering? + Skjul placeringsdetaljer + Brug denne placering + Løs %1$d filer + Skifter til brugerdefineret placering og bevarer de anbefalede tilknytninger, så uløste filer kan tildeles sikkert. + Gennemgå alle filer (%1$d) + Alle planlagte filer + Søg i kilde, destination eller årsag + Alle (%1$d) + Ingen planlagte filer matcher filteret + Tidligere: %1$s + Destination: %1$s + Gennemse destination + Destinationens indhold + Tilføjet + Erstattet + Flyttet + Fjernet + Ignoreret + Blokeret + Uændret diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index d5f895d3c4..2aa99a61b1 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -1860,8 +1860,6 @@ Ordner/Datei aus dem Mod Zielordner Methode installieren - Erstellen Sie einen Ordner für die Auswahl - Ein: Der ausgewählte Ordner wird im Ziel installiert. Aus: Nur der Inhalt wird dort platziert. Manuelle Pfade ausblenden Manuelle Pfade Ordner/Dateien aus dem Mod @@ -2325,4 +2323,54 @@ Vorherige Bereitstellung wird wiederhergestellt… Die vorherige Bereitstellung wurde wiederhergestellt. Die vorherige Bereitstellung konnte nicht wiederhergestellt werden (%1$d Problem(e)) + Diesen Ordner durchsuchen + Versteckte Dateien und Ordner anzeigen + Neuer Ordner + Wähle einen Ordnernamen im aktuellen Ziel. + Ordnername + Noch wird nichts geändert. Der Ordner wird erst beim Anwenden des geprüften Plans erstellt. + Ordner verwenden + Wird erstellt + Keine passenden Dateien oder Ordner + Wird hinzugefügt + Wird ersetzt + Wird gesichert + Plankonflikt + Von diesem Mod verwaltet + Verwaltet von %1$s + Seit der Bereitstellung geändert + Spiel- oder nicht verwaltete Datei + Erhält Dateien + Erweiterte Platzierung + Erweiterte Platzierung ausblenden + Die automatische Platzierung wird empfohlen. Öffne die erweiterte Platzierung nur für Vorlagen, frühere Layouts oder manuelle Zuordnungen. + Am Ziel installieren + Inhalt von %1$s + Ordner %1$s und sein Inhalt + Inhalte ausgewählter Ordner zusammenführen + Namen aller ausgewählten Ordner beibehalten + (Empfohlen) + Ergebnis: %1$s + Dadurch entsteht ein doppelter Ordnername wie Data/Data. Wähle Inhalte, sofern der Mod den zusätzlichen Ordner nicht ausdrücklich benötigt. + Warum diese Platzierung? + Platzierungsdetails ausblenden + Diese Platzierung verwenden + %1$d Dateien lösen + Wechselt zur benutzerdefinierten Platzierung und behält empfohlene Zuordnungen bei, damit ungelöste Dateien sicher zugewiesen werden können. + Alle Dateien prüfen (%1$d) + Alle geplanten Dateien + Quelle, Ziel oder Grund durchsuchen + Alle (%1$d) + Keine geplanten Dateien entsprechen dem Filter + Vorher: %1$s + Ziel: %1$s + Ziel durchsuchen + Zielinhalt + Hinzugefügt + Ersetzt + Verschoben + Entfernt + Ignoriert + Blockiert + Unverändert diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 0802ae23e4..d278d8c1a1 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -1918,8 +1918,6 @@ Carpeta/archivo del mod Carpeta de destino Método de instalación - Crear una carpeta para la selección - Activado: La carpeta seleccionada se instala en el destino. Apagado: Sólo se coloca allí su contenido. Ocultar rutas manuales Rutas manuales Carpetas/archivos del mod @@ -2383,4 +2381,54 @@ Restaurando el despliegue anterior… Se restauró el despliegue anterior. No se pudo restaurar el despliegue anterior (%1$d problema(s)) + Buscar en esta carpeta + Mostrar archivos y carpetas ocultos + Nueva carpeta + Elige un nombre de carpeta dentro del destino actual. + Nombre de carpeta + Aún no se cambia nada. La carpeta se creará al aplicar el plan revisado. + Usar carpeta + Se creará + No hay archivos ni carpetas coincidentes + Se añadirá + Se reemplazará + Se respaldará + Conflicto del plan + Gestionado por este mod + Gestionado por %1$s + Cambiado desde el despliegue + Archivo del juego o no gestionado + Recibirá archivos + Colocación avanzada + Ocultar colocación avanzada + Se recomienda la colocación automática. Abre las opciones avanzadas solo para elegir ajustes, reutilizar un diseño o asignar archivos manualmente. + En el destino, instalar + Contenido de %1$s + Carpeta %1$s y su contenido + Combinar el contenido de las carpetas seleccionadas + Conservar el nombre de cada carpeta seleccionada + (Recomendado) + Resultado: %1$s + Esto crea un nombre de carpeta repetido, como Data/Data. Elige el contenido salvo que el mod requiera la carpeta adicional. + ¿Por qué esta colocación? + Ocultar detalles de colocación + Usar esta colocación + Resolver %1$d archivos + Cambia a colocación personalizada y conserva las asignaciones recomendadas para asignar con seguridad los archivos sin resolver. + Revisar todos los archivos (%1$d) + Todos los archivos planificados + Buscar origen, destino o motivo + Todos (%1$d) + Ningún archivo planificado coincide con el filtro + Anterior: %1$s + Destino: %1$s + Explorar destino + Contenido del destino + Añadidos + Reemplazados + Movidos + Eliminados + Ignorados + Bloqueados + Sin cambios diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 3e476e1757..21724591b8 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -1938,8 +1938,6 @@ Dossier/fichier du mod Dossier de destination Méthode d\'installation - Créer un dossier pour la sélection - Activé : Le dossier sélectionné est installé dans la destination. Désactivé : seul son contenu y est placé. Masquer les chemins manuels Chemins manuels Dossiers/fichiers du mod @@ -2385,4 +2383,54 @@ Restauration du déploiement précédent… Le déploiement précédent a été restauré. Impossible de restaurer le déploiement précédent (%1$d problème(s)) + Rechercher dans ce dossier + Afficher les fichiers et dossiers cachés + Nouveau dossier + Choisissez un nom de dossier dans la destination actuelle. + Nom du dossier + Rien ne change encore. Le dossier sera créé uniquement lors de l’application du plan vérifié. + Utiliser le dossier + Sera créé + Aucun fichier ou dossier correspondant + Sera ajouté + Sera remplacé + Sera sauvegardé + Conflit du plan + Géré par ce mod + Géré par %1$s + Modifié depuis le déploiement + Fichier du jeu ou non géré + Recevra des fichiers + Placement avancé + Masquer le placement avancé + Le placement automatique est recommandé. Ouvrez les options avancées uniquement pour choisir un préréglage, réutiliser une disposition ou associer des fichiers manuellement. + À la destination, installer + Contenu de %1$s + Dossier %1$s et son contenu + Fusionner le contenu des dossiers sélectionnés + Conserver le nom de chaque dossier sélectionné + (Recommandé) + Résultat : %1$s + Cela crée un nom de dossier répété, comme Data/Data. Choisissez le contenu sauf si le mod exige le dossier supplémentaire. + Pourquoi ce placement ? + Masquer les détails du placement + Utiliser ce placement + Résoudre %1$d fichiers + Passe au placement personnalisé tout en conservant les associations recommandées afin d’affecter les fichiers non résolus en toute sécurité. + Vérifier tous les fichiers (%1$d) + Tous les fichiers planifiés + Rechercher la source, la destination ou la raison + Tous (%1$d) + Aucun fichier planifié ne correspond au filtre + Précédent : %1$s + Destination : %1$s + Parcourir la destination + Contenu de la destination + Ajoutés + Remplacés + Déplacés + Supprimés + Ignorés + Bloqués + Inchangés diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 0cc6ef0031..98eeb0fffa 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -1911,8 +1911,6 @@ Cartella/file dal mod Cartella di destinazione Metodo di installazione - Creare una cartella per la selezione - On: La cartella selezionata viene installata nella destinazione. Off: solo i suoi contenuti vengono posizionati lì. Nascondi percorsi manuali Percorsi manuali Cartelle/file dal mod @@ -2376,4 +2374,54 @@ Ripristino della distribuzione precedente… La distribuzione precedente è stata ripristinata. Impossibile ripristinare la distribuzione precedente (%1$d problema/i) + Cerca in questa cartella + Mostra file e cartelle nascosti + Nuova cartella + Scegli un nome di cartella nella destinazione attuale. + Nome cartella + Non viene ancora modificato nulla. La cartella verrà creata solo applicando il piano verificato. + Usa cartella + Verrà creata + Nessun file o cartella corrispondente + Verrà aggiunto + Verrà sostituito + Verrà salvato + Conflitto del piano + Gestito da questa mod + Gestito da %1$s + Modificato dopo il deployment + File di gioco o non gestito + Riceverà file + Posizionamento avanzato + Nascondi posizionamento avanzato + È consigliato il posizionamento automatico. Apri le opzioni avanzate solo per scegliere preset, riutilizzare un layout o mappare manualmente i file. + Nella destinazione, installa + Contenuto di %1$s + Cartella %1$s e relativo contenuto + Unisci il contenuto delle cartelle selezionate + Mantieni il nome di ogni cartella selezionata + (Consigliato) + Risultato: %1$s + Verrà ripetuto un nome di cartella, ad esempio Data/Data. Scegli il contenuto, a meno che la mod non richieda la cartella aggiuntiva. + Perché questo posizionamento? + Nascondi dettagli del posizionamento + Usa questo posizionamento + Risolvi %1$d file + Passa al posizionamento personalizzato conservando le mappature consigliate, così i file irrisolti possono essere assegnati in sicurezza. + Verifica tutti i file (%1$d) + Tutti i file pianificati + Cerca origine, destinazione o motivo + Tutti (%1$d) + Nessun file pianificato corrisponde al filtro + Precedente: %1$s + Destinazione: %1$s + Sfoglia destinazione + Contenuto destinazione + Aggiunti + Sostituiti + Spostati + Rimossi + Ignorati + Bloccati + Invariati diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 5da555e756..c4e714f0ec 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -1876,8 +1876,6 @@ MOD からのフォルダー/ファイル 保存先フォルダー インストール方法 - 選択範囲のフォルダーを作成する - オン: 選択したフォルダーがインストール先にインストールされます。 Off: コンテンツのみがそこに配置されます。 手動パスを非表示にする 手動パス MOD のフォルダー/ファイル @@ -2339,4 +2337,54 @@ 以前の配置を復元中… 以前の配置を復元しました。 以前の配置を復元できませんでした（問題 %1$d 件） + このフォルダーを検索 + 隠しファイルとフォルダーを表示 + 新しいフォルダー + 現在のインストール先に作成するフォルダー名を選択します。 + フォルダー名 + まだ何も変更されません。フォルダーは確認済みプランの適用時にのみ作成されます。 + このフォルダーを使用 + 作成予定 + 一致するファイルまたはフォルダーはありません + 追加予定 + 置換予定 + バックアップ予定 + プランの競合 + この Mod が管理 + %1$s が管理 + 配置後に変更済み + ゲームまたは未管理のファイル + ファイルの配置先 + 詳細な配置 + 詳細な配置を隠す + 自動配置を推奨します。プリセット、以前のレイアウト、手動マッピングが必要な場合のみ詳細設定を開いてください。 + インストール先での配置 + %1$s の内容 + %1$s フォルダーとその内容 + 選択したフォルダーの内容を統合 + 選択した各フォルダー名を維持 + （推奨） + 結果: %1$s + Data/Data のようにフォルダー名が重複します。Mod が追加フォルダーを必要とする場合を除き、内容を選択してください。 + この配置を選んだ理由 + 配置の詳細を隠す + この配置を使用 + %1$d 個のファイルを解決 + 推奨マッピングを維持してカスタム配置に切り替え、未解決ファイルを安全に割り当てます。 + すべてのファイルを確認（%1$d） + プラン内の全ファイル + 元、配置先、理由を検索 + すべて（%1$d） + フィルターに一致するファイルはありません + 以前: %1$s + 配置先: %1$s + 配置先を参照 + 配置先の内容 + 追加 + 置換 + 移動 + 削除 + 無視 + ブロック + 変更なし diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index cedcf5c340..d7c17d19f6 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -1917,8 +1917,6 @@ 모드의 폴더/파일 대상 폴더 설치 방법 - 선택 항목에 대한 폴더 생성 - On: 선택한 폴더가 대상에 설치됩니다. 끄기: 해당 내용만 여기에 배치됩니다. 수동 경로 숨기기 수동 경로 모드의 폴더/파일 @@ -2380,4 +2378,54 @@ 이전 배포 복원 중… 이전 배포를 복원했습니다. 이전 배포를 복원하지 못했습니다(문제 %1$d개) + 이 폴더 검색 + 숨김 파일 및 폴더 표시 + 새 폴더 + 현재 대상 안에 사용할 폴더 이름을 선택하세요. + 폴더 이름 + 아직 변경되지 않습니다. 검토한 계획을 적용할 때만 폴더가 생성됩니다. + 폴더 사용 + 생성 예정 + 일치하는 파일 또는 폴더 없음 + 추가 예정 + 교체 예정 + 백업 예정 + 계획 충돌 + 이 모드가 관리함 + %1$s에서 관리함 + 배포 후 변경됨 + 게임 또는 관리되지 않는 파일 + 파일을 받을 폴더 + 고급 배치 + 고급 배치 숨기기 + 자동 배치를 권장합니다. 프리셋, 이전 레이아웃 또는 수동 매핑이 필요할 때만 고급 배치를 여세요. + 대상에 설치할 항목 + %1$s의 내용 + %1$s 폴더와 그 내용 + 선택한 폴더 내용 병합 + 선택한 각 폴더 이름 유지 + (권장) + 결과: %1$s + Data/Data처럼 폴더 이름이 반복됩니다. 모드에 추가 폴더가 필요한 경우가 아니면 내용을 선택하세요. + 이 배치를 선택한 이유 + 배치 세부 정보 숨기기 + 이 배치 사용 + 파일 %1$d개 해결 + 권장 매핑을 유지한 채 사용자 지정 배치로 전환하여 미해결 파일을 안전하게 할당합니다. + 모든 파일 검토 (%1$d) + 계획된 모든 파일 + 원본, 대상 또는 이유 검색 + 모두 (%1$d) + 필터와 일치하는 계획 파일 없음 + 이전: %1$s + 대상: %1$s + 대상 찾아보기 + 대상 내용 + 추가됨 + 교체됨 + 이동됨 + 제거됨 + 무시됨 + 차단됨 + 변경 없음 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 1efae11dfd..5240945422 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -1920,8 +1920,6 @@ Folder/plik z mod Folder docelowy Metoda instalacji - Utwórz folder dla zaznaczenia - Wł.: Wybrany folder zostanie zainstalowany w miejscu docelowym. Wyłączone: umieszczana jest tam tylko jego zawartość. Ukryj ścieżki ręczne Ścieżki ręczne Foldery/pliki z mod @@ -2389,4 +2387,54 @@ Przywracanie poprzedniego wdrożenia… Poprzednie wdrożenie zostało przywrócone. Nie udało się przywrócić poprzedniego wdrożenia (%1$d problem(y)) + Przeszukaj ten folder + Pokaż ukryte pliki i foldery + Nowy folder + Wybierz nazwę folderu w bieżącym miejscu docelowym. + Nazwa folderu + Nic nie zostanie jeszcze zmienione. Folder powstanie dopiero po zastosowaniu sprawdzonego planu. + Użyj folderu + Zostanie utworzony + Brak pasujących plików lub folderów + Zostanie dodany + Zostanie zastąpiony + Zostanie zapisany + Konflikt planu + Zarządzany przez ten mod + Zarządzany przez %1$s + Zmieniony od wdrożenia + Plik gry lub niezarządzany + Otrzyma pliki + Zaawansowane rozmieszczenie + Ukryj zaawansowane rozmieszczenie + Zalecane jest rozmieszczenie automatyczne. Opcje zaawansowane otwieraj tylko dla ustawień wstępnych, wcześniejszego układu lub ręcznego mapowania. + W miejscu docelowym zainstaluj + Zawartość %1$s + Folder %1$s i jego zawartość + Scal zawartość wybranych folderów + Zachowaj nazwę każdego wybranego folderu + (Zalecane) + Wynik: %1$s + Powstanie powtórzona nazwa folderu, np. Data/Data. Wybierz zawartość, chyba że mod wymaga dodatkowego folderu. + Dlaczego to rozmieszczenie? + Ukryj szczegóły rozmieszczenia + Użyj tego rozmieszczenia + Rozwiąż %1$d plików + Przełącza na rozmieszczenie niestandardowe z zachowaniem zalecanych mapowań, aby bezpiecznie przypisać nierozwiązane pliki. + Sprawdź wszystkie pliki (%1$d) + Wszystkie zaplanowane pliki + Szukaj źródła, celu lub powodu + Wszystkie (%1$d) + Żaden zaplanowany plik nie pasuje do filtra + Poprzednio: %1$s + Cel: %1$s + Przeglądaj cel + Zawartość celu + Dodane + Zastąpione + Przeniesione + Usunięte + Pominięte + Zablokowane + Bez zmian diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index dde9220709..2fb004499c 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -1790,8 +1790,6 @@ Pasta/arquivo do mod Pasta de destino Método de instalação - Crie uma pasta para a seleção - Ligado: A pasta selecionada é instalada no destino. Desligado: Somente seu conteúdo é colocado lá. Ocultar caminhos manuais Caminhos manuais Pastas/arquivos do mod @@ -2255,4 +2253,54 @@ Restaurando a implantação anterior… A implantação anterior foi restaurada. Não foi possível restaurar a implantação anterior (%1$d problema(s)) + Pesquisar nesta pasta + Mostrar arquivos e pastas ocultos + Nova pasta + Escolha um nome de pasta dentro do destino atual. + Nome da pasta + Nada foi alterado ainda. A pasta só será criada ao aplicar o plano revisado. + Usar pasta + Será criada + Nenhum arquivo ou pasta correspondente + Será adicionado + Será substituído + Terá backup + Conflito no plano + Gerenciado por este mod + Gerenciado por %1$s + Alterado desde a implantação + Arquivo do jogo ou não gerenciado + Receberá arquivos + Posicionamento avançado + Ocultar posicionamento avançado + O posicionamento automático é recomendado. Abra as opções avançadas apenas para predefinições, layouts anteriores ou mapeamento manual. + No destino, instalar + Conteúdo de %1$s + Pasta %1$s e seu conteúdo + Mesclar o conteúdo das pastas selecionadas + Manter o nome de cada pasta selecionada + (Recomendado) + Resultado: %1$s + Isso cria um nome de pasta repetido, como Data/Data. Escolha o conteúdo, a menos que o mod exija a pasta adicional. + Por que este posicionamento? + Ocultar detalhes do posicionamento + Usar este posicionamento + Resolver %1$d arquivos + Muda para o posicionamento personalizado preservando os mapeamentos recomendados para atribuir com segurança os arquivos não resolvidos. + Revisar todos os arquivos (%1$d) + Todos os arquivos planejados + Pesquisar origem, destino ou motivo + Todos (%1$d) + Nenhum arquivo planejado corresponde ao filtro + Anterior: %1$s + Destino: %1$s + Explorar destino + Conteúdo do destino + Adicionados + Substituídos + Movidos + Removidos + Ignorados + Bloqueados + Sem alterações diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 96502a4e49..fac15323b8 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -1922,8 +1922,6 @@ Dosar/fișier din mod Folder de destinație Metoda de instalare - Creați un folder pentru selecție - Activat: folderul selectat este instalat în destinație. Off: Doar conținutul său este plasat acolo. Ascunde căile manuale Căi manuale Foldere/fișiere din mod @@ -2389,4 +2387,54 @@ Se restaurează implementarea anterioară… Implementarea anterioară a fost restaurată. Implementarea anterioară nu a putut fi restaurată (%1$d problemă(e)) + Caută în acest folder + Afișează fișierele și folderele ascunse + Folder nou + Alege un nume de folder în destinația curentă. + Numele folderului + Încă nu se modifică nimic. Folderul va fi creat doar când se aplică planul verificat. + Folosește folderul + Va fi creat + Niciun fișier sau folder corespunzător + Va fi adăugat + Va fi înlocuit + Va avea copie de rezervă + Conflict în plan + Gestionat de acest mod + Gestionat de %1$s + Modificat după implementare + Fișier de joc sau negestionat + Va primi fișiere + Plasare avansată + Ascunde plasarea avansată + Se recomandă plasarea automată. Deschide opțiunile avansate doar pentru presetări, reutilizarea unui aspect sau mapare manuală. + La destinație, instalează + Conținutul din %1$s + Folderul %1$s și conținutul său + Îmbină conținutul folderelor selectate + Păstrează numele fiecărui folder selectat + (Recomandat) + Rezultat: %1$s + Aceasta creează un nume de folder repetat, precum Data/Data. Alege conținutul dacă modul nu necesită folderul suplimentar. + De ce această plasare? + Ascunde detaliile plasării + Folosește această plasare + Rezolvă %1$d fișiere + Trece la plasarea personalizată și păstrează mapările recomandate pentru atribuirea sigură a fișierelor nerezolvate. + Verifică toate fișierele (%1$d) + Toate fișierele planificate + Caută sursa, destinația sau motivul + Toate (%1$d) + Niciun fișier planificat nu corespunde filtrului + Anterior: %1$s + Destinație: %1$s + Răsfoiește destinația + Conținutul destinației + Adăugate + Înlocuite + Mutate + Eliminate + Ignorate + Blocate + Neschimbate diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 291640d0db..6a64accc55 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -1848,8 +1848,6 @@ https://gamenative.app Папка/файл из мода Папка назначения Способ установки - Создать папку для выбора - Вкл.: выбранная папка устанавливается в место назначения. Выкл.: туда помещается только его содержимое. Скрыть пути, заданные вручную Ручные пути Папки/файлы из мода @@ -2317,4 +2315,54 @@ https://gamenative.app Восстановление предыдущего развёртывания… Предыдущее развёртывание восстановлено. Не удалось восстановить предыдущее развёртывание (проблем: %1$d) + Поиск в этой папке + Показывать скрытые файлы и папки + Новая папка + Выберите имя папки в текущем месте назначения. + Имя папки + Пока ничего не изменяется. Папка будет создана только при применении проверенного плана. + Использовать папку + Будет создана + Нет подходящих файлов или папок + Будет добавлен + Будет заменён + Будет сохранён + Конфликт плана + Управляется этим модом + Управляется %1$s + Изменён после развёртывания + Файл игры или неуправляемый файл + Получит файлы + Расширенное размещение + Скрыть расширенное размещение + Рекомендуется автоматическое размещение. Открывайте расширенные настройки только для шаблонов, прежней схемы или ручного сопоставления. + В месте назначения установить + Содержимое %1$s + Папку %1$s и её содержимое + Объединить содержимое выбранных папок + Сохранить имя каждой выбранной папки + (Рекомендуется) + Результат: %1$s + Это создаст повторяющееся имя папки, например Data/Data. Выберите содержимое, если моду не нужна дополнительная папка. + Почему выбрано это размещение? + Скрыть сведения о размещении + Использовать это размещение + Разрешить файлы: %1$d + Переходит к пользовательскому размещению, сохраняя рекомендуемые сопоставления для безопасного назначения нерешённых файлов. + Проверить все файлы (%1$d) + Все запланированные файлы + Поиск источника, назначения или причины + Все (%1$d) + Нет запланированных файлов, соответствующих фильтру + Ранее: %1$s + Назначение: %1$s + Просмотреть назначение + Содержимое назначения + Добавлено + Заменено + Перемещено + Удалено + Игнорируется + Заблокировано + Без изменений diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index edcb0fa0fb..0b47cd7e60 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -1916,8 +1916,6 @@ Папка/файл із мод Папка призначення Спосіб встановлення - Створіть папку для вибору - Увімк.: вибрану папку встановлено в цільову папку. Вимкнено: там розміщується лише його вміст. Приховати ручні шляхи Ручні шляхи Папки/файли з мод @@ -2385,4 +2383,54 @@ Відновлення попереднього розгортання… Попереднє розгортання відновлено. Не вдалося відновити попереднє розгортання (проблем: %1$d) + Пошук у цій папці + Показувати приховані файли та папки + Нова папка + Виберіть назву папки в поточному місці призначення. + Назва папки + Поки нічого не змінюється. Папку буде створено лише під час застосування перевіреного плану. + Використати папку + Буде створено + Немає відповідних файлів або папок + Буде додано + Буде замінено + Буде створено резервну копію + Конфлікт плану + Керується цим модом + Керується %1$s + Змінено після розгортання + Файл гри або некерований файл + Отримає файли + Розширене розміщення + Сховати розширене розміщення + Рекомендується автоматичне розміщення. Відкривайте розширені параметри лише для шаблонів, попередньої схеми або ручного зіставлення. + У місці призначення встановити + Вміст %1$s + Папку %1$s та її вміст + Об’єднати вміст вибраних папок + Зберегти назву кожної вибраної папки + (Рекомендовано) + Результат: %1$s + Це створить повторювану назву папки, наприклад Data/Data. Виберіть вміст, якщо мод не вимагає додаткової папки. + Чому це розміщення? + Сховати подробиці розміщення + Використати це розміщення + Вирішити файли: %1$d + Переходить до власного розміщення, зберігаючи рекомендовані зіставлення для безпечного призначення невирішених файлів. + Перевірити всі файли (%1$d) + Усі заплановані файли + Пошук джерела, призначення або причини + Усі (%1$d) + Немає запланованих файлів, що відповідають фільтру + Раніше: %1$s + Призначення: %1$s + Переглянути призначення + Вміст призначення + Додано + Замінено + Переміщено + Видалено + Ігнорується + Заблоковано + Без змін diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 08ff1f8ca2..8af1d341a9 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -1937,8 +1937,6 @@ 模组中的文件夹/文件 目标文件夹 安装方法 - 为选择创建一个文件夹 - 开：所选文件夹安装到目标位置。关：仅放置其内容。 隐藏手动路径 手动路径 模组中的文件夹/文件 @@ -2400,4 +2398,54 @@ 正在恢复上一次部署… 已恢复上一次部署。 无法恢复上一次部署（%1$d 个问题） + 搜索此文件夹 + 显示隐藏文件和文件夹 + 新建文件夹 + 在当前目标位置中选择文件夹名称。 + 文件夹名称 + 目前不会更改任何内容。仅在应用已审核的计划时创建文件夹。 + 使用文件夹 + 将创建 + 没有匹配的文件或文件夹 + 将添加 + 将替换 + 将备份 + 计划冲突 + 由此模组管理 + 由 %1$s 管理 + 部署后已更改 + 游戏文件或未管理文件 + 将接收文件 + 高级放置 + 隐藏高级放置 + 建议使用自动放置。仅在选择预设、复用旧布局或手动映射文件时打开高级选项。 + 在目标位置安装 + %1$s 的内容 + %1$s 文件夹及其内容 + 合并所选文件夹的内容 + 保留每个所选文件夹的名称 + （推荐） + 结果：%1$s + 这会产生 Data/Data 之类的重复文件夹名称。除非模组明确需要额外文件夹，否则请选择内容。 + 为何选择此放置方式？ + 隐藏放置详情 + 使用此放置方式 + 解决 %1$d 个文件 + 切换到自定义放置并保留推荐映射，以便安全分配未解决的文件。 + 审核所有文件（%1$d） + 所有计划文件 + 搜索来源、目标或原因 + 全部（%1$d） + 没有计划文件与此筛选条件匹配 + 先前：%1$s + 目标：%1$s + 浏览目标 + 目标内容 + 已添加 + 已替换 + 已移动 + 已移除 + 已忽略 + 已阻止 + 未更改 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index f41f2fcb01..253399eab7 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -1928,8 +1928,6 @@ 模組中的資料夾/檔案 目標資料夾 安裝方法 - 為選擇建立一個資料夾 - 開：所選資料夾安裝到目標位置。關：僅放置其內容。 隱藏手動路徑 手動路徑 模組中的資料夾/檔案 @@ -2391,4 +2389,54 @@ 正在還原上一次部署… 已還原上一次部署。 無法還原上一次部署（%1$d 個問題） + 搜尋此資料夾 + 顯示隱藏檔案和資料夾 + 新增資料夾 + 在目前目標位置中選擇資料夾名稱。 + 資料夾名稱 + 目前不會變更任何內容。只有套用已檢閱的計畫時才會建立資料夾。 + 使用資料夾 + 將建立 + 沒有相符的檔案或資料夾 + 將新增 + 將取代 + 將備份 + 計畫衝突 + 由此模組管理 + 由 %1$s 管理 + 部署後已變更 + 遊戲檔案或未管理檔案 + 將接收檔案 + 進階放置 + 隱藏進階放置 + 建議使用自動放置。只有選擇預設、重用舊配置或手動對應檔案時才開啟進階選項。 + 在目標位置安裝 + %1$s 的內容 + %1$s 資料夾及其內容 + 合併所選資料夾的內容 + 保留每個所選資料夾的名稱 + （建議） + 結果：%1$s + 這會產生 Data/Data 之類的重複資料夾名稱。除非模組明確需要額外資料夾，否則請選擇內容。 + 為何選擇此放置方式？ + 隱藏放置詳細資料 + 使用此放置方式 + 解決 %1$d 個檔案 + 切換到自訂放置並保留建議對應，以便安全指派未解決的檔案。 + 檢閱所有檔案（%1$d） + 所有計畫檔案 + 搜尋來源、目標或原因 + 全部（%1$d） + 沒有計畫檔案符合此篩選條件 + 先前：%1$s + 目標：%1$s + 瀏覽目標 + 目標內容 + 已新增 + 已取代 + 已移動 + 已移除 + 已忽略 + 已阻止 + 未變更 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 1e5a0c8adc..db6ba96f33 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1977,8 +1977,6 @@ Game or unmanaged file Will receive files Install method - Create a folder for the selection - On: The selected folder is installed into the destination. Off: Only its contents are placed there. Advanced placement Hide advanced placement Automatic placement is recommended. Open advanced placement only to choose presets, reuse an earlier layout, or map files yourself. From 5130fbef782147ab8a1ceeb17baf37d3ccd51bbe Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:30:35 -0500 Subject: [PATCH 34/60] feat: add destination breadcrumbs --- .../dialog/NexusModsPlacementSections.kt | 58 ++++++++++++++----- .../dialog/PlacementWorkspaceModels.kt | 1 + 2 files changed, 43 insertions(+), 16 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 058d9ac1af..0995a1a5de 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -1491,15 +1491,6 @@ private fun ContainerDestinationPickerDialog( } } - val breadcrumb = remember(currentDir, currentRoot) { - val dir = currentDir ?: return@remember "" - val root = currentRoot ?: return@remember dir.name - val relative = runCatching { - dir.canonicalFile.relativeToOrNull(root.dir.canonicalFile)?.path.orEmpty() - }.getOrDefault("") - if (relative.isBlank()) root.label else "${root.label} / ${relative.replace(File.separatorChar, '/')}" - } - Dialog( onDismissRequest = onDismiss, properties = DialogProperties(usePlatformDefaultWidth = false), @@ -1517,13 +1508,19 @@ private fun ContainerDestinationPickerDialog( stringResource(if (readOnly) R.string.nexus_destination_contents else R.string.nexus_destination_folder), style = MaterialTheme.typography.headlineSmall, ) - Text( - text = if (currentDir == null) stringResource(R.string.nexus_choose_game_container_location) else breadcrumb, - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - maxLines = 1, - overflow = TextOverflow.Ellipsis, - ) + if (currentDir == null || currentRoot == null) { + Text( + text = stringResource(R.string.nexus_choose_game_container_location), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else { + DestinationBreadcrumb(currentRoot, currentDir!!) { destination -> + currentDir = destination + selectedDestination = destination + query = "" + } + } if (roots.isNotEmpty()) { Row( modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), @@ -1783,6 +1780,35 @@ private fun ContainerDestinationPickerDialog( } } +@Composable +private fun DestinationBreadcrumb( + root: ResolvedModTargetRoot, + directory: File, + onNavigate: (File) -> Unit, +) { + val relativeSegments = remember(root, directory) { + runCatching { + directory.canonicalFile.relativeTo(root.dir.canonicalFile).path + .replace(File.separatorChar, '/') + .split('/') + .filter(String::isNotBlank) + }.getOrDefault(emptyList()) + } + Row( + modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), + verticalAlignment = Alignment.CenterVertically, + ) { + TextButton(onClick = { onNavigate(root.dir) }) { Text(root.label, maxLines = 1) } + var destination = root.dir + relativeSegments.forEach { segment -> + destination = File(destination, segment) + val segmentDestination = destination + Text("/", color = MaterialTheme.colorScheme.onSurfaceVariant) + TextButton(onClick = { onNavigate(segmentDestination) }) { Text(segment, maxLines = 1) } + } + } +} + @Composable private fun DestinationEntryMetadata( entry: DestinationBrowserEntry, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index 302a6d15e5..e878f5856b 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -89,6 +89,7 @@ internal fun destinationBrowserEntries( val normalizedQuery = query.trim().lowercase(Locale.ROOT) val children = directory.listFiles().orEmpty() .asSequence() + .filter { it.isInsideOrEqual(root.dir) } .filter { showHidden || !it.name.startsWith('.') } .filter { normalizedQuery.isBlank() || normalizedQuery in it.name.lowercase(Locale.ROOT) } .map { child -> From d1bb7bc02924ae987c003d8f0dbaa6029d4aec83 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:35:21 -0500 Subject: [PATCH 35/60] style: align placement compose parameters --- .../ui/component/dialog/NexusModsPlacementSections.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 0995a1a5de..0980ed51f9 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -859,9 +859,9 @@ private fun PlacementChoiceSelector( private fun PlacementChoiceButton( text: String, selected: Boolean, - enabled: Boolean = true, onClick: () -> Unit, modifier: Modifier = Modifier, + enabled: Boolean = true, ) { val content: @Composable () -> Unit = { Text(text, maxLines = 1, overflow = TextOverflow.Ellipsis) From cc70fb54b1f56c8b2dcbc201b8c18fd3ede1164f Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sun, 23 Aug 2026 22:36:20 -0500 Subject: [PATCH 36/60] fix: refresh placement ownership after apply --- .../app/gamenative/ui/component/dialog/NexusModsDialog.kt | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 6b2faa0fbb..97d81dfc03 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -3177,6 +3177,14 @@ fun NexusModsDialog( } applied } + if (selectedInstall?.installId == install.installId) { + val ownership = withContext(Dispatchers.IO) { + val root = NexusModManager.cacheRoot(context, install.appId) + ModOwnershipStore.read(root, install.installId) to ModOwnershipStore.readPrevious(root, install.installId) + } + selectedOwnership = ownership.first + selectedPreviousOwnership = ownership.second + } val message = if (result.errors.isEmpty()) { lastPlacementDrafts = recipes.map { it.toDraft() } val cleanupSuffix = if (result.warnings.isNotEmpty()) { From 29da690424ddc3b6e6d5b47bc44758e28b721236 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Mon, 24 Aug 2026 00:01:13 -0500 Subject: [PATCH 37/60] fix: make placement workspace responsive --- .../dialog/NexusModsPlacementSections.kt | 237 +++++++++++++----- .../dialog/PlacementWorkspaceModels.kt | 28 +++ app/src/main/res/values-da/strings.xml | 3 + app/src/main/res/values-de/strings.xml | 3 + app/src/main/res/values-es/strings.xml | 3 + app/src/main/res/values-fr/strings.xml | 3 + app/src/main/res/values-it/strings.xml | 3 + app/src/main/res/values-ja/strings.xml | 3 + app/src/main/res/values-ko/strings.xml | 3 + app/src/main/res/values-pl/strings.xml | 3 + app/src/main/res/values-pt-rBR/strings.xml | 3 + app/src/main/res/values-ro/strings.xml | 3 + app/src/main/res/values-ru/strings.xml | 3 + app/src/main/res/values-uk/strings.xml | 3 + app/src/main/res/values-zh-rCN/strings.xml | 3 + app/src/main/res/values-zh-rTW/strings.xml | 3 + app/src/main/res/values/strings.xml | 3 + .../dialog/PlacementWorkspaceModelsTest.kt | 9 + 18 files changed, 263 insertions(+), 56 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 0980ed51f9..f1250cc9fc 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -13,6 +13,7 @@ import androidx.compose.foundation.layout.Column import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxHeight import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding @@ -37,6 +38,8 @@ import androidx.compose.material.icons.filled.Save import androidx.compose.material.icons.filled.Settings import androidx.compose.material.icons.filled.SnippetFolder import androidx.compose.material.icons.filled.SportsEsports +import androidx.compose.material.icons.filled.Visibility +import androidx.compose.material.icons.filled.VisibilityOff import androidx.compose.material3.AlertDialog import androidx.compose.material3.Button import androidx.compose.material3.Checkbox @@ -63,6 +66,7 @@ import androidx.compose.ui.graphics.vector.ImageVector import androidx.compose.ui.res.stringResource import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.style.TextAlign import androidx.compose.ui.text.style.TextOverflow import androidx.compose.ui.unit.dp import androidx.compose.ui.window.Dialog @@ -163,16 +167,27 @@ internal fun PlacementSection( var showArchiveBrowser by remember(install.installId, entries) { mutableStateOf(false) } var showFomodWizard by remember(install.installId, fomodInstaller) { mutableStateOf(false) } var showAdvancedPlacement by remember(install.installId) { mutableStateOf(placementChoice != PlacementChoice.AUTOMATIC) } + var customDraftPage by remember(install.installId) { mutableStateOf(0) } + val visibleDraftPage = remember(drafts.size, customDraftPage) { + placementDraftPage(drafts.size, customDraftPage) + } LaunchedEffect(placementChoice) { if (placementChoice != PlacementChoice.AUTOMATIC) showAdvancedPlacement = true } + LaunchedEffect(visibleDraftPage.pageIndex) { + if (customDraftPage != visibleDraftPage.pageIndex) customDraftPage = visibleDraftPage.pageIndex + } val destinationsValid = drafts.all { draft -> roots.any { it.type.name == draft.targetRoot } } - val automaticPlan = automaticPlacement.recommended?.plan - ?.let(PlacementRiskPolicy::enforce) - ?.withRiskApproval(riskyAutomaticPlanApproved) - val configuredPlan = reviewedPlan - ?.let(PlacementRiskPolicy::enforce) - ?.withRiskApproval(riskyAutomaticPlanApproved) + val automaticPlan = remember(automaticPlacement.recommended?.plan, riskyAutomaticPlanApproved) { + automaticPlacement.recommended?.plan + ?.let(PlacementRiskPolicy::enforce) + ?.withRiskApproval(riskyAutomaticPlanApproved) + } + val configuredPlan = remember(reviewedPlan, riskyAutomaticPlanApproved) { + reviewedPlan + ?.let(PlacementRiskPolicy::enforce) + ?.withRiskApproval(riskyAutomaticPlanApproved) + } val visiblePlan = if (placementChoice == PlacementChoice.AUTOMATIC) automaticPlan else configuredPlan val reconfigurationDiff = remember(previousOwnership, visiblePlan) { visiblePlan?.takeIf { previousOwnership != null }?.let { ModOwnershipPlanDiffer.compare(previousOwnership, it) } @@ -390,7 +405,16 @@ internal fun PlacementSection( ) } } else { - drafts.forEachIndexed { index, draft -> + if (visibleDraftPage.pageCount > 1) { + PlacementDraftPager( + page = visibleDraftPage, + totalRules = drafts.size, + onPrevious = { customDraftPage-- }, + onNext = { customDraftPage++ }, + ) + } + (visibleDraftPage.startIndex until visibleDraftPage.endIndexExclusive).forEach { index -> + val draft = drafts[index] PlacementDraftEditor( index = index, draft = draft, @@ -514,6 +538,39 @@ internal fun PlacementSection( } } +@Composable +private fun PlacementDraftPager( + page: PlacementDraftPage, + totalRules: Int, + onPrevious: () -> Unit, + onNext: () -> Unit, +) { + Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { + Row( + modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + IconButton(onClick = onPrevious, enabled = page.pageIndex > 0) { + Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = stringResource(R.string.nexus_previous_rule_page)) + } + Text( + stringResource( + R.string.nexus_placement_rule_range, + page.startIndex + 1, + page.endIndexExclusive, + totalRules, + ), + modifier = Modifier.weight(1f), + textAlign = TextAlign.Center, + style = MaterialTheme.typography.labelLarge, + ) + IconButton(onClick = onNext, enabled = page.pageIndex < page.pageCount - 1) { + Icon(Icons.AutoMirrored.Filled.ArrowForward, contentDescription = stringResource(R.string.nexus_next_rule_page)) + } + } + } +} + @Composable private fun PlacementPlanReview( automaticPlacement: AutomaticPlacementResult?, @@ -532,7 +589,13 @@ private fun PlacementPlanReview( var showWhy by remember(plan.digest) { mutableStateOf(false) } var showAllFiles by remember(plan.digest) { mutableStateOf(false) } var browseTarget by remember(plan.digest) { mutableStateOf(null) } - val rows = remember(plan, diff, roots) { placementReviewRows(plan, diff, roots) } + var rows by remember(plan.digest, diff, roots) { mutableStateOf>(emptyList()) } + var rowsLoading by remember(plan.digest, diff, roots) { mutableStateOf(true) } + LaunchedEffect(plan, diff, roots) { + rowsLoading = true + rows = withContext(Dispatchers.IO) { placementReviewRows(plan, diff, roots) } + rowsLoading = false + } Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { Text(stringResource(R.string.nexus_plan_review_title), style = MaterialTheme.typography.labelLarge) @@ -623,8 +686,12 @@ private fun PlacementPlanReview( Text("\u2022 $warning", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.tertiary) } Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { - OutlinedButton(onClick = { showAllFiles = true }) { - Text(stringResource(R.string.nexus_review_all_files, rows.size)) + OutlinedButton(onClick = { showAllFiles = true }, enabled = !rowsLoading) { + if (rowsLoading) { + CircularProgressIndicator(modifier = Modifier.size(16.dp), strokeWidth = 2.dp) + Spacer(Modifier.width(6.dp)) + } + Text(stringResource(R.string.nexus_review_all_files, rows.size.takeUnless { rowsLoading } ?: plan.files.size)) } TextButton(onClick = onExport) { Text(stringResource(R.string.nexus_plan_export)) @@ -993,11 +1060,11 @@ private fun PlacementDraftEditor( val layout = remember(draft.sourceSubpath, draft.targetRelativePath, draft.includeSourceDirectory, entries) { placementLayoutModel(draft, entries) } - val recommendedKeepFolder = remember(draft.sourceSubpath, draft.targetRelativePath, entries) { - AutomaticPlacementPlanner.inferIncludeSourceDirectory( - ModPlacementSources.decode(draft.sourceSubpath), - entries, - draft.targetRelativePath, + val recommendedKeepFolder = remember(draft.sourceSubpath, draft.targetRelativePath, entries, layout.visible) { + layout.visible && AutomaticPlacementPlanner.inferIncludeSourceDirectory( + selectedPaths = ModPlacementSources.decode(draft.sourceSubpath), + entries = entries, + targetRelativePath = draft.targetRelativePath, ) } @@ -1495,18 +1562,23 @@ private fun ContainerDestinationPickerDialog( onDismissRequest = onDismiss, properties = DialogProperties(usePlatformDefaultWidth = false), ) { - Surface( - modifier = Modifier - .fillMaxWidth(0.94f) - .height(540.dp), - shape = RoundedCornerShape(12.dp), - color = MaterialTheme.colorScheme.surface, - ) { - Column(modifier = Modifier.fillMaxSize()) { - Column(Modifier.padding(20.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) { + BoxWithConstraints(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) { + val compactHeight = maxHeight < 600.dp + Surface( + modifier = Modifier + .fillMaxWidth(0.94f) + .fillMaxHeight(if (compactHeight) 0.98f else 0.94f), + shape = RoundedCornerShape(12.dp), + color = MaterialTheme.colorScheme.surface, + ) { + Column(modifier = Modifier.fillMaxSize()) { + Column( + Modifier.padding(if (compactHeight) 12.dp else 20.dp), + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { Text( stringResource(if (readOnly) R.string.nexus_destination_contents else R.string.nexus_destination_folder), - style = MaterialTheme.typography.headlineSmall, + style = if (compactHeight) MaterialTheme.typography.titleLarge else MaterialTheme.typography.headlineSmall, ) if (currentDir == null || currentRoot == null) { Text( @@ -1543,7 +1615,7 @@ private fun ContainerDestinationPickerDialog( } if (currentDir != null) { - Surface(modifier = Modifier.fillMaxWidth(), color = MaterialTheme.colorScheme.surfaceVariant) { + if (!compactHeight) Surface(modifier = Modifier.fillMaxWidth(), color = MaterialTheme.colorScheme.surfaceVariant) { Row( modifier = Modifier .clickable { @@ -1566,33 +1638,18 @@ private fun ContainerDestinationPickerDialog( } } HorizontalDivider() - Column( - modifier = Modifier.padding(horizontal = 20.dp, vertical = 10.dp), - verticalArrangement = Arrangement.spacedBy(6.dp), - ) { - NoExtractOutlinedTextField( - value = query, - onValueChange = { query = it }, - modifier = Modifier.fillMaxWidth(), - label = { Text(stringResource(R.string.nexus_search_destination)) }, - leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) }, - singleLine = true, - ) - Row(verticalAlignment = Alignment.CenterVertically) { - Checkbox(checked = showHidden, onCheckedChange = { showHidden = it }) - Text(stringResource(R.string.nexus_show_hidden_files), modifier = Modifier.weight(1f)) - if (!readOnly) { - TextButton(onClick = { - newFolderName = "" - showNewFolderDialog = true - }) { - Icon(Icons.Default.CreateNewFolder, contentDescription = null, modifier = Modifier.size(18.dp)) - Spacer(Modifier.width(6.dp)) - Text(stringResource(R.string.nexus_new_destination_folder)) - } - } - } - } + DestinationBrowserTools( + compact = compactHeight, + query = query, + onQueryChange = { query = it }, + showHidden = showHidden, + onShowHiddenChange = { showHidden = it }, + readOnly = readOnly, + onNewFolder = { + newFolderName = "" + showNewFolderDialog = true + }, + ) HorizontalDivider() } @@ -1608,7 +1665,7 @@ private fun ContainerDestinationPickerDialog( selectedDestination = root.dir query = "" } - .padding(horizontal = 20.dp, vertical = 12.dp), + .padding(horizontal = 20.dp, vertical = if (compactHeight) 8.dp else 12.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp), ) { @@ -1665,7 +1722,7 @@ private fun ContainerDestinationPickerDialog( selectedDestination = entry.file query = "" } - .padding(horizontal = 20.dp, vertical = 12.dp), + .padding(horizontal = 20.dp, vertical = if (compactHeight) 8.dp else 12.dp), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(12.dp), ) { @@ -1700,7 +1757,7 @@ private fun ContainerDestinationPickerDialog( Row( modifier = Modifier .fillMaxWidth() - .padding(horizontal = 20.dp, vertical = 12.dp), + .padding(horizontal = 20.dp, vertical = if (compactHeight) 6.dp else 12.dp), horizontalArrangement = Arrangement.End, verticalAlignment = Alignment.CenterVertically, ) { @@ -1740,6 +1797,7 @@ private fun ContainerDestinationPickerDialog( } } } + } if (showNewFolderDialog && !readOnly) { val validName = validVirtualDestinationFolderName(newFolderName) @@ -1780,6 +1838,73 @@ private fun ContainerDestinationPickerDialog( } } +@Composable +private fun DestinationBrowserTools( + compact: Boolean, + query: String, + onQueryChange: (String) -> Unit, + showHidden: Boolean, + onShowHiddenChange: (Boolean) -> Unit, + readOnly: Boolean, + onNewFolder: () -> Unit, +) { + if (compact) { + Row( + modifier = Modifier.fillMaxWidth().padding(horizontal = 12.dp, vertical = 4.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + NoExtractOutlinedTextField( + value = query, + onValueChange = onQueryChange, + modifier = Modifier.weight(1f), + label = { Text(stringResource(R.string.nexus_search_destination)) }, + leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) }, + singleLine = true, + ) + IconButton(onClick = { onShowHiddenChange(!showHidden) }) { + Icon( + if (showHidden) Icons.Default.Visibility else Icons.Default.VisibilityOff, + contentDescription = stringResource(R.string.nexus_show_hidden_files), + tint = if (showHidden) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + if (!readOnly) { + IconButton(onClick = onNewFolder) { + Icon( + Icons.Default.CreateNewFolder, + contentDescription = stringResource(R.string.nexus_new_destination_folder), + ) + } + } + } + } else { + Column( + modifier = Modifier.padding(horizontal = 20.dp, vertical = 10.dp), + verticalArrangement = Arrangement.spacedBy(6.dp), + ) { + NoExtractOutlinedTextField( + value = query, + onValueChange = onQueryChange, + modifier = Modifier.fillMaxWidth(), + label = { Text(stringResource(R.string.nexus_search_destination)) }, + leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) }, + singleLine = true, + ) + Row(verticalAlignment = Alignment.CenterVertically) { + Checkbox(checked = showHidden, onCheckedChange = onShowHiddenChange) + Text(stringResource(R.string.nexus_show_hidden_files), modifier = Modifier.weight(1f)) + if (!readOnly) { + TextButton(onClick = onNewFolder) { + Icon(Icons.Default.CreateNewFolder, contentDescription = null, modifier = Modifier.size(18.dp)) + Spacer(Modifier.width(6.dp)) + Text(stringResource(R.string.nexus_new_destination_folder)) + } + } + } + } + } +} + @Composable private fun DestinationBreadcrumb( root: ResolvedModTargetRoot, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index e878f5856b..f64bc15e5a 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -22,10 +22,38 @@ internal data class PlacementLayoutModel( val duplicateFolderWarning: Boolean, ) +internal data class PlacementDraftPage( + val pageIndex: Int, + val pageCount: Int, + val startIndex: Int, + val endIndexExclusive: Int, +) + +internal fun placementDraftPage( + totalRules: Int, + requestedPage: Int, + pageSize: Int = 20, +): PlacementDraftPage { + require(pageSize > 0) + val safeTotal = totalRules.coerceAtLeast(0) + val pageCount = maxOf(1, (safeTotal + pageSize - 1) / pageSize) + val pageIndex = requestedPage.coerceIn(0, pageCount - 1) + val startIndex = (pageIndex * pageSize).coerceAtMost(safeTotal) + return PlacementDraftPage( + pageIndex = pageIndex, + pageCount = pageCount, + startIndex = startIndex, + endIndexExclusive = (startIndex + pageSize).coerceAtMost(safeTotal), + ) +} + internal fun placementLayoutModel( draft: RecipeDraft, entries: List, ): PlacementLayoutModel { + if (draft.targetFileName.isNotBlank()) { + return PlacementLayoutModel(false, false, emptyList(), "", false) + } val sources = ModPlacementSources.decode(draft.sourceSubpath).filter(String::isNotBlank) val folders = sources.filter { source -> entries.any { entry -> diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 9eaaf1f88a..0a6d3149eb 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2303,4 +2303,7 @@ Ignoreret Blokeret Uændret + Forrige side med placeringsregler + Næste side med placeringsregler + Placeringsregler %1$d–%2$d af %3$d diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 2aa99a61b1..4d94d37a00 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2373,4 +2373,7 @@ Ignoriert Blockiert Unverändert + Vorherige Seite mit Platzierungsregeln + Nächste Seite mit Platzierungsregeln + Platzierungsregeln %1$d–%2$d von %3$d diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index d278d8c1a1..37f37755a6 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2431,4 +2431,7 @@ Ignorados Bloqueados Sin cambios + Página anterior de reglas de ubicación + Página siguiente de reglas de ubicación + Reglas de ubicación %1$d–%2$d de %3$d diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 21724591b8..3efc09e35f 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2433,4 +2433,7 @@ Ignorés Bloqués Inchangés + Page précédente des règles de placement + Page suivante des règles de placement + Règles de placement %1$d–%2$d sur %3$d diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 98eeb0fffa..25638fb7f7 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2424,4 +2424,7 @@ Ignorati Bloccati Invariati + Pagina precedente delle regole di posizionamento + Pagina successiva delle regole di posizionamento + Regole di posizionamento %1$d–%2$d di %3$d diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index c4e714f0ec..316e4bab93 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2387,4 +2387,7 @@ 無視 ブロック 変更なし + 前の配置ルールページ + 次の配置ルールページ + 配置ルール %1$d～%2$d / %3$d diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index d7c17d19f6..5f75b9ae28 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2428,4 +2428,7 @@ 무시됨 차단됨 변경 없음 + 이전 배치 규칙 페이지 + 다음 배치 규칙 페이지 + 배치 규칙 %1$d~%2$d / %3$d diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 5240945422..1774bb9405 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2437,4 +2437,7 @@ Pominięte Zablokowane Bez zmian + Poprzednia strona reguł umieszczania + Następna strona reguł umieszczania + Reguły umieszczania %1$d–%2$d z %3$d diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 2fb004499c..8b3643d622 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2303,4 +2303,7 @@ Ignorados Bloqueados Sem alterações + Página anterior de regras de posicionamento + Próxima página de regras de posicionamento + Regras de posicionamento %1$d–%2$d de %3$d diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index fac15323b8..bdd9922db5 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2437,4 +2437,7 @@ Ignorate Blocate Neschimbate + Pagina anterioară cu reguli de plasare + Pagina următoare cu reguli de plasare + Reguli de plasare %1$d–%2$d din %3$d diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 6a64accc55..90655ecf78 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2365,4 +2365,7 @@ https://gamenative.app Игнорируется Заблокировано Без изменений + Предыдущая страница правил размещения + Следующая страница правил размещения + Правила размещения %1$d–%2$d из %3$d diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 0b47cd7e60..36c4f3d4e9 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2433,4 +2433,7 @@ Ігнорується Заблоковано Без змін + Попередня сторінка правил розміщення + Наступна сторінка правил розміщення + Правила розміщення %1$d–%2$d із %3$d diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 8af1d341a9..2bffe6b840 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2448,4 +2448,7 @@ 已忽略 已阻止 未更改 + 上一页放置规则 + 下一页放置规则 + 放置规则 %1$d–%2$d，共 %3$d 条 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 253399eab7..2079c42d2b 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2439,4 +2439,7 @@ 已忽略 已阻止 未變更 + 上一頁放置規則 + 下一頁放置規則 + 放置規則 %1$d–%2$d，共 %3$d 條 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index db6ba96f33..d7244fa149 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2434,4 +2434,7 @@ Conservative AdjustsGradual gradually with a focus on stability VR Refresh Rate + Previous placement-rule page + Next placement-rule page + Placement rules %1$d–%2$d of %3$d diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt index 1f10ccc226..52a534d44d 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt @@ -33,6 +33,15 @@ class PlacementWorkspaceModelsTest { assertFalse(placementLayoutModel(RecipeDraft(), entries).visible) assertFalse(placementLayoutModel(RecipeDraft(sourceSubpath = "readme.txt"), entries).visible) + assertFalse(placementLayoutModel(RecipeDraft(sourceSubpath = "Data", targetFileName = "file.txt"), entries).visible) + } + + @Test + fun placementDraftPage_boundsLargeRuleSets() { + assertEquals(0 until 20, placementDraftPage(6_654, 0).let { it.startIndex until it.endIndexExclusive }) + val last = placementDraftPage(6_654, Int.MAX_VALUE) + assertEquals(332, last.pageIndex) + assertEquals(6_640 until 6_654, last.startIndex until last.endIndexExclusive) } @Test From c34d0b888133624b8342f11f88d8b19fdfea36bd Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Mon, 24 Aug 2026 00:01:22 -0500 Subject: [PATCH 38/60] fix: harden large automatic and FOMOD placement --- .../mods/AutomaticPlacementPlanner.kt | 10 ++- .../gamenative/mods/FomodInstallPlanner.kt | 41 ++++++--- .../app/gamenative/mods/ModArchiveIndex.kt | 75 ++++++++++++----- .../ui/component/dialog/NexusModsDialog.kt | 8 +- .../dialog/NexusModsFomodSections.kt | 84 ++++++++++++++----- .../mods/AutomaticPlacementPlannerTest.kt | 23 +++++ .../mods/ModArchiveIndexPerformanceTest.kt | 8 +- 7 files changed, 190 insertions(+), 59 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index 8d0e191c41..54aaff80c4 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -135,8 +135,14 @@ object AutomaticPlacementPlanner { entries: List, targetRelativePath: String, ): Boolean { - val index = ModArchiveIndex.build(entries) - val selectedDirectories = selectedPaths.filter(index::isDirectory) + val selectedDirectories = selectedPaths.filter { selectedPath -> + val selectedKey = normalizedArchiveKey(selectedPath) ?: return@filter false + val childPrefix = "$selectedKey/" + entries.any { entry -> + val entryKey = normalizedArchiveKey(entry.path) + entryKey == selectedKey && entry.directory || entryKey?.startsWith(childPrefix) == true + } + } if (selectedDirectories.isEmpty()) return false val targetName = normalizeArchiveDisplayPath(targetRelativePath).substringAfterLast('/') return selectedDirectories.any { source -> diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 968ccc2286..6552d241b7 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -94,12 +94,13 @@ object FomodPlanExpander { mode: String = ModPlacementMode.OVERWRITE_COPY.name, ): ModInstallPlan { val root = extractedRoot.canonicalFile + val sourceResolver = CaseInsensitiveSourceResolver(root) val expanded = mutableListOf() val missing = mutableListOf() evaluation.mappings.forEach { expected -> val sourcePath = joinPath(installer.basePath, expected.mapping.source) - val source = resolveCaseInsensitive(root, sourcePath) + val source = sourceResolver.resolve(sourcePath) when { source == null || !source.exists() -> missing += expected.missingFile(sourcePath) expected.mapping.directory && !source.isDirectory -> missing += expected.missingFile(sourcePath) @@ -198,18 +199,34 @@ object FomodPlanExpander { risk = PlacementRisk.REVIEW, ) - private fun resolveCaseInsensitive(root: File, relativePath: String): File? { - val segments = normalizedArchiveKey(relativePath)?.split('/').orEmpty() - val displaySegments = normalizeArchiveDisplayPath(relativePath).split('/').filter(String::isNotBlank) - if (segments.size != displaySegments.size) return null - var current = root - displaySegments.forEach { segment -> - val matches = current.listFiles().orEmpty().filter { it.name.equals(segment, ignoreCase = true) } - if (matches.size != 1) return null - current = matches.single() + private class CaseInsensitiveSourceResolver( + private val root: File, + ) { + private val directoryListings = mutableMapOf>>() + private val resolvedPaths = mutableMapOf() + + fun resolve(relativePath: String): File? { + val key = normalizedArchiveKey(relativePath) ?: return null + if (resolvedPaths.containsKey(key)) return resolvedPaths[key] + val displaySegments = normalizeArchiveDisplayPath(relativePath).split('/').filter(String::isNotBlank) + if (key.split('/').size != displaySegments.size) return null + var current = root + displaySegments.forEach { segment -> + val children = directoryListings.getOrPut(current.path) { + current.listFiles().orEmpty().groupBy { it.name.lowercase(Locale.ROOT) } + } + val matches = children[segment.lowercase(Locale.ROOT)].orEmpty() + if (matches.size != 1) { + resolvedPaths[key] = null + return null + } + current = matches.single() + } + val candidate = runCatching { current.canonicalFile }.getOrNull() + ?.takeIf { it == root || it.path.startsWith(root.path + File.separator) } + resolvedPaths[key] = candidate + return candidate } - val candidate = runCatching { current.canonicalFile }.getOrNull() ?: return null - return candidate.takeIf { it == root || it.path.startsWith(root.path + File.separator) } } private fun joinPath(vararg paths: String): String = diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index 45c938db74..bc23c3f8cf 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -59,6 +59,19 @@ data class ModArchiveIndex( companion object { private val semanticAnchors = ModPlacementRulePacks.archiveSemanticAnchors + private val managerMetadataDirectories = setOf("bashtags", "omod conversion data") + private val documentationDirectories = setOf("doc", "docs", "documentation", "manual", "manuals", "readmes") + private val documentationNamePrefixes = setOf( + "readme", + "changelog", + "changes", + "license", + "copying", + "credits", + "authors", + "install instructions", + "installation instructions", + ) fun build(entries: List): ModArchiveIndex { val indexedFiles = entries.asSequence() @@ -75,38 +88,48 @@ data class ModArchiveIndex( } .sortedWith(compareBy { it.normalizedKey }.thenBy { it.displayPath }) .toList() - val displayPaths = sortedMapOf() + val displayPaths = mutableMapOf() val counts = mutableMapOf() val bytes = mutableMapOf() val anchors = mutableMapOf>() entries.asSequence().filter { it.directory }.forEach { entry -> val display = normalizeArchiveDisplayPath(entry.path) val key = normalizedArchiveKey(display) - if (display.isNotBlank() && key != null) displayPaths.merge(key, display, ::stableDisplayPath) + if (display.isNotBlank() && key != null) displayPaths.rememberDisplayPath(key, display) } indexedFiles.forEach { file -> val displaySegments = file.displayPath.split('/') val keySegments = file.normalizedKey.split('/') val fileAnchors = keySegments.filterTo(mutableSetOf()) { it in semanticAnchors } - (1 until keySegments.size).forEach { count -> - val key = keySegments.take(count).joinToString("/") - val display = displaySegments.take(count).joinToString("/") - displayPaths.merge(key, display, ::stableDisplayPath) + val keyBuilder = StringBuilder() + val displayBuilder = StringBuilder() + (0 until keySegments.lastIndex).forEach { index -> + if (index > 0) { + keyBuilder.append('/') + displayBuilder.append('/') + } + keyBuilder.append(keySegments[index]) + displayBuilder.append(displaySegments[index]) + val key = keyBuilder.toString() + val display = displayBuilder.toString() + displayPaths.rememberDisplayPath(key, display) counts[key] = counts.getOrDefault(key, 0) + 1 bytes[key] = bytes.getOrDefault(key, 0L) + file.sizeBytes anchors.getOrPut(key, ::mutableSetOf).addAll(fileAnchors) } } - val nodes = displayPaths.map { (key, display) -> - ArchiveTreeNode( - displayPath = display, - normalizedKey = key, - descendantFileCount = counts.getOrDefault(key, 0), - descendantBytes = bytes.getOrDefault(key, 0L), - semanticAnchors = anchors[key].orEmpty(), - optionStyleWrapper = looksLikeOptionWrapper(display.substringAfterLast('/')), - ) - } + val nodes = displayPaths.entries + .sortedBy { it.key } + .map { (key, display) -> + ArchiveTreeNode( + displayPath = display, + normalizedKey = key, + descendantFileCount = counts.getOrDefault(key, 0), + descendantBytes = bytes.getOrDefault(key, 0L), + semanticAnchors = anchors[key].orEmpty(), + optionStyleWrapper = looksLikeOptionWrapper(display.substringAfterLast('/')), + ) + } return ModArchiveIndex( files = indexedFiles, nodes = nodes, @@ -118,19 +141,23 @@ data class ModArchiveIndex( private fun classify(path: String): ArchiveContentRole { val normalized = path.lowercase(Locale.ROOT) + val segments = normalized.split('/') val name = normalized.substringAfterLast('/') if (normalized.startsWith("__macosx/") || name in setOf(".ds_store", "thumbs.db", "desktop.ini")) { return ArchiveContentRole.METADATA } + if (segments.dropLast(1).any { it in managerMetadataDirectories }) { + return ArchiveContentRole.METADATA + } if (normalized.contains("/fomod/") || normalized.startsWith("fomod/")) { return ArchiveContentRole.INSTALLER_SUPPORT } if ( - name.startsWith("readme") || - name.startsWith("changelog") || - name.startsWith("license") || + segments.dropLast(1).any { it in documentationDirectories } || + documentationNamePrefixes.any(name::startsWith) || name.endsWith(".md") || - name.endsWith(".pdf") + name.endsWith(".pdf") || + segments.size == 1 && listOf(".htm", ".html", ".rtf").any(name::endsWith) ) { return ArchiveContentRole.DOCUMENTATION } @@ -148,6 +175,14 @@ data class ModArchiveIndex( private fun stableDisplayPath(left: String, right: String): String = minOf(left, right, compareBy { it.lowercase(Locale.ROOT) }.thenBy { it }) + + private fun MutableMap.rememberDisplayPath(key: String, display: String) { + val existing = this[key] + when { + existing == null -> this[key] = display + existing != display -> this[key] = stableDisplayPath(existing, display) + } + } } } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 97d81dfc03..ec887e161c 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -3099,7 +3099,13 @@ fun NexusModsDialog( ) { val install = selectedInstall val snapshot = recipeDrafts.toList() - if (install == null || !install.canPlaceFiles() || placementChoice == PlacementChoice.AUTOMATIC || snapshot.isEmpty()) { + if ( + install == null || + !install.canPlaceFiles() || + placementChoice == PlacementChoice.AUTOMATIC || + snapshot.isEmpty() || + reviewedPlacementPlan != null + ) { placementPlanPreview = null return@LaunchedEffect } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index cdd090f3fc..0f89977914 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -21,6 +21,7 @@ import androidx.compose.material.icons.automirrored.filled.ArrowForward import androidx.compose.material3.Button import androidx.compose.material3.Checkbox import androidx.compose.material3.AlertDialog +import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.HorizontalDivider import androidx.compose.material3.Icon import androidx.compose.material3.IconButton @@ -35,6 +36,7 @@ import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateMapOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope import androidx.compose.runtime.snapshotFlow import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment @@ -59,7 +61,11 @@ import app.gamenative.mods.effectiveType import com.skydoves.landscapist.ImageOptions import com.skydoves.landscapist.coil.CoilImage import java.io.File +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext @Composable internal fun FomodSummarySection( installer: FomodInstaller, @@ -113,6 +119,9 @@ internal fun FomodWizardDialog( ) { var previewImage by remember { mutableStateOf(null) } var pendingResult by remember { mutableStateOf(null) } + var generatingPlan by remember(installId, installer) { mutableStateOf(false) } + var generationError by remember(installId, installer) { mutableStateOf(null) } + val scope = rememberCoroutineScope() val selectedByGroup = remember(installer) { mutableStateMapOf>().apply { installer.steps.forEachIndexed { stepIndex, step -> @@ -204,6 +213,14 @@ internal fun FomodWizardDialog( overflow = TextOverflow.Ellipsis, ) } + generationError?.let { message -> + Text( + text = message, + modifier = Modifier.padding(horizontal = 20.dp, vertical = 8.dp), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } HorizontalDivider() Column( modifier = Modifier @@ -306,30 +323,57 @@ internal fun FomodWizardDialog( Button( onClick = { val selectedKeys = selectedByGroup.values.flatten().toSet() - val result = FomodRecipeGenerator.generateForPluginKeys( - installId = installId, - installer = installer, - selectedPluginKeys = selectedKeys, - targetRoot = baseDraft.targetRoot, - targetRelativePath = baseDraft.targetRelativePath.ifBlank { "Data" }, - mode = ModPlacementMode.OVERWRITE_COPY.name, - extractedRoot = extractedRoot, - environment = environment, - ) - pendingResult = PendingFomodResult( - drafts = result.recipes.map { it.toDraft() }, - plan = result.plan, - unsupportedCount = result.plan?.let { plan -> - plan.unresolvedCount + plan.blockingIssues.size - } ?: (result.unsupportedMappings.size + result.blockingIssues.size), - selectedOptions = fomodSelectedOptionLabels(installer, selectedKeys, fallbackStepNames, environment), - conditionalRuleCount = installer.conditionalFileInstalls.size, + val selectedOptions = fomodSelectedOptionLabels( + installer, + selectedKeys, + fallbackStepNames, + environment, ) + generationError = null + generatingPlan = true + scope.launch { + try { + val result = withContext(Dispatchers.IO) { + FomodRecipeGenerator.generateForPluginKeys( + installId = installId, + installer = installer, + selectedPluginKeys = selectedKeys, + targetRoot = baseDraft.targetRoot, + targetRelativePath = baseDraft.targetRelativePath.ifBlank { "Data" }, + mode = ModPlacementMode.OVERWRITE_COPY.name, + extractedRoot = extractedRoot, + environment = environment, + ) + } + if (selectedByGroup.values.flatten().toSet() == selectedKeys) { + pendingResult = PendingFomodResult( + drafts = result.recipes.map { it.toDraft() }, + plan = result.plan, + unsupportedCount = result.plan?.let { plan -> + plan.unresolvedCount + plan.blockingIssues.size + } ?: (result.unsupportedMappings.size + result.blockingIssues.size), + selectedOptions = selectedOptions, + conditionalRuleCount = installer.conditionalFileInstalls.size, + ) + } + } catch (error: Throwable) { + if (error is CancellationException) throw error + generationError = error.message ?: error.javaClass.simpleName + } finally { + generatingPlan = false + } + } }, - enabled = invalidGroups.isEmpty(), + enabled = invalidGroups.isEmpty() && !generatingPlan, modifier = Modifier.padding(start = 8.dp), ) { - Text(stringResource(R.string.nexus_fomod_use_choices)) + if (generatingPlan) { + CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp) + Spacer(Modifier.size(8.dp)) + Text(stringResource(R.string.nexus_building_install_plan)) + } else { + Text(stringResource(R.string.nexus_fomod_use_choices)) + } } } } diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index c0547b9b73..ac80f2ffef 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -20,6 +20,29 @@ class AutomaticPlacementPlannerTest { assertEquals(PlannedFileStatus.INTENTIONALLY_IGNORED, candidate.plan.files.single { it.sourceRelativePath == "readme.txt" }.status) } + @Test + fun bethesdaPlan_ignoresDocumentationAndManagerMetadataButKeepsRuntimeText() { + val plan = AutomaticPlacementPlanner.plan( + "Skyrim Special Edition", + archive( + "Data/Interface/Translations/example_english.txt", + "BashTags/Example.txt", + "Docs/Example Readme + Credits.html", + "credits.html", + ), + ).recommended!!.plan + + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals( + PlannedFileStatus.PLACED, + plan.files.single { it.sourceRelativePath.contains("Translations") }.status, + ) + assertTrue( + plan.files.filterNot { it.sourceRelativePath.contains("Translations") } + .all { it.status == PlannedFileStatus.INTENTIONALLY_IGNORED }, + ) + } + @Test fun bethesdaPlan_stripsOneWrapperAndDataContainer() { val candidate = AutomaticPlacementPlanner.plan( diff --git a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt index c2c2543456..309e059ac4 100644 --- a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt @@ -13,7 +13,7 @@ import org.junit.Test class ModArchiveIndexPerformanceTest { @Test - fun fiftyThousandEntries_indexWithinGenerousRegressionBudget() { + fun fiftyThousandEntries_indexWithinInteractiveRegressionBudget() { val entries = List(50_000) { index -> ModArchiveEntry( path = "Data/Textures/Set${index / 100}/texture$index.dds", @@ -27,11 +27,11 @@ class ModArchiveIndexPerformanceTest { assertEquals(50_000, archiveIndex.files.size) assertEquals(100, archiveIndex.filesUnder("Data/Textures/Set42").size) - assertTrue("Indexing took ${elapsed}ms", elapsed < 15_000) + assertTrue("Indexing took ${elapsed}ms", elapsed < 3_000) } @Test - fun fiftyThousandEntries_completePlanningWithinGenerousRegressionBudget() { + fun fiftyThousandEntries_completePlanningWithinInteractiveRegressionBudget() { val entries = List(50_000) { index -> ModArchiveEntry( path = "Data/Textures/Set${index / 100}/texture$index.dds", @@ -47,7 +47,7 @@ class ModArchiveIndexPerformanceTest { assertTrue(plan.blockingIssues.toString(), plan.isComplete) assertEquals(50_000, plan.placedCount) - assertTrue("Planning took ${elapsed}ms", elapsed < 20_000) + assertTrue("Planning took ${elapsed}ms", elapsed < 5_000) } @Test From a0ca9dd8da816d506ed8316debd5d7859c09555f Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Mon, 24 Aug 2026 00:04:34 -0500 Subject: [PATCH 39/60] fix: keep placement preparation off the UI thread --- .../ui/component/dialog/NexusModsDialog.kt | 43 +++++++++++-------- .../dialog/NexusModsPlacementSections.kt | 16 +++++-- 2 files changed, 37 insertions(+), 22 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index ec887e161c..e8cfcc410a 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -3085,11 +3085,11 @@ fun NexusModsDialog( } } - fun buildRecipes(install: ModInstall): List = + fun buildRecipes(install: ModInstall, drafts: List): List = BethesdaPlacementRecipeExpander.expand( gameName = libraryItem.name, install = install, - recipes = recipeDrafts.map { draft -> draft.toRecipe(install.installId) }, + recipes = drafts.map { draft -> draft.toRecipe(install.installId) }, ) LaunchedEffect( @@ -3141,17 +3141,22 @@ fun NexusModsDialog( val install = selectedInstall ?: return@LaunchedEffect if (!configurationDraftLoaded || !install.canPlaceFiles()) return@LaunchedEffect delay(200) - val recipes = recipeDrafts.map { it.toRecipe(install.installId) } + val draftSnapshot = recipeDrafts.toList() + val placementChoiceSnapshot = placementChoice.name + val automaticOptionsSnapshot = automaticOptionSelections + val riskyTargetsApprovedSnapshot = riskyAutomaticPlanApproved + val fomodSelectionsSnapshot = fomodSelectionDraft.mapValues { (_, values) -> values.sorted() } withContext(Dispatchers.IO) { + val recipes = draftSnapshot.map { it.toRecipe(install.installId) } ModConfigurationDraftStore.write( NexusModManager.cacheRoot(context, install.appId), ModConfigurationDraft( installId = install.installId, archiveIdentity = ModConfigurationDraftStore.archiveIdentity(install), - placementChoice = placementChoice.name, - automaticOptions = automaticOptionSelections, - riskyTargetsApproved = riskyAutomaticPlanApproved, - fomodSelections = fomodSelectionDraft.mapValues { (_, values) -> values.sorted() }, + placementChoice = placementChoiceSnapshot, + automaticOptions = automaticOptionsSnapshot, + riskyTargetsApproved = riskyTargetsApprovedSnapshot, + fomodSelections = fomodSelectionsSnapshot, recipes = recipes.map(ModConfigurationRecipe::from), ), ) @@ -3233,9 +3238,6 @@ fun NexusModsDialog( } } - fun applyRecipes(install: ModInstall, allowOverwrite: Boolean) = - applyRecipes(install, buildRecipes(install), allowOverwrite) - fun saveAndApply() { val install = selectedInstall ?: return if (!install.canPlaceFiles()) { @@ -3252,28 +3254,24 @@ fun NexusModsDialog( null } if (placementChoice == PlacementChoice.AUTOMATIC) { - val inspection = automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } - if ( - automaticPlan?.isComplete != true || - inspection?.ambiguousPaths?.isNotEmpty() == true - ) { + if (automaticPlan?.isComplete != true) { SnackbarManager.show(context.getString(R.string.nexus_plan_blocked)) return } } + val draftSnapshot = recipeDrafts.toList() val currentPreview = placementPlanPreview?.takeIf { - it.installId == install.installId && it.drafts == recipeDrafts.toList() + it.installId == install.installId && it.drafts == draftSnapshot }?.plan val initialReviewedPlan = automaticPlan ?: reviewedPlacementPlan ?: currentPreview if ( selectedFomodInstaller != null && placementChoice != PlacementChoice.CUSTOM && - recipeDrafts.any { draft -> ModPlacementSources.decode(draft.sourceSubpath).isEmpty() } + draftSnapshot.any { draft -> ModPlacementSources.decode(draft.sourceSubpath).isEmpty() } ) { SnackbarManager.show(context.getString(R.string.nexus_fomod_or_custom_required)) return } - val recipes = buildRecipes(install) if (modApplyInProgress) { SnackbarManager.show(context.getString(R.string.nexus_mod_apply_already_running)) return @@ -3283,6 +3281,15 @@ fun NexusModsDialog( try { placementApplyStatusMessage = null loadingMessage = context.getString(R.string.nexus_checking_target_files) + val hasAmbiguousTargets = automaticPlan?.let { plan -> + withContext(Dispatchers.IO) { ModTargetResolver.inspectPlan(plan, roots) } + .ambiguousPaths.isNotEmpty() + } == true + if (hasAmbiguousTargets) { + SnackbarManager.show(context.getString(R.string.nexus_plan_blocked)) + return@launch + } + val recipes = withContext(Dispatchers.Default) { buildRecipes(install, draftSnapshot) } val reviewedPlan = withContext(Dispatchers.IO) { val base = initialReviewedPlan ?: ModMaterializer.materializationPlan( install = install, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index f1250cc9fc..24cfd4c013 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -57,6 +57,7 @@ import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue @@ -89,6 +90,7 @@ import app.gamenative.mods.ModReconfigurationDiff import app.gamenative.mods.ModPlacementPreset import app.gamenative.mods.ModPlacementSources import app.gamenative.mods.ModTargetResolver +import app.gamenative.mods.ModTargetPlanInspection import app.gamenative.mods.PlannedFileStatus import app.gamenative.mods.PlacementRisk import app.gamenative.mods.PlacementRiskPolicy @@ -167,7 +169,7 @@ internal fun PlacementSection( var showArchiveBrowser by remember(install.installId, entries) { mutableStateOf(false) } var showFomodWizard by remember(install.installId, fomodInstaller) { mutableStateOf(false) } var showAdvancedPlacement by remember(install.installId) { mutableStateOf(placementChoice != PlacementChoice.AUTOMATIC) } - var customDraftPage by remember(install.installId) { mutableStateOf(0) } + var customDraftPage by remember(install.installId) { mutableIntStateOf(0) } val visibleDraftPage = remember(drafts.size, customDraftPage) { placementDraftPage(drafts.size, customDraftPage) } @@ -192,11 +194,17 @@ internal fun PlacementSection( val reconfigurationDiff = remember(previousOwnership, visiblePlan) { visiblePlan?.takeIf { previousOwnership != null }?.let { ModOwnershipPlanDiffer.compare(previousOwnership, it) } } - val targetInspection = remember(automaticPlan, roots) { - automaticPlan?.let { ModTargetResolver.inspectPlan(it, roots) } + var targetInspection by remember(automaticPlan, roots) { mutableStateOf(null) } + var targetInspectionLoading by remember(automaticPlan, roots) { mutableStateOf(automaticPlan != null) } + LaunchedEffect(automaticPlan, roots) { + targetInspectionLoading = automaticPlan != null + targetInspection = automaticPlan?.let { plan -> + withContext(Dispatchers.IO) { ModTargetResolver.inspectPlan(plan, roots) } + } + targetInspectionLoading = false } val applyBlocked = when { - placementChoice == PlacementChoice.AUTOMATIC -> automaticPlanLoading || + placementChoice == PlacementChoice.AUTOMATIC -> automaticPlanLoading || targetInspectionLoading || automaticPlan?.isComplete != true || targetInspection?.ambiguousPaths?.isNotEmpty() == true visiblePlan != null -> !visiblePlan.isComplete From 5d724e293f79ea6d5f126276f35fdf194e2beb5e Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Mon, 24 Aug 2026 21:02:11 -0500 Subject: [PATCH 40/60] fix: preserve mod state and accelerate integrity checks --- .../main/java/app/gamenative/db/dao/ModDao.kt | 2 +- .../gamenative/mods/BethesdaPluginManager.kt | 56 +++--- .../gamenative/mods/ModConflictAnalyzer.kt | 15 ++ .../gamenative/mods/ModDeploymentVerifier.kt | 170 ++++++++++++++---- .../gamenative/mods/ModOwnershipManifest.kt | 8 +- .../app/gamenative/mods/NexusModManager.kt | 19 +- .../ui/component/dialog/NexusModsDialog.kt | 133 +++++++++++--- .../dialog/NexusModsDialogHelpers.kt | 34 ++++ app/src/main/res/values/strings.xml | 7 +- .../db/dao/ModDaoLocalImportTest.kt | 32 ++++ .../mods/BethesdaPluginManagerTest.kt | 43 +++++ .../mods/ModConflictAnalyzerTest.kt | 43 +++++ .../mods/ModOwnershipManifestTest.kt | 44 +++++ .../dialog/NexusModsDialogHelpersTest.kt | 57 ++++++ 14 files changed, 569 insertions(+), 94 deletions(-) diff --git a/app/src/main/java/app/gamenative/db/dao/ModDao.kt b/app/src/main/java/app/gamenative/db/dao/ModDao.kt index da772463ef..176b53b7f4 100644 --- a/app/src/main/java/app/gamenative/db/dao/ModDao.kt +++ b/app/src/main/java/app/gamenative/db/dao/ModDao.kt @@ -82,7 +82,7 @@ interface ModDao { @Query("SELECT * FROM mod_profile WHERE app_id = :appId AND active = 1 LIMIT 1") suspend fun getActiveProfileForApp(appId: String): ModProfile? - @Insert(onConflict = OnConflictStrategy.REPLACE) + @Upsert suspend fun upsertProfile(profile: ModProfile) @Query("UPDATE mod_profile SET name = :name, updated_at = :updatedAt WHERE profile_id = :profileId") diff --git a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt index 467ac5690f..d7bb16a2be 100644 --- a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt +++ b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt @@ -78,6 +78,7 @@ object BethesdaPluginManager { gameRootDir: File?, winePrefix: String, pluginsFile: File?, + ownershipByInstallId: Map = emptyMap(), defaultEnabled: Boolean = false, ): List = withContext(Dispatchers.IO) { val game = gameFromPluginsFile(pluginsFile) @@ -88,29 +89,40 @@ object BethesdaPluginManager { .toMap() installs.filter { it.status == ModInstallStatus.APPLIED.name }.flatMap { install -> val recipes = recipesByInstallId[install.installId].orEmpty() + val ownership = ownershipByInstallId[install.installId] + ?.takeIf { it.state == ModOwnershipState.ACTIVE } runCatching { - val plan = ModMaterializer.materializationPlan( - install, - recipes, - gameRootDir, - winePrefix, - captureTargetHashes = false, - ) - check(plan.isComplete) { plan.errors.values.joinToString() } - plan.files - .filter { file -> file.source.extension.lowercase() in pluginExtensions } - .map { plugin -> - BethesdaPlugin( - fileName = plugin.target.name, - installId = install.installId, - modName = install.modName, - deployedPath = plugin.target.absolutePath, - enabled = existingByPlugin[plugin.target.name.lowercase()]?.enabled ?: defaultEnabled, - priority = prioritiesByInstallId[install.installId] ?: 0, - orderIndex = orderByPlugin[plugin.target.name.lowercase()] ?: Int.MAX_VALUE, - sourcePath = plugin.source.absolutePath, - ) - } + val pluginFiles = if (ownership != null) { + ownership.files + .asSequence() + .filter { it.active && File(it.targetPath).extension.lowercase() in pluginExtensions } + .map { file -> File(install.extractedPath, file.sourceRelativePath) to File(file.targetPath) } + .toList() + } else { + val plan = ModMaterializer.materializationPlan( + install, + recipes, + gameRootDir, + winePrefix, + captureTargetHashes = false, + ) + check(plan.isComplete) { plan.errors.values.joinToString() } + plan.files + .filter { file -> file.source.extension.lowercase() in pluginExtensions } + .map { file -> file.source to file.target } + } + pluginFiles.map { (source, target) -> + BethesdaPlugin( + fileName = target.name, + installId = install.installId, + modName = install.modName, + deployedPath = target.absolutePath, + enabled = existingByPlugin[target.name.lowercase()]?.enabled ?: defaultEnabled, + priority = prioritiesByInstallId[install.installId] ?: 0, + orderIndex = orderByPlugin[target.name.lowercase()] ?: Int.MAX_VALUE, + sourcePath = source.absolutePath, + ) + } }.getOrElse { error -> Timber.w(error, "Skipping Bethesda plugin detection for Nexus install %s", install.installId) emptyList() diff --git a/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt b/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt index cfecb8242a..c64fe0b7de 100644 --- a/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt +++ b/app/src/main/java/app/gamenative/mods/ModConflictAnalyzer.kt @@ -1,6 +1,7 @@ package app.gamenative.mods import app.gamenative.data.ModInstall +import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementRecipe import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext @@ -29,10 +30,24 @@ object ModConflictAnalyzer { prioritiesByInstallId: Map, gameRootDir: File?, winePrefix: String, + ownershipByInstallId: Map = emptyMap(), ): List = withContext(Dispatchers.IO) { val installById = installs.associateBy { it.installId } val plannedFiles = installs.flatMap { install -> val recipes = recipesByInstallId[install.installId].orEmpty() + val ownership = ownershipByInstallId[install.installId] + ?.takeIf { install.status == ModInstallStatus.APPLIED.name && it.state == ModOwnershipState.ACTIVE } + if (ownership != null) { + return@flatMap ownership.files + .filter { it.active } + .map { file -> + PlannedFile( + installId = install.installId, + source = File(install.extractedPath, file.sourceRelativePath), + target = File(file.targetPath), + ) + } + } runCatching { val plan = ModMaterializer.materializationPlan( install, diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt index 2646547999..63f176a0ef 100644 --- a/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt @@ -2,6 +2,7 @@ package app.gamenative.mods import java.io.File import java.nio.file.Files +import java.util.Locale enum class ModVerificationIssueType { MISSING, @@ -23,32 +24,59 @@ data class ModDeploymentVerification(val issues: List) { val successful: Boolean get() = issues.isEmpty() } +enum class ModVerificationDepth { + FULL, + CHANGED_CONTENT, +} + object ModDeploymentVerifier { - fun verify(plan: ModMaterializationPlan): ModDeploymentVerification = - ModDeploymentVerification( + fun verify(plan: ModMaterializationPlan): ModDeploymentVerification { + val session = VerificationSession(ModVerificationDepth.FULL) + return ModDeploymentVerification( plan.files.flatMap { file -> - verifyTarget( + session.verifyTarget( target = file.target, expectedHash = ModOwnershipStore.sha256(file.source), + expectedSize = file.source.length(), + expectedMtime = 0L, stale = false, installId = file.installId, ) }, ) + } - fun verify(manifest: ModOwnershipManifest): ModDeploymentVerification = - ModDeploymentVerification( + fun verify( + manifest: ModOwnershipManifest, + depth: ModVerificationDepth = ModVerificationDepth.FULL, + ): ModDeploymentVerification { + val session = VerificationSession(depth) + return ModDeploymentVerification( manifest.files.flatMap { file -> - verifyTarget(File(file.targetPath), file.installedHash, stale = !file.active, installId = manifest.installId) + session.verifyTarget( + target = File(file.targetPath), + expectedHash = file.installedHash, + expectedSize = file.installedSize, + expectedMtime = file.installedMtime, + stale = !file.active, + installId = manifest.installId, + ) }, ) + } - fun verify(overlay: ModProfileOverlay): ModDeploymentVerification = - ModDeploymentVerification( + fun verify( + overlay: ModProfileOverlay, + depth: ModVerificationDepth = ModVerificationDepth.FULL, + ): ModDeploymentVerification { + val session = VerificationSession(depth) + return ModDeploymentVerification( overlay.targets.values.flatMap { target -> - verifyTarget( + session.verifyTarget( target = File(target.winner.file.targetPath), expectedHash = target.winner.file.installedHash, + expectedSize = target.winner.file.installedSize, + expectedMtime = target.winner.file.installedMtime, stale = false, installId = target.winner.installId, ) + if (target.hasCaseCollision) { @@ -65,38 +93,114 @@ object ModDeploymentVerifier { } }, ) + } - private fun verifyTarget( - target: File, - expectedHash: String, - stale: Boolean, - installId: String, - ): List { - val parent = target.parentFile - val caseMatches = parent?.listFiles().orEmpty().filter { it.name.equals(target.name, ignoreCase = true) } - if (caseMatches.size > 1) { - return listOf(issue(ModVerificationIssueType.AMBIGUOUS, target, "Multiple case variants exist", installId)) + fun verifyPresence(manifest: ModOwnershipManifest): ModDeploymentVerification { + val session = VerificationSession(ModVerificationDepth.CHANGED_CONTENT) + return ModDeploymentVerification( + manifest.files + .asSequence() + .filter { it.active } + .flatMap { file -> session.verifyPresence(File(file.targetPath), manifest.installId).asSequence() } + .toList(), + ) + } + + fun verifyStale(manifest: ModOwnershipManifest): ModDeploymentVerification { + val session = VerificationSession(ModVerificationDepth.CHANGED_CONTENT) + return ModDeploymentVerification( + manifest.files + .asSequence() + .filterNot { it.active } + .flatMap { file -> session.verifyStale(File(file.targetPath), manifest.installId).asSequence() } + .toList(), + ) + } + + private class VerificationSession(private val depth: ModVerificationDepth) { + private val childrenByParent = mutableMapOf>>() + + fun verifyTarget( + target: File, + expectedHash: String, + expectedSize: Long, + expectedMtime: Long, + stale: Boolean, + installId: String, + ): List { + val resolution = resolveTarget(target, installId) + resolution.issue?.let { return listOf(it) } + val actual = resolution.actual + if (actual == null) { + return if (stale) emptyList() else listOf(issue(ModVerificationIssueType.MISSING, target, "Required planned file is missing", installId)) + } + if (stale) { + return listOf(issue(ModVerificationIssueType.STALE, actual, "A preserved stale managed file is still present", installId)) + } + val issues = mutableListOf() + if (actual.name != target.name) { + issues += issue(ModVerificationIssueType.WRONG_CASE, actual, "Target exists with unexpected casing", installId) + } + if (!contentMatches(actual, expectedHash, expectedSize, expectedMtime)) { + issues += issue(ModVerificationIssueType.MODIFIED, actual, "Target content differs from the reviewed plan", installId) + } + return issues } - val actual = when { - target.exists() || Files.isSymbolicLink(target.toPath()) -> target - caseMatches.size == 1 -> caseMatches.single() - stale -> return emptyList() - else -> return listOf(issue(ModVerificationIssueType.MISSING, target, "Required planned file is missing", installId)) + + fun verifyPresence(target: File, installId: String): List { + val resolution = resolveTarget(target, installId) + resolution.issue?.let { return listOf(it) } + return if (resolution.actual == null) { + listOf(issue(ModVerificationIssueType.MISSING, target, "Required planned file is missing", installId)) + } else { + emptyList() + } + } + + fun verifyStale(target: File, installId: String): List { + val resolution = resolveTarget(target, installId) + resolution.issue?.let { return listOf(it) } + return resolution.actual?.let { + listOf(issue(ModVerificationIssueType.STALE, it, "A preserved stale managed file is still present", installId)) + }.orEmpty() } - if (stale) { - return listOf(issue(ModVerificationIssueType.STALE, actual, "A preserved stale managed file is still present", installId)) + + private fun contentMatches(actual: File, expectedHash: String, expectedSize: Long, expectedMtime: Long): Boolean { + if (!actual.isFile || expectedHash.isBlank()) return false + if (depth == ModVerificationDepth.CHANGED_CONTENT) { + if (expectedSize >= 0L && actual.length() != expectedSize) return false + if (expectedMtime > 0L && actual.lastModified() == expectedMtime) return true + } + return ModOwnershipStore.sha256(actual) == expectedHash } - val issues = mutableListOf() - if (actual.name != target.name) { - issues += issue(ModVerificationIssueType.WRONG_CASE, actual, "Target exists with unexpected casing", installId) + + private fun resolveTarget(target: File, installId: String): TargetResolution { + val caseMatches = caseMatches(target) + if (caseMatches.size > 1) { + return TargetResolution( + issue = issue(ModVerificationIssueType.AMBIGUOUS, target, "Multiple case variants exist", installId), + ) + } + if (target.exists() || Files.isSymbolicLink(target.toPath())) return TargetResolution(target) + return TargetResolution(caseMatches.singleOrNull()) } - val currentHash = ModOwnershipStore.sha256(actual) - if (!actual.isFile || expectedHash.isBlank() || currentHash != expectedHash) { - issues += issue(ModVerificationIssueType.MODIFIED, actual, "Target content differs from the reviewed plan", installId) + + private fun caseMatches(target: File): List { + val parent = target.parentFile ?: return emptyList() + val children = childrenByParent.getOrPut(parent.absolutePath) { + parent.listFiles() + .orEmpty() + .groupBy { it.name.lowercase(Locale.ROOT) } + } + return children[target.name.lowercase(Locale.ROOT)].orEmpty() } - return issues } + private data class TargetResolution( + val actual: File? = null, + val issue: ModVerificationIssue? = null, + ) + private fun issue(type: ModVerificationIssueType, target: File, detail: String, installId: String) = ModVerificationIssue(type, target.absolutePath, detail, installId) } diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index c9473cf68c..948db67a56 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -302,7 +302,13 @@ object ModProfileOverlayPlanner { current = current, desired = desired, changedWinnerKeys = changedWinnerKeys, - currentVerification = ModDeploymentVerifier.verify(current), + currentVerification = if (changedWinnerKeys.isEmpty()) { + ModDeploymentVerification(emptyList()) + } else { + ModDeploymentVerifier.verify( + current.copy(targets = current.targets.filterKeys(changedWinnerKeys::contains)), + ) + }, ) } } diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index 11b587a5bb..3a75b76f90 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -761,7 +761,7 @@ object NexusModManager { created = 0, skipped = 0, backedUp = 0, - errors = mapOf(install.modName to "Ownership adoption is only available for an applied historical install without an ownership manifest"), + errors = mapOf(install.modName to "File tracking setup is only available for an older applied mod that is not tracked yet"), manifests = emptyList(), ) } @@ -873,7 +873,7 @@ object NexusModManager { val ownership = ModOwnershipStore.read(ownershipRoot, install.installId) if (ownership == null) { dao.updateInstallEnabled(install.installId, false, ModInstallStatus.DISABLED.name) - return@withContext listOf("Ownership adoption is required before deployed files can be removed safely") + return@withContext listOf("Verify and track this mod's installed files before disabling or removing it safely") } val cleanup = ModOwnershipReconciler.removeOwnedFiles(ownership, manifests, restoreBackups = restoreBackups) ModOwnershipStore.writePending( @@ -1169,8 +1169,10 @@ object NexusModManager { .filter { it.enabled } .associate { it.installId to it.priority } }.orEmpty() + val overlay = ModProfileOverlayPlanner.build(ownershipByInstallId.values.toList(), enabledPriorities) val overlayFindings = ModDeploymentVerifier.verify( - ModProfileOverlayPlanner.build(ownershipByInstallId.values.toList(), enabledPriorities), + overlay, + ModVerificationDepth.CHANGED_CONTENT, ).issues installs.forEach { install -> @@ -1209,8 +1211,8 @@ object NexusModManager { } else if (ownership == null) { add( ModHealthSeverity.WARNING, - "Ownership adoption is required", - "This historical install remains usable. Verify its current files to adopt conservative ownership without changing them.", + "Finish tracking installed files", + "This mod was installed before file tracking was added. Verify the files already in place so GameNative can disable or remove the mod safely. No files will be moved or replaced.", install, ModHealthAction.ADOPT_OWNERSHIP, ) @@ -1218,7 +1220,7 @@ object NexusModManager { add(ModHealthSeverity.ERROR, "Ownership state does not match the applied mod", ownership.state.name, install) } else { val findingsForInstall = overlayFindings.filter { it.installId == install.installId } + - ModDeploymentVerifier.verify(ownership).issues.filter { it.type == ModVerificationIssueType.STALE } + ModDeploymentVerifier.verifyStale(ownership).issues findingsForInstall.groupBy { it.type }.forEach { (type, findings) -> val severity = if (type == ModVerificationIssueType.STALE) ModHealthSeverity.WARNING else ModHealthSeverity.ERROR add( @@ -1254,8 +1256,7 @@ object NexusModManager { } } } else if (ownership != null) { - ModDeploymentVerifier.verify(ownership).issues - .filter { it.type == ModVerificationIssueType.STALE } + ModDeploymentVerifier.verifyStale(ownership).issues .take(3) .forEach { finding -> add(ModHealthSeverity.WARNING, "Stale managed file was preserved", finding.targetPath, install) @@ -1335,7 +1336,7 @@ object NexusModManager { "deployment-journals=${journals.size}", "journal-checkpoints=$journalCheckpoints", "profile-enabled=${enabledPriorities.size}", - "overlay-targets=${ModProfileOverlayPlanner.build(ownershipByInstallId.values.toList(), enabledPriorities).targets.size}", + "overlay-targets=${overlay.targets.size}", ), ) } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index e8cfcc410a..60a9f70efc 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -156,14 +156,18 @@ import app.gamenative.ui.screen.auth.NexusOAuthBrowserLauncher import app.gamenative.ui.util.LocalSnackbarHostController import app.gamenative.ui.util.SnackbarManager import app.gamenative.utils.StorageUtils -import kotlinx.coroutines.Dispatchers -import kotlinx.coroutines.delay import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.async +import kotlinx.coroutines.awaitAll +import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.delay import kotlinx.coroutines.flow.collect import kotlinx.coroutines.flow.flowOf import kotlinx.coroutines.launch +import kotlinx.coroutines.sync.Semaphore +import kotlinx.coroutines.sync.withPermit import kotlinx.coroutines.withContext import timber.log.Timber import java.io.File @@ -371,8 +375,10 @@ private data class ProfileOrderPlan( val configuredInstalls: List, val installsToApply: List, val rebuildManagedOverlay: Boolean, + val overlayTransitionBlockerCount: Int, val missingTargetRepairInstallIds: Set, val recipesByInstallId: Map>, + val ownershipByInstallId: Map, val reviewedPlansByInstallId: Map, val recipesToPersistByInstallId: Map>, val unconfiguredCount: Int, @@ -1298,12 +1304,18 @@ fun NexusModsDialog( val recipesByInstallId = usableInstalls.associate { install -> install.installId to dao.getRecipesForInstall(install.installId) } + val ownershipRoot = NexusModManager.cacheRoot(context, libraryItem.appId) + val ownershipByInstallId = usableInstalls.mapNotNull { install -> + ModOwnershipStore.read(ownershipRoot, install.installId) + ?.let { install.installId to it } + }.toMap() val conflicts = ModConflictAnalyzer.analyze( installs = usableInstalls, recipesByInstallId = recipesByInstallId, prioritiesByInstallId = priorities, gameRootDir = gameRootDir, winePrefix = winePrefix, + ownershipByInstallId = ownershipByInstallId, ) val game = BethesdaPluginManager.detectGame(libraryItem.name) val detectedPlugins = game?.let { @@ -1314,6 +1326,7 @@ fun NexusModsDialog( gameRootDir = gameRootDir, winePrefix = winePrefix, pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, it), + ownershipByInstallId = ownershipByInstallId, ) }.orEmpty() ModDiagnosticsSnapshot( @@ -1595,6 +1608,7 @@ fun NexusModsDialog( install.installId, ) } + val ownershipByInstallId = allOwnership.associateBy { it.installId } val reviewedPlansByInstallId = allOwnership.mapNotNull { ownership -> ownership.reviewedPlanOrNull()?.let { ownership.installId to it } }.toMap() @@ -1613,9 +1627,11 @@ fun NexusModsDialog( allOwnership, desiredPriorities, ) - val rebuildManagedOverlay = configuredInstalls.isNotEmpty() && - configuredInstalls.all { it.installId in configuredOwnershipIds } && - overlayTransition.safeToRebuild + val rebuildManagedOverlay = requiresManagedOverlayRebuild( + configuredInstallIds = configuredInstalls.mapTo(mutableSetOf()) { it.installId }, + activeOwnershipInstallIds = configuredOwnershipIds, + transition = overlayTransition, + ) val game = BethesdaPluginManager.detectGame(libraryItem.name) val plugins = game?.let { BethesdaPluginManager.detectPlugins( @@ -1625,6 +1641,7 @@ fun NexusModsDialog( gameRootDir = gameRootDir, winePrefix = winePrefix, pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, it), + ownershipByInstallId = ownershipByInstallId, defaultEnabled = true, ) }.orEmpty() @@ -1641,23 +1658,33 @@ fun NexusModsDialog( val assetRepairInstallIds = pluginAssetIssues.mapNotNull { it.plugin.installId }.toSet() val missingTargetRepairInstallIds = configuredInstalls .filter { install -> - NexusModManager.hasMissingAppliedTargets( - install = install, - recipes = recipesByInstallId[install.installId].orEmpty(), - gameRootDir = gameRootDir, - winePrefix = winePrefix, - reviewedPlan = reviewedPlansByInstallId[install.installId], - ) + val ownership = ownershipByInstallId[install.installId] + if (ownership?.state == app.gamenative.mods.ModOwnershipState.ACTIVE) { + app.gamenative.mods.ModDeploymentVerifier.verifyPresence(ownership).issues.any { + it.type == app.gamenative.mods.ModVerificationIssueType.MISSING + } + } else { + NexusModManager.hasMissingAppliedTargets( + install = install, + recipes = recipesByInstallId[install.installId].orEmpty(), + gameRootDir = gameRootDir, + winePrefix = winePrefix, + reviewedPlan = reviewedPlansByInstallId[install.installId], + ) + } } .mapTo(mutableSetOf()) { it.installId } val installsToApply = if (rebuildManagedOverlay) { configuredInstalls } else { configuredInstalls.filter { install -> - install.status != ModInstallStatus.APPLIED.name || - install.installId in conflictInstallIds || - install.installId in assetRepairInstallIds || - install.installId in missingTargetRepairInstallIds + shouldApplyProfileInstall( + install = install, + hasActiveOwnership = install.installId in configuredOwnershipIds, + hasConflict = install.installId in conflictInstallIds, + needsAssetRepair = install.installId in assetRepairInstallIds, + hasMissingTarget = install.installId in missingTargetRepairInstallIds, + ) } } ProfileOrderPlan( @@ -1667,8 +1694,14 @@ fun NexusModsDialog( configuredInstalls = configuredInstalls, installsToApply = installsToApply, rebuildManagedOverlay = rebuildManagedOverlay, + overlayTransitionBlockerCount = if (overlayTransition.requiresRebuild && !overlayTransition.safeToRebuild) { + overlayTransition.currentVerification.issues.size + } else { + 0 + }, missingTargetRepairInstallIds = missingTargetRepairInstallIds, recipesByInstallId = recipesByInstallId, + ownershipByInstallId = ownershipByInstallId, reviewedPlansByInstallId = reviewedPlansByInstallId, recipesToPersistByInstallId = recipesToPersistByInstallId, unconfiguredCount = unconfiguredInstalls.size, @@ -1683,6 +1716,15 @@ fun NexusModsDialog( bethesdaPlugins = plan.plugins bethesdaPluginIssues = plan.pluginIssues bethesdaPluginAssetIssues = plan.pluginAssetIssues + if (plan.overlayTransitionBlockerCount > 0) { + SnackbarManager.show( + context.getString( + R.string.nexus_mod_order_blocked_managed_files, + plan.overlayTransitionBlockerCount, + ), + ) + return@launch + } if (plan.pluginIssues.hasBlockingPluginIssues()) { SnackbarManager.show(context.getString(R.string.nexus_fix_plugin_warnings_before_apply)) return@launch @@ -1818,6 +1860,14 @@ fun NexusModsDialog( val pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game) if (pluginsFile != null) { val appliedInstalls = plan.configuredInstalls.map { it.copy(status = ModInstallStatus.APPLIED.name) } + val appliedOwnership = plan.ownershipByInstallId.toMutableMap().apply { + plan.installsToApply.forEach { install -> + ModOwnershipStore.read( + NexusModManager.cacheRoot(context, libraryItem.appId), + install.installId, + )?.let { put(install.installId, it) } + } + } val detectedPlugins = applyCollectionPluginOrder( BethesdaPluginManager.detectPlugins( installs = appliedInstalls, @@ -1826,6 +1876,7 @@ fun NexusModsDialog( gameRootDir = gameRootDir, winePrefix = winePrefix, pluginsFile = pluginsFile, + ownershipByInstallId = appliedOwnership, defaultEnabled = true, ), collectionPluginOrder, @@ -1964,13 +2015,13 @@ fun NexusModsDialog( if (result.errors.isEmpty()) { context.getString(R.string.nexus_ownership_adopted) } else { - context.getString(R.string.nexus_ownership_adoption_failed, result.errors.size) + context.getString(R.string.nexus_file_tracking_setup_failed, result.errors.size) }, ) healthReport = NexusModManager.checkInstallHealthForApp(context, libraryItem.appId, gameRootDir, winePrefix) } catch (error: Throwable) { if (error is kotlinx.coroutines.CancellationException) throw error - SnackbarManager.show(context.getString(R.string.nexus_ownership_adoption_failed, 1)) + SnackbarManager.show(context.getString(R.string.nexus_file_tracking_setup_failed, 1)) } finally { healthLoading = false } @@ -1982,6 +2033,7 @@ fun NexusModsDialog( if (modApplyInProgress || profileApplyInProgress) return scope.launch { modApplyInProgress = true + diagnosticsPaused = true try { loadingMessage = context.getString(R.string.nexus_restoring_previous_deployment) val profile = activeProfile ?: ModProfileManager.ensureActiveProfile(dao, libraryItem.appId) @@ -2017,6 +2069,7 @@ fun NexusModsDialog( } finally { modApplyInProgress = false loadingMessage = null + diagnosticsPaused = false } } } @@ -2522,14 +2575,19 @@ fun NexusModsDialog( error = context.getString(R.string.nexus_collection_manual_external_entry), ) } + val embeddedFile = collectionFile.toFallbackNexusFile() + val embeddedModInfo = collectionFile.toEmbeddedNexusModInfo() return try { - val modInfo = apiClient.getModInfo(collectionFile.gameDomain, collectionFile.modId) + val modInfo = embeddedModInfo + ?: apiClient.getModInfo(collectionFile.gameDomain, collectionFile.modId) val files = apiClient.getModFiles(collectionFile.gameDomain, collectionFile.modId) val file = files.firstOrNull { it.fileId == collectionFile.fileId } - ?: collectionFile.toFallbackNexusFile() + ?: embeddedFile PendingCollectionMod(collectionFile, modInfo, file) + } catch (e: CancellationException) { + throw e } catch (e: Exception) { - val fallbackFile = collectionFile.toFallbackNexusFile() + val fallbackFile = embeddedFile if (fallbackFile != null) { PendingCollectionMod( collectionFile = collectionFile, @@ -2565,10 +2623,21 @@ fun NexusModsDialog( SnackbarManager.show(context.getString(R.string.nexus_collection_no_downloadable_mods)) return@launch } - val resolvedMods = mutableListOf() - collection.files.forEachIndexed { index, file -> - loadingMessage = context.getString(R.string.nexus_resolving_collection_item, index + 1, collection.files.size) - resolvedMods += resolveCollectionMod(file) + var resolvedCount = 0 + val resolutionGate = Semaphore(4) + val resolvedMods = coroutineScope { + collection.files.map { file -> + async { + val resolved = resolutionGate.withPermit { resolveCollectionMod(file) } + resolvedCount++ + loadingMessage = context.getString( + R.string.nexus_resolving_collection_item, + resolvedCount, + collection.files.size, + ) + resolved + } + }.awaitAll() } pendingFileSelection = null pendingCollectionSelection = PendingCollectionSelection(collection, resolvedMods) @@ -3198,12 +3267,20 @@ fun NexusModsDialog( } val message = if (result.errors.isEmpty()) { lastPlacementDrafts = recipes.map { it.toDraft() } + placementNeededInstallIds = placementNeededInstallIds - install.installId val cleanupSuffix = if (result.warnings.isNotEmpty()) { context.getString(R.string.nexus_old_files_left_in_place_suffix, result.warnings.size) } else { "" } - context.getString(R.string.nexus_applied_items_backups, result.created, result.backedUp, cleanupSuffix) + context.getString( + R.string.nexus_placement_complete_summary, + result.created + result.skipped, + result.created, + result.skipped, + result.backedUp, + cleanupSuffix, + ) } else { context.getString(R.string.nexus_applied_with_errors, result.errors.size) } @@ -3224,6 +3301,7 @@ fun NexusModsDialog( } scope.launch { modApplyInProgress = true + diagnosticsPaused = true try { placementApplyStatusMessage = null applyRecipesInternal(install, recipes, allowOverwrite, reviewedPlan) @@ -3234,6 +3312,7 @@ fun NexusModsDialog( } finally { modApplyInProgress = false loadingMessage = null + diagnosticsPaused = false } } } @@ -3278,6 +3357,7 @@ fun NexusModsDialog( } scope.launch { modApplyInProgress = true + diagnosticsPaused = true try { placementApplyStatusMessage = null loadingMessage = context.getString(R.string.nexus_checking_target_files) @@ -3342,6 +3422,7 @@ fun NexusModsDialog( } finally { modApplyInProgress = false loadingMessage = null + diagnosticsPaused = false } } } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt index 0093db5fbe..324e31d1af 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt @@ -27,9 +27,11 @@ import app.gamenative.mods.ModImportProgress import app.gamenative.mods.ModPlacementPreset import app.gamenative.mods.ModPlacementPresetDetector import app.gamenative.mods.ModPlacementSources +import app.gamenative.mods.ModProfileOverlayTransition import app.gamenative.mods.ModTargetResolver import app.gamenative.mods.NexusCollectionFile import app.gamenative.mods.NexusModFile +import app.gamenative.mods.NexusModInfo import app.gamenative.mods.ResolvedModTargetRoot import java.io.File import kotlinx.coroutines.CoroutineStart @@ -101,6 +103,28 @@ internal fun ModInstall.profileStatus(enabledInProfile: Boolean): String = else -> status } +internal fun requiresManagedOverlayRebuild( + configuredInstallIds: Set, + activeOwnershipInstallIds: Set, + transition: ModProfileOverlayTransition, +): Boolean = + configuredInstallIds.isNotEmpty() && + configuredInstallIds.all(activeOwnershipInstallIds::contains) && + transition.requiresRebuild && + transition.safeToRebuild + +internal fun shouldApplyProfileInstall( + install: ModInstall, + hasActiveOwnership: Boolean, + hasConflict: Boolean, + needsAssetRepair: Boolean, + hasMissingTarget: Boolean, +): Boolean = + install.status != ModInstallStatus.APPLIED.name || + (hasConflict && !hasActiveOwnership) || + needsAssetRepair || + hasMissingTarget + internal fun ModDownloadInfo.toImportProgress(): ModImportProgress = ModImportProgress( status = status, @@ -227,6 +251,16 @@ internal fun automaticDraftsFor( return automaticDraftsFor(result, gameName, entries, fallback) } +internal fun NexusCollectionFile.toEmbeddedNexusModInfo(): NexusModInfo? { + val resolvedModName = modName.ifBlank { return null } + return NexusModInfo( + modId = modId, + name = resolvedModName, + summary = "", + version = version, + ) +} + internal fun automaticDraftsFor( result: AutomaticPlacementResult, gameName: String, diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index d7244fa149..cfb0fa08c8 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1,4 +1,4 @@ - + GameNative User Login Two Factor @@ -2089,6 +2089,7 @@ Mod order is already applying. Applying mod order. Large mod lists may take a while. Checking mod order + Mod order was not changed because %1$d managed file(s) are missing or modified. Run Install health and resolve those files first. Fix plugin master warnings before applying order. Checking file conflicts Profile order has existing target files. Use Overwrite files and create backups for mods that should win conflicts. @@ -2110,9 +2111,10 @@ DLL, EXE, and loader files can change how the game starts. Confirm only when this archive is trusted and the preview matches its installation instructions. Building the file placement plan… Reapply missing files - Adopt verified files + Verify and track files Verified files were adopted without changing them Could not safely adopt ownership (%1$d issue(s)) + Could not verify and track installed files (%1$d issue(s)) Restore previous deployment Returns this mod to its previous reviewed file plan. Externally modified files are preserved. Restoring previous deployment @@ -2166,6 +2168,7 @@ Failed to resolve Nexus URL Applying mod files Applied %1$d item(s), backed up %2$d%3$s + Placement complete for %1$d item(s): %2$d updated, %3$d already current, %4$d backed up%5$s ; %1$d old file(s) left in place Applied with %1$d error(s) Mod files are already being applied. diff --git a/app/src/test/java/app/gamenative/db/dao/ModDaoLocalImportTest.kt b/app/src/test/java/app/gamenative/db/dao/ModDaoLocalImportTest.kt index b78cf8264b..5a1a032cd7 100644 --- a/app/src/test/java/app/gamenative/db/dao/ModDaoLocalImportTest.kt +++ b/app/src/test/java/app/gamenative/db/dao/ModDaoLocalImportTest.kt @@ -15,6 +15,7 @@ import org.junit.After import org.junit.Assert.assertEquals import org.junit.Assert.assertNotNull import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import org.junit.runner.RunWith @@ -87,6 +88,37 @@ class ModDaoLocalImportTest { assertNotNull(dao.getProfileInstallState(profile.profileId, install.installId)) } + @Test + fun profileUpsert_preservesEveryDependentInstallState() = runBlocking { + val profile = ModProfile( + profileId = "profile", + appId = APP_ID, + name = "Default", + ) + val first = localInstall("first", ModInstallStatus.APPLIED) + val second = localInstall("second", ModInstallStatus.APPLIED) + dao.upsertProfile(profile) + dao.upsertInstall(first) + dao.upsertInstall(second) + listOf(first, second).forEachIndexed { priority, install -> + dao.upsertProfileInstallState( + ModProfileInstallState( + profileId = profile.profileId, + installId = install.installId, + appId = APP_ID, + enabled = true, + priority = priority, + ), + ) + } + + dao.upsertProfile(profile.copy(active = true, updatedAt = profile.updatedAt + 1)) + + val states = dao.getProfileInstallStates(APP_ID, profile.profileId) + assertEquals(setOf("first", "second"), states.map { it.installId }.toSet()) + assertTrue(states.all { it.enabled }) + } + @Test fun installUpdate_doesNotRecreateDeletedRow() = runBlocking { val deleted = localInstall("local_deleted", ModInstallStatus.ERROR) diff --git a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt index a338ae6b00..7be9318663 100644 --- a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt +++ b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt @@ -104,6 +104,49 @@ class BethesdaPluginManagerTest { assertEquals(true, plugins.single().enabled) } + @Test + fun detectPlugins_reusesAppliedOwnershipWithoutRebuildingArchivePlan() = runBlocking { + val install = install() + val source = File(install.extractedPath, "Choices/Cloaks.esp").apply { + parentFile?.mkdirs() + writeText("esp") + } + val target = File(gameDir, "Data/Cloaks.esp") + val ownership = ModOwnershipManifest( + installId = install.installId, + appId = install.appId, + planDigest = "owned", + files = listOf( + ModOwnedFile( + sourceRelativePath = source.relativeTo(File(install.extractedPath)).path, + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "Data/Cloaks.esp", + targetPath = target.absolutePath, + normalizedTargetKey = WindowsPathIdentity.absoluteKey(target), + mode = ModPlacementMode.OVERWRITE_COPY.name, + installedHash = "hash", + installedSize = source.length(), + installedMtime = source.lastModified(), + disposition = ModOwnedFileDisposition.CREATED, + ), + ), + ) + + val plugins = BethesdaPluginManager.detectPlugins( + installs = listOf(install), + recipesByInstallId = emptyMap(), + prioritiesByInstallId = mapOf(install.installId to 7), + gameRootDir = gameDir, + winePrefix = "", + pluginsFile = File(tempDir, "missing/plugins.txt"), + ownershipByInstallId = mapOf(install.installId to ownership), + defaultEnabled = true, + ) + + assertEquals("Cloaks.esp", plugins.single().fileName) + assertEquals(source.absolutePath, plugins.single().sourcePath) + } + @Test fun detectPlugins_ignoresReadyModsThatHaveNotBeenApplied() = runBlocking { val install = install().copy(status = ModInstallStatus.READY.name) diff --git a/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt b/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt index 30e6ef85c7..ca2f99100f 100644 --- a/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModConflictAnalyzerTest.kt @@ -1,6 +1,7 @@ package app.gamenative.mods import app.gamenative.data.ModInstall +import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementMode import app.gamenative.data.ModPlacementRecipe import app.gamenative.data.ModTargetRoot @@ -85,6 +86,27 @@ class ModConflictAnalyzerTest { assertEquals(setOf("first", "second"), reports.single().participants.map { it.installId }.toSet()) } + @Test + fun analyze_reusesAppliedOwnershipWithoutRebuildingArchivePlans() = runBlocking { + val low = install("low", "Low", "low").copy(status = ModInstallStatus.APPLIED.name) + val high = install("high", "High", "high").copy(status = ModInstallStatus.APPLIED.name) + val target = File(gameDir, "Data/shared.txt") + + val reports = ModConflictAnalyzer.analyze( + installs = listOf(low, high), + recipesByInstallId = emptyMap(), + prioritiesByInstallId = mapOf("low" to 1, "high" to 2), + gameRootDir = gameDir, + winePrefix = "", + ownershipByInstallId = mapOf( + "low" to ownership(low, target), + "high" to ownership(high, target), + ), + ) + + assertEquals("high", reports.single().winnerInstallId) + } + private fun install(id: String, name: String, folder: String): ModInstall { val extracted = File(tempDir, folder).apply { mkdirs() } return ModInstall( @@ -108,4 +130,25 @@ class ModConflictAnalyzerTest { targetRelativePath = "Data", mode = ModPlacementMode.OVERWRITE_COPY.name, ) + + private fun ownership(install: ModInstall, target: File): ModOwnershipManifest = + ModOwnershipManifest( + installId = install.installId, + appId = install.appId, + planDigest = install.installId, + files = listOf( + ModOwnedFile( + sourceRelativePath = "Data/shared.txt", + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "Data/shared.txt", + targetPath = target.absolutePath, + normalizedTargetKey = WindowsPathIdentity.absoluteKey(target), + mode = ModPlacementMode.OVERWRITE_COPY.name, + installedHash = install.installId, + installedSize = 1L, + installedMtime = 1L, + disposition = ModOwnedFileDisposition.CREATED, + ), + ), + ) } diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt index 527debf63f..0a18502e79 100644 --- a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -47,6 +47,50 @@ class ModOwnershipManifestTest { assertTrue(transition.safeToRebuild) } + @Test + fun overlayTransition_skipsContentVerificationWhenNoWinnerCanChange() { + val target = temporaryFolder.newFile("unchanged-order.txt").apply { writeText("current") } + val manifest = manifest("managed", target, "not-the-current-hash", priority = 10) + + val transition = ModProfileOverlayPlanner.transition( + listOf(manifest), + desiredPriorities = mapOf("managed" to 10), + ) + + assertFalse(transition.requiresRebuild) + assertTrue(transition.currentVerification.successful) + } + + @Test + fun changedContentVerification_hashesOnlyWhenRecordedMetadataChanged() { + val target = temporaryFolder.newFile("metadata.txt").apply { writeText("owned") } + val manifest = manifest("managed", target, "not-the-current-hash", priority = 10).let { ownership -> + ownership.copy( + files = ownership.files.map { + it.copy(installedSize = target.length(), installedMtime = target.lastModified()) + }, + ) + } + + assertFalse(ModDeploymentVerifier.verify(manifest).successful) + assertTrue(ModDeploymentVerifier.verify(manifest, ModVerificationDepth.CHANGED_CONTENT).successful) + + target.appendText("-changed") + + assertFalse(ModDeploymentVerifier.verify(manifest, ModVerificationDepth.CHANGED_CONTENT).successful) + } + + @Test + fun presenceVerification_reportsMissingManagedTargetsWithoutMaterializingTheArchive() { + val missing = File(temporaryFolder.root, "missing.txt") + val manifest = manifest("managed", missing, "hash", priority = 10) + + assertEquals( + listOf(ModVerificationIssueType.MISSING), + ModDeploymentVerifier.verifyPresence(manifest).issues.map { it.type }, + ) + } + @Test fun staleCleanup_removesOnlyUnchangedOwnedFiles() = runBlocking { val targetRoot = temporaryFolder.newFolder("game") diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt index fce4759375..8fb3a7386a 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt @@ -3,6 +3,10 @@ package app.gamenative.ui.component.dialog import app.gamenative.data.ModInstall import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementRecipe +import app.gamenative.mods.NexusCollectionFile +import app.gamenative.mods.ModDeploymentVerification +import app.gamenative.mods.ModProfileOverlay +import app.gamenative.mods.ModProfileOverlayTransition import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.flow.MutableStateFlow @@ -10,6 +14,7 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.test.runTest import kotlinx.coroutines.yield import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Test @@ -96,6 +101,58 @@ class NexusModsDialogHelpersTest { assertEquals("", drafts.last().targetRoot) } + @Test + fun collectionEmbeddedMetadata_avoidsSeparateModInfoLookup() { + val collectionFile = NexusCollectionFile( + gameDomain = "skyrimspecialedition", + modId = 123L, + fileId = 456L, + modName = "Cloaks", + fileName = "Cloaks-456.7z", + version = "1.2.1", + sizeBytes = 42L, + ) + + assertEquals("Cloaks", collectionFile.toEmbeddedNexusModInfo()?.name) + assertEquals("Cloaks-456.7z", collectionFile.toFallbackNexusFile()?.fileName) + } + + @Test + fun applyOrder_doesNotRebuildOrReapplyManagedConflictsWhenOrderIsAlreadyCurrent() { + val overlay = ModProfileOverlay(emptyMap(), emptyList()) + val unchanged = ModProfileOverlayTransition( + current = overlay, + desired = overlay, + changedWinnerKeys = emptyList(), + currentVerification = ModDeploymentVerification(emptyList()), + ) + val applied = install(status = ModInstallStatus.APPLIED) + + assertFalse(requiresManagedOverlayRebuild(setOf(applied.installId), setOf(applied.installId), unchanged)) + assertFalse( + shouldApplyProfileInstall( + install = applied, + hasActiveOwnership = true, + hasConflict = true, + needsAssetRepair = false, + hasMissingTarget = false, + ), + ) + } + + @Test + fun applyOrder_rebuildsManagedOverlayOnlyWhenAValidatedWinnerChanges() { + val overlay = ModProfileOverlay(emptyMap(), emptyList()) + val changed = ModProfileOverlayTransition( + current = overlay, + desired = overlay, + changedWinnerKeys = listOf("data/shared.txt"), + currentVerification = ModDeploymentVerification(emptyList()), + ) + + assertTrue(requiresManagedOverlayRebuild(setOf("low", "high"), setOf("low", "high"), changed)) + } + private fun install(status: ModInstallStatus): ModInstall = ModInstall( installId = "install", From f96b187795c1acbb41c8e44c8f52cc4006844f32 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Tue, 25 Aug 2026 11:19:31 -0500 Subject: [PATCH 41/60] fix: harden disabled and variant mod placement --- .../mods/AutomaticPlacementPlanner.kt | 155 +++++++++++++++++- .../gamenative/mods/FomodInstallPlanner.kt | 2 +- .../app/gamenative/mods/ModArchiveIndex.kt | 35 +++- .../gamenative/mods/ModDeploymentVerifier.kt | 2 +- .../app/gamenative/mods/ModPlacementPreset.kt | 2 + .../app/gamenative/mods/NexusModManager.kt | 24 ++- .../ui/component/dialog/NexusModsDialog.kt | 60 ++++++- .../dialog/NexusModsDialogHelpers.kt | 1 + .../dialog/NexusModsPlacementSections.kt | 62 ++++--- .../dialog/PlacementWorkspaceModels.kt | 19 ++- app/src/main/res/values/strings.xml | 3 + .../mods/AutomaticPlacementPlannerTest.kt | 86 ++++++++++ .../app/gamenative/mods/FomodInstallerTest.kt | 75 +++++++++ .../gamenative/mods/ModMaterializerTest.kt | 44 +++++ .../mods/ModOwnershipManifestTest.kt | 20 +++ .../dialog/PlacementWorkspaceModelsTest.kt | 12 ++ 16 files changed, 550 insertions(+), 52 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index 54aaff80c4..805f2cd1a3 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -20,6 +20,13 @@ data class AutomaticPlacementResult( val optionGroups: List = emptyList(), ) +data class AutomaticPlacementContext( + val defaultTargetRoot: String = ModTargetRoot.GAME_DIR.name, + val defaultTargetRelativePath: String = "", + val defaultTargetIsProven: Boolean = false, + val existingGameDirectories: Set = emptySet(), +) + object AutomaticPlacementPlanner { private val bethesdaRule = ModPlacementRulePacks.bethesda @@ -27,6 +34,7 @@ object AutomaticPlacementPlanner { gameName: String, entries: List, selectedOptions: Map = emptyMap(), + context: AutomaticPlacementContext = AutomaticPlacementContext(), ): AutomaticPlacementResult { val fullIndex = ModArchiveIndex.build(entries) val optionGroups = GenericOptionSetDetector.detect(fullIndex) @@ -59,6 +67,8 @@ object AutomaticPlacementPlanner { val generated = buildList { bethesdaCandidate(gameName, index)?.let(::add) frameworkCandidates(gameName, index).let(::addAll) + existingGameLayoutCandidate(index, context)?.let(::add) + provenPackageDirectoryCandidate(index, optionGroups, validSelections, context)?.let(::add) } val combined = generated.takeIf { candidates -> candidates.size > 1 } ?.flatMap { it.drafts } @@ -126,7 +136,12 @@ object AutomaticPlacementPlanner { ) } } - val recommended = recommendedBase?.let { base -> reviewed.firstOrNull { it.id == base.id } } + val recommendedIndex = recommendedBase?.let { base -> + ranked.indexOfFirst { candidate -> + candidate.id == base.id || candidate.plan.digest == base.plan.digest + } + } ?: -1 + val recommended = reviewed.getOrNull(recommendedIndex) return AutomaticPlacementResult(reviewed, recommended, optionGroups) } @@ -273,6 +288,140 @@ object AutomaticPlacementPlanner { } } + private fun existingGameLayoutCandidate( + index: ModArchiveIndex, + context: AutomaticPlacementContext, + ): AutomaticPlacementCandidate? { + if (index.hasFomod || context.existingGameDirectories.isEmpty()) return null + val existingByKey = context.existingGameDirectories + .associateBy { it.lowercase(Locale.ROOT) } + val matchingRoots = index.nodes + .asSequence() + .filter { node -> '/' !in node.displayPath && node.descendantFileCount > 0 } + .filter { node -> node.normalizedKey in existingByKey } + .filter { node -> index.filesUnder(node.displayPath).any { it.role == ArchiveContentRole.INSTALLABLE } } + .sortedBy { it.normalizedKey } + .toList() + if (matchingRoots.isEmpty()) return null + val drafts = matchingRoots.map { node -> + ModPlacementPresetDraft( + sourceSubpath = node.displayPath, + targetRelativePath = "", + targetRoot = ModTargetRoot.GAME_DIR.name, + mode = ModPlacementMode.OVERWRITE_COPY.name, + includeSourceDirectory = true, + ) + } + return candidateFromDrafts( + id = "rules:existing-game-layout-v1", + label = "Match existing game folders", + description = "Keeps archive folders whose names match folders already used by the game.", + drafts = drafts, + index = index, + origin = PlacementOrigin.GAME_RULE, + evidence = listOf("Matched existing game folders: ${matchingRoots.joinToString { it.displayPath }}"), + ) + } + + private fun provenPackageDirectoryCandidate( + index: ModArchiveIndex, + optionGroups: List, + selectedOptions: Map, + context: AutomaticPlacementContext, + ): AutomaticPlacementCandidate? { + if ( + index.hasFomod || + !context.defaultTargetIsProven || + context.defaultTargetRelativePath.isBlank() + ) { + return null + } + val installableFiles = index.files.filter { it.role == ArchiveContentRole.INSTALLABLE } + val topLevelRoots = installableFiles.mapNotNull { file -> + file.displayPath.substringBefore('/', "").takeIf(String::isNotBlank) + }.distinctBy { it.lowercase(Locale.ROOT) } + if (topLevelRoots.size != 1 || installableFiles.any { '/' !in it.displayPath }) return null + val packageRoot = topLevelRoots.single() + val packageName = packageRoot.substringAfterLast('/') + val sourceIsTargetContainer = context.defaultTargetRelativePath.substringAfterLast('/') + .equals(packageName, ignoreCase = true) + val packageTarget = if (sourceIsTargetContainer) { + context.defaultTargetRelativePath + } else { + listOf(context.defaultTargetRelativePath, packageName).filter(String::isNotBlank).joinToString("/") + } + val packageGroups = optionGroups.filter { group -> + group.choices.all { choice -> + choice.sourceDirectory.substringBeforeLast('/', "").equals(packageRoot, ignoreCase = true) + } + } + val selectedPackageGroups = packageGroups.mapNotNull { group -> + selectedOptions[group.stableId]?.let { selected -> group to selected } + } + val drafts = if (selectedPackageGroups.isEmpty()) { + listOf( + ModPlacementPresetDraft( + sourceSubpath = packageRoot, + targetRelativePath = context.defaultTargetRelativePath, + targetRoot = context.defaultTargetRoot, + mode = ModPlacementMode.OVERWRITE_COPY.name, + includeSourceDirectory = !sourceIsTargetContainer, + ), + ) + } else { + buildList { + selectedPackageGroups.forEach { (_, selected) -> + add( + ModPlacementPresetDraft( + sourceSubpath = selected, + targetRelativePath = packageTarget, + targetRoot = context.defaultTargetRoot, + mode = ModPlacementMode.OVERWRITE_COPY.name, + ), + ) + } + packageGroups.flatMap { it.commonSourceDirectories } + .distinctBy { it.lowercase(Locale.ROOT) } + .forEach { common -> + add( + ModPlacementPresetDraft( + sourceSubpath = common, + targetRelativePath = packageTarget, + targetRoot = context.defaultTargetRoot, + mode = ModPlacementMode.OVERWRITE_COPY.name, + includeSourceDirectory = true, + ), + ) + } + val directFiles = index.filesUnder(packageRoot).filter { file -> + file.displayPath.removePrefixCaseInsensitive("$packageRoot/").let { '/' !in it } + }.map { it.displayPath } + if (directFiles.isNotEmpty()) { + add( + ModPlacementPresetDraft( + sourceSubpath = ModPlacementSources.encode(directFiles), + targetRelativePath = packageTarget, + targetRoot = context.defaultTargetRoot, + mode = ModPlacementMode.OVERWRITE_COPY.name, + ), + ) + } + } + } + return candidateFromDrafts( + id = "rules:proven-package-directory-v1", + label = "Install package into ${context.defaultTargetRelativePath}", + description = "Preserves the package folder while applying only the selected package variant.", + drafts = drafts, + index = index, + origin = PlacementOrigin.GAME_RULE, + evidence = listOf( + "High-confidence mod directory: ${context.defaultTargetRelativePath}", + "Single package folder: $packageRoot", + ), + ) + } + private fun bethesdaSourceForFile(file: IndexedArchiveFile): String? { if (file.role != ArchiveContentRole.INSTALLABLE) return null val segments = file.displayPath.split('/') @@ -308,10 +457,10 @@ object AutomaticPlacementPlanner { source.substringAfterLast('/').takeIf { sourceIsDirectory && source.isNotBlank() && draft.includeSourceDirectory }, relative.takeIf(String::isNotBlank), ).joinToString("/") - val targetKey = WindowsPathIdentity.targetKey(ModTargetRoot.GAME_DIR.name, targetPath) + val targetKey = WindowsPathIdentity.targetKey(draft.targetRoot, targetPath) placedBySource[file.normalizedKey] = PlannedModFile( sourceRelativePath = file.displayPath, - targetRoot = ModTargetRoot.GAME_DIR.name, + targetRoot = draft.targetRoot, targetRelativePath = targetPath, normalizedTargetKey = targetKey, status = if (targetKey == null) PlannedFileStatus.UNSUPPORTED else PlannedFileStatus.PLACED, diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 6552d241b7..8bfb2c760a 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -137,7 +137,7 @@ object FomodPlanExpander { val index = planned.indexOf(loser.file) planned[index] = loser.file.copy( status = PlannedFileStatus.INTENTIONALLY_IGNORED, - reason = "Superseded by a higher-priority FOMOD mapping", + reason = "Replaced by selected FOMOD file ${winner.file.sourceRelativePath}", ) } } diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index bc23c3f8cf..dfe6b8a76c 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -39,17 +39,30 @@ data class ModArchiveIndex( val key = normalizedArchiveKey(sourcePath) ?: return emptyList() if (key.isBlank()) return files val prefix = "$key/" + val exactStart = lowerBound(key) + val prefixStart = lowerBound(prefix) + val result = mutableListOf() + var exactEnd = exactStart + while (exactEnd < files.size && files[exactEnd].normalizedKey == key) { + result += files[exactEnd] + exactEnd++ + } + var end = prefixStart + while (end < files.size && files[end].normalizedKey.startsWith(prefix)) { + result += files[end] + end++ + } + return result + } + + private fun lowerBound(key: String): Int { var low = 0 var high = files.size while (low < high) { val middle = (low + high) ushr 1 if (files[middle].normalizedKey < key) low = middle + 1 else high = middle } - var end = low - while (end < files.size && (files[end].normalizedKey == key || files[end].normalizedKey.startsWith(prefix))) { - end++ - } - return files.subList(low, end).toList() + return low } fun isDirectory(sourcePath: String): Boolean { @@ -60,7 +73,17 @@ data class ModArchiveIndex( companion object { private val semanticAnchors = ModPlacementRulePacks.archiveSemanticAnchors private val managerMetadataDirectories = setOf("bashtags", "omod conversion data") - private val documentationDirectories = setOf("doc", "docs", "documentation", "manual", "manuals", "readmes") + private val documentationDirectories = setOf( + "doc", + "docs", + "documentation", + "help", + "manual", + "manuals", + "readmes", + "screenshot", + "screenshots", + ) private val documentationNamePrefixes = setOf( "readme", "changelog", diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt index 63f176a0ef..35b91ef2cd 100644 --- a/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt @@ -111,7 +111,7 @@ object ModDeploymentVerifier { return ModDeploymentVerification( manifest.files .asSequence() - .filterNot { it.active } + .filter { !it.active && it.disposition == ModOwnedFileDisposition.STALE_PRESERVED } .flatMap { file -> session.verifyStale(File(file.targetPath), manifest.installId).asSequence() } .toList(), ) diff --git a/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt b/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt index f23c889f72..7c6e6e1b54 100644 --- a/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt +++ b/app/src/main/java/app/gamenative/mods/ModPlacementPreset.kt @@ -1,6 +1,7 @@ package app.gamenative.mods import app.gamenative.data.ModPlacementMode +import app.gamenative.data.ModTargetRoot import java.util.Locale data class ModPlacementPreset( @@ -13,6 +14,7 @@ data class ModPlacementPreset( data class ModPlacementPresetDraft( val sourceSubpath: String, val targetRelativePath: String, + val targetRoot: String = ModTargetRoot.GAME_DIR.name, val mode: String = ModPlacementMode.OVERWRITE_COPY.name, val includeSourceDirectory: Boolean = false, ) diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index 3a75b76f90..4c2560419f 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -69,6 +69,7 @@ enum class ModHealthSeverity { enum class ModHealthAction { REAPPLY_MISSING, RECONFIGURE, + REVIEW_PLACEMENT, REBUILD_PROFILE, ADOPT_OWNERSHIP, RESTORE_PREVIOUS, @@ -1256,11 +1257,24 @@ object NexusModManager { } } } else if (ownership != null) { - ModDeploymentVerifier.verifyStale(ownership).issues - .take(3) - .forEach { finding -> - add(ModHealthSeverity.WARNING, "Stale managed file was preserved", finding.targetPath, install) - } + val preserved = ownership.copy( + files = ownership.files.filter { file -> + file.normalizedTargetKey !in overlay.targets + }, + ) + val findings = ModDeploymentVerifier.verifyStale(preserved).issues + if (findings.isNotEmpty()) { + add( + ModHealthSeverity.WARNING, + "Disabled mod still has changed files in the game folder", + buildString { + append("${findings.size} changed file(s) were kept to avoid deleting user changes. They can still affect the game while this mod is disabled. Review the placement to decide what to keep or remove; Apply order will not remove them.") + findings.take(3).forEach { finding -> append("\n${finding.targetPath}") } + }, + install, + ModHealthAction.REVIEW_PLACEMENT, + ) + } } if (install.status == ModInstallStatus.READY.name && manifests.isNotEmpty()) { add(ModHealthSeverity.WARNING, "Ready mod has overwrite records", "This mod is not applied but still has ${manifests.size} overwrite record(s).", install) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 60a9f70efc..8d61890788 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -86,6 +86,7 @@ import app.gamenative.mods.BethesdaPluginManager import app.gamenative.mods.AuthorizedNexusWebsiteDownload import app.gamenative.mods.AutomaticPlacementPlanner import app.gamenative.mods.AutomaticPlacementCandidate +import app.gamenative.mods.AutomaticPlacementContext import app.gamenative.mods.AutomaticPlacementResult import app.gamenative.mods.BrowserFirstNexusWebsiteDownload import app.gamenative.mods.FomodInstaller @@ -703,8 +704,15 @@ private fun InstallHealthSection( } else { val summaryColor = if (current.errorCount > 0) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant Text(stringResource(R.string.nexus_install_health_summary, current.errorCount, current.warningCount), style = MaterialTheme.typography.bodySmall, color = summaryColor) - OutlinedButton(onClick = onRebuild, enabled = !loading, modifier = Modifier.fillMaxWidth()) { - Text(stringResource(R.string.nexus_apply_order)) + if ( + current.issues.any { + it.recommendedAction == ModHealthAction.REAPPLY_MISSING || + it.recommendedAction == ModHealthAction.REBUILD_PROFILE + } + ) { + OutlinedButton(onClick = onRebuild, enabled = !loading, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.nexus_apply_order)) + } } OutlinedButton(onClick = { onExport(current) }, enabled = !loading, modifier = Modifier.fillMaxWidth()) { Text(stringResource(R.string.nexus_plan_export)) @@ -724,7 +732,9 @@ private fun InstallHealthSection( -> onRebuild() ModHealthAction.ADOPT_OWNERSHIP -> onAdoptOwnership(issue.installId) ModHealthAction.RESTORE_PREVIOUS -> onRestorePrevious(issue.installId) - ModHealthAction.RECONFIGURE -> onReconfigure(issue.installId) + ModHealthAction.RECONFIGURE, + ModHealthAction.REVIEW_PLACEMENT, + -> onReconfigure(issue.installId) } }, ) { @@ -736,6 +746,7 @@ private fun InstallHealthSection( ModHealthAction.ADOPT_OWNERSHIP -> R.string.nexus_adopt_ownership ModHealthAction.RESTORE_PREVIOUS -> R.string.nexus_restore_previous_deployment ModHealthAction.RECONFIGURE -> R.string.nexus_configure + ModHealthAction.REVIEW_PLACEMENT -> R.string.nexus_review_placement }, ), ) @@ -867,6 +878,7 @@ fun NexusModsDialog( var placementOwnershipManifests by remember(libraryItem.appId) { mutableStateOf>(emptyList()) } var lastPlacementDrafts by remember(libraryItem.appId) { mutableStateOf>(emptyList()) } var detectedDefaultDraft by remember(libraryItem.appId) { mutableStateOf(null) } + var automaticPlacementContext by remember(libraryItem.appId) { mutableStateOf(AutomaticPlacementContext()) } val defaultDraft = detectedDefaultDraft ?: fallbackDefaultDraft var selectedTab by remember(libraryItem.appId) { mutableStateOf(ManageModsTab.MODS) } val recipeDrafts = remember { mutableStateListOf() } @@ -883,6 +895,7 @@ fun NexusModsDialog( archiveEntries, automaticOptionSelections, riskyAutomaticPlanApproved, + automaticPlacementContext, ) { val install = selectedInstall if (install == null || archiveEntries.isEmpty()) { @@ -897,6 +910,7 @@ fun NexusModsDialog( libraryItem.name, archiveEntries, automaticOptionSelections, + automaticPlacementContext, ) planned.copy( candidates = planned.candidates.map { candidate -> @@ -1239,15 +1253,27 @@ fun NexusModsDialog( LaunchedEffect(roots, gameRootDir, winePrefix, libraryItem.name) { detectedDefaultDraft = null - detectedDefaultDraft = withContext(Dispatchers.IO) { + automaticPlacementContext = AutomaticPlacementContext() + val detected = withContext(Dispatchers.IO) { + val existingGameDirectories = gameRootDir?.listFiles().orEmpty() + .filter { it.isDirectory } + .mapTo(linkedSetOf()) { it.name } BethesdaPluginManager.detectGame(libraryItem.name)?.let { game -> - return@withContext RecipeDraft( + val draft = RecipeDraft( targetRoot = ModTargetRoot.GAME_DIR.name, targetRelativePath = game.dataDirName, mode = ModPlacementMode.OVERWRITE_COPY.name, ) + return@withContext draft to AutomaticPlacementContext( + defaultTargetRoot = draft.targetRoot, + defaultTargetRelativePath = draft.targetRelativePath, + defaultTargetIsProven = true, + existingGameDirectories = existingGameDirectories, + ) } - val detectedDir = ModPathDetector.detect(gameRootDir, winePrefix, libraryItem.name) + val pathDetection = ModPathDetector.detect(gameRootDir, winePrefix, libraryItem.name) + val detectedDir = pathDetection + ?.takeIf { it.confidence == "HIGH" } ?.targetDirs ?.firstOrNull() ?.canonicalFile @@ -1262,11 +1288,19 @@ fun NexusModsDialog( } else { "" } - RecipeDraft( + val draft = RecipeDraft( targetRoot = root?.type?.name ?: ModTargetRoot.GAME_DIR.name, targetRelativePath = relative, ) + draft to AutomaticPlacementContext( + defaultTargetRoot = draft.targetRoot, + defaultTargetRelativePath = draft.targetRelativePath, + defaultTargetIsProven = detectedDir != null && relative.isNotBlank(), + existingGameDirectories = existingGameDirectories, + ) } + detectedDefaultDraft = detected.first + automaticPlacementContext = detected.second } LaunchedEffect(pendingCollectionSelection) { @@ -3247,6 +3281,7 @@ fun NexusModsDialog( gameRootDir = gameRootDir, winePrefix = winePrefix, allowOverwrite = allowOverwrite, + preserveStatusOnError = true, reviewedPlan = reviewedPlan, ) if (applied.errors.isEmpty()) { @@ -3286,7 +3321,9 @@ fun NexusModsDialog( } placementApplyStatusMessage = message SnackbarManager.show(message) - selectedInstall = install.copy(status = if (result.errors.isEmpty()) ModInstallStatus.APPLIED.name else ModInstallStatus.ERROR.name) + selectedInstall = install.copy( + status = if (result.errors.isEmpty()) ModInstallStatus.APPLIED.name else install.status, + ) } fun applyRecipes( @@ -3753,7 +3790,12 @@ fun NexusModsDialog( canUseLastPlacement = lastPlacementDrafts.isNotEmpty(), onPlacementChoiceChange = { choice -> placementApplyStatusMessage = null - reviewedPlacementPlan = null + val carriedAutomaticPlan = automaticPlacementResult?.recommended?.plan + ?.takeIf { + choice == PlacementChoice.CUSTOM && + placementChoice == PlacementChoice.AUTOMATIC + } + reviewedPlacementPlan = carriedAutomaticPlan val currentDrafts = recipeDrafts.toList() placementChoice = choice recipeDrafts.clear() diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt index 324e31d1af..4056ad16a0 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpers.kt @@ -272,6 +272,7 @@ internal fun automaticDraftsFor( return recommendation.drafts.map { draft -> fallback.copy( sourceSubpath = draft.sourceSubpath, + targetRoot = draft.targetRoot, targetRelativePath = draft.targetRelativePath, mode = draft.mode, includeSourceDirectory = draft.includeSourceDirectory, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 24cfd4c013..15d01ea878 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -617,6 +617,17 @@ private fun PlacementPlanReview( ), style = MaterialTheme.typography.bodySmall, ) + val replacedDefaultCount = plan.files.count { file -> + file.status == PlannedFileStatus.INTENTIONALLY_IGNORED && + file.reason.startsWith("Replaced by selected FOMOD file") + } + if (replacedDefaultCount > 0) { + Text( + stringResource(R.string.nexus_fomod_defaults_replaced, replacedDefaultCount), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.primary, + ) + } TextButton(onClick = { showWhy = !showWhy }) { Text(if (showWhy) stringResource(R.string.nexus_hide_placement_reason) else stringResource(R.string.nexus_why_this_placement)) } @@ -1104,30 +1115,35 @@ private fun PlacementDraftEditor( if (layout.visible) { Column(verticalArrangement = Arrangement.spacedBy(6.dp)) { - Text(stringResource(R.string.nexus_folder_layout), style = MaterialTheme.typography.labelLarge) - val names = layout.selectedNames.take(2).joinToString(", ") + if (layout.selectedNames.size > 2) ", ..." else "" - val contentsLabel = if (layout.multipleFolders) { - stringResource(R.string.nexus_merge_selected_folder_contents) - } else { - stringResource(R.string.nexus_install_contents_of, names) - } - val folderLabel = if (layout.multipleFolders) { - stringResource(R.string.nexus_keep_selected_folder_names) - } else { - stringResource(R.string.nexus_install_folder_and_contents, names) - } - PlacementChoiceButton( - text = contentsLabel + if (!recommendedKeepFolder) stringResource(R.string.nexus_recommended_suffix) else "", - selected = !draft.includeSourceDirectory, - onClick = { onUpdate(draft.copy(includeSourceDirectory = false)) }, - modifier = Modifier.fillMaxWidth(), - ) - PlacementChoiceButton( - text = folderLabel + if (recommendedKeepFolder) stringResource(R.string.nexus_recommended_suffix) else "", - selected = draft.includeSourceDirectory, - onClick = { onUpdate(draft.copy(includeSourceDirectory = true)) }, - modifier = Modifier.fillMaxWidth(), + Text( + stringResource(if (layout.editable) R.string.nexus_folder_layout else R.string.nexus_everything_folder_layout), + style = MaterialTheme.typography.labelLarge, ) + if (layout.editable) { + val names = layout.selectedNames.take(2).joinToString(", ") + if (layout.selectedNames.size > 2) ", ..." else "" + val contentsLabel = if (layout.multipleFolders) { + stringResource(R.string.nexus_merge_selected_folder_contents) + } else { + stringResource(R.string.nexus_install_contents_of, names) + } + val folderLabel = if (layout.multipleFolders) { + stringResource(R.string.nexus_keep_selected_folder_names) + } else { + stringResource(R.string.nexus_install_folder_and_contents, names) + } + PlacementChoiceButton( + text = contentsLabel + if (!recommendedKeepFolder) stringResource(R.string.nexus_recommended_suffix) else "", + selected = !draft.includeSourceDirectory, + onClick = { onUpdate(draft.copy(includeSourceDirectory = false)) }, + modifier = Modifier.fillMaxWidth(), + ) + PlacementChoiceButton( + text = folderLabel + if (recommendedKeepFolder) stringResource(R.string.nexus_recommended_suffix) else "", + selected = draft.includeSourceDirectory, + onClick = { onUpdate(draft.copy(includeSourceDirectory = true)) }, + modifier = Modifier.fillMaxWidth(), + ) + } Text( stringResource(R.string.nexus_folder_layout_result, layout.resultExample), style = MaterialTheme.typography.bodySmall, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index f64bc15e5a..97de948755 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -16,6 +16,7 @@ import java.util.Locale internal data class PlacementLayoutModel( val visible: Boolean, + val editable: Boolean, val multipleFolders: Boolean, val selectedNames: List, val resultExample: String, @@ -52,9 +53,10 @@ internal fun placementLayoutModel( entries: List, ): PlacementLayoutModel { if (draft.targetFileName.isNotBlank()) { - return PlacementLayoutModel(false, false, emptyList(), "", false) + return PlacementLayoutModel(false, false, false, emptyList(), "", false) } val sources = ModPlacementSources.decode(draft.sourceSubpath).filter(String::isNotBlank) + val selectingEverything = sources.isEmpty() val folders = sources.filter { source -> entries.any { entry -> val path = normalizeArchivePath(entry.path) @@ -62,16 +64,25 @@ internal fun placementLayoutModel( path.startsWith("${normalizeArchivePath(source)}/", ignoreCase = true) } } - val selectedNames = folders.map { it.substringAfterLast('/') }.distinct() + val selectedNames = if (selectingEverything) { + entries.mapNotNull { entry -> + normalizeArchivePath(entry.path).substringBefore('/', "").takeIf(String::isNotBlank) + }.distinctBy { it.lowercase(Locale.ROOT) } + } else { + folders.map { it.substringAfterLast('/') }.distinct() + } val destination = draft.targetRelativePath.trim('/').ifBlank { "" } val result = when { + selectingEverything && selectedNames.size == 1 -> "$destination/${selectedNames.single()}/" + selectingEverything -> "$destination/{${selectedNames.take(3).joinToString(", ")}${if (selectedNames.size > 3) ", ..." else ""}}/" selectedNames.isEmpty() || !draft.includeSourceDirectory -> "$destination/" selectedNames.size == 1 -> "$destination/${selectedNames.single()}/" else -> "$destination/{${selectedNames.take(3).joinToString(", ")}${if (selectedNames.size > 3) ", ..." else ""}}/" } return PlacementLayoutModel( - visible = folders.isNotEmpty(), - multipleFolders = folders.size > 1, + visible = selectedNames.isNotEmpty(), + editable = !selectingEverything, + multipleFolders = selectedNames.size > 1, selectedNames = selectedNames, resultExample = result, duplicateFolderWarning = draft.includeSourceDirectory && selectedNames.any { selected -> diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index cfb0fa08c8..2b0e24f59e 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1905,6 +1905,7 @@ Related archive files are missing from the game folder: %1$s FOMOD installer Configure + Review placement %1$d step(s), %2$d option(s) %1$d required file mapping(s) Complete required FOMOD groups: %1$s @@ -1981,6 +1982,7 @@ Hide advanced placement Automatic placement is recommended. Open advanced placement only to choose presets, reuse an earlier layout, or map files yourself. At the destination, install + Top-level folders keep their names; root files go directly in the destination Contents of %1$s %1$s folder and its contents Merge selected folder contents @@ -2098,6 +2100,7 @@ Refreshing install health Placement review %1$d of %2$d files planned • %3$d ignored • %4$d need review + %1$d default file(s) replaced by your FOMOD choices Ranked suggestions %1$d. %2$s — %3$d%% coverage Case merge: %1$s diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index ac80f2ffef..d9a1bb2857 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -160,6 +160,92 @@ class AutomaticPlacementPlannerTest { } } + @Test + fun existingGameFolders_outweighAnUnprovenSingleFolderGuess() { + val result = AutomaticPlacementPlanner.plan( + gameName = "Classic arena game", + entries = archive( + "Help/Map Readme.txt", + "Maps/CTF-Arena.ut2", + "Music/Arena.ogg", + "Screenshots/Arena.jpg", + ), + context = AutomaticPlacementContext( + defaultTargetRelativePath = "Sounds", + defaultTargetIsProven = false, + existingGameDirectories = setOf("Maps", "Music", "Sounds"), + ), + ) + val plan = result.recommended!!.plan + + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals( + setOf("Maps/CTF-Arena.ut2", "Music/Arena.ogg"), + plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet(), + ) + assertTrue( + plan.files.filter { it.sourceRelativePath.startsWith("Help/") || it.sourceRelativePath.startsWith("Screenshots/") } + .all { it.status == PlannedFileStatus.INTENTIONALLY_IGNORED }, + ) + } + + @Test + fun provenModDirectory_preservesPackageWrapperAndStripsOnlySelectedVariant() { + val entries = archive( + "CharacterEditor/v1/About/About.xml", + "CharacterEditor/v1/Assemblies/Editor.dll", + "CharacterEditor/v1.6/About/About.xml", + "CharacterEditor/v1.6/Assemblies/Editor.dll", + "CharacterEditor/Textures/Icon.png", + ) + val context = AutomaticPlacementContext( + defaultTargetRelativePath = "Mods", + defaultTargetIsProven = true, + ) + val initial = AutomaticPlacementPlanner.plan("Colony game", entries, context = context) + val optionGroup = initial.optionGroups.single() + val result = AutomaticPlacementPlanner.plan( + gameName = "Colony game", + entries = entries, + selectedOptions = mapOf(optionGroup.stableId to "CharacterEditor/v1.6"), + context = context, + ) + val plan = result.recommended!!.plan + + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals( + setOf( + "Mods/CharacterEditor/About/About.xml", + "Mods/CharacterEditor/Assemblies/Editor.dll", + "Mods/CharacterEditor/Textures/Icon.png", + ), + plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet(), + ) + assertTrue( + plan.files.filter { it.sourceRelativePath.startsWith("CharacterEditor/v1/") } + .all { it.status == PlannedFileStatus.INTENTIONALLY_IGNORED }, + ) + } + + @Test + fun provenTargetContainer_isMergedWithoutDuplicatingItsFolderName() { + val result = AutomaticPlacementPlanner.plan( + gameName = "Plugin game", + entries = archive("Mods/Example/About.xml", "Mods/Example/Runtime.dll"), + context = AutomaticPlacementContext( + defaultTargetRelativePath = "Mods", + defaultTargetIsProven = true, + ), + ) + val plan = result.recommended!!.plan + + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals( + setOf("Mods/Example/About.xml", "Mods/Example/Runtime.dll"), + plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet(), + ) + } + private fun archive(vararg paths: String): List = paths.map { ModArchiveEntry(it, directory = false, sizeBytes = 1L) } } diff --git a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt index 10af9dda09..12a0e5a4bf 100644 --- a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt @@ -394,6 +394,81 @@ class FomodInstallerTest { assertEquals(listOf("PatchA"), result.recipes.map { it.sourceSubpath }) } + @Test + fun equalPrioritySelectedBodyFiles_overrideRequiredDefaultsDuringMaterialization() = runBlocking { + val moduleConfig = writeModuleConfig( + """ + + Body installer fixture + + + + + + + + + + + + """.trimIndent(), + ) + val relativeBody = "meshes/actors/character/character assets/femalebody_0.nif" + File(tempDir, "00 Required (Slim)/$relativeBody").apply { + parentFile?.mkdirs() + writeText("slim-default") + } + File(tempDir, "00 Required (Slim)/CalienteTools/base.osd").apply { + parentFile?.mkdirs() + writeText("required") + } + File(tempDir, "02 Vanilla/$relativeBody").apply { + parentFile?.mkdirs() + writeText("vanilla-selected") + } + val installer = FomodParser.parse(moduleConfig, tempDir) + val result = FomodRecipeGenerator.generateForPluginKeys( + installId = "body", + installer = installer, + selectedPluginKeys = setOf(FomodRecipeGenerator.pluginKey(0, 0, 0)), + extractedRoot = tempDir, + ) + val plan = result.plan!! + + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals( + "02 Vanilla/$relativeBody", + plan.files.single { it.targetRelativePath == "Data/$relativeBody" && it.status == PlannedFileStatus.PLACED } + .sourceRelativePath, + ) + assertEquals( + PlannedFileStatus.INTENTIONALLY_IGNORED, + plan.files.single { it.sourceRelativePath == "00 Required (Slim)/$relativeBody" }.status, + ) + + val game = File(tempDir, "game").apply { mkdirs() } + val install = ModInstall( + installId = "body", + appId = "game", + modName = "Body installer fixture", + fileName = "fixture.zip", + archivePath = "", + extractedPath = tempDir.absolutePath, + ) + val materialization = ModMaterializer.materializationPlan( + install = install, + recipes = result.recipes, + gameRootDir = game, + winePrefix = "", + reviewedPlan = plan, + ) + val applied = ModMaterializer.apply(install, materialization, File(tempDir, "backups"), allowOverwrite = true) + + assertTrue(applied.errors.toString(), applied.errors.isEmpty()) + assertEquals("vanilla-selected", File(game, "Data/$relativeBody").readText()) + assertEquals("required", File(game, "Data/CalienteTools/base.osd").readText()) + } + @Test fun mcmHelperShape_plansAndAppliesEverySelectedFile() = runBlocking { val moduleConfig = writeModuleConfig( diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index ab995e67c1..5a3a3ef2e8 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -818,6 +818,50 @@ class ModMaterializerTest { assertFalse(created.exists()) } + @Test + fun reviewedPackageVariant_materializesInsideItsPreservedWrapper() = runBlocking { + val paths = listOf( + "CharacterEditor/v1/About/About.xml" to "old-version", + "CharacterEditor/v1/Assemblies/Editor.dll" to "old-version", + "CharacterEditor/v1.6/About/About.xml" to "selected-version", + "CharacterEditor/v1.6/Assemblies/Editor.dll" to "selected-version", + "CharacterEditor/Textures/Icon.png" to "common", + ) + paths.forEach { (path, contents) -> + File(extracted, path).apply { + parentFile?.mkdirs() + writeText(contents) + } + } + val entries = paths.map { (path, _) -> ModArchiveEntry(path, directory = false, sizeBytes = 1L) } + val context = AutomaticPlacementContext(defaultTargetRelativePath = "Mods", defaultTargetIsProven = true) + val initial = AutomaticPlacementPlanner.plan("Colony game", entries, context = context) + val group = initial.optionGroups.single() + val candidate = AutomaticPlacementPlanner.plan( + "Colony game", + entries, + selectedOptions = mapOf(group.stableId to "CharacterEditor/v1.6"), + context = context, + ).recommended!! + val recipes = candidate.drafts.map { draft -> + ModPlacementRecipe( + installId = "install", + sourceSubpath = draft.sourceSubpath, + targetRoot = draft.targetRoot, + targetRelativePath = draft.targetRelativePath, + mode = draft.mode, + includeSourceDirectory = draft.includeSourceDirectory, + ) + } + val plan = ModMaterializer.materializationPlan(install(), recipes, gameDir, "", reviewedPlan = candidate.plan) + val result = ModMaterializer.apply(install(), plan, backupDir, allowOverwrite = true) + + assertTrue(result.errors.toString(), result.errors.isEmpty()) + assertEquals("selected-version", File(gameDir, "Mods/CharacterEditor/Assemblies/Editor.dll").readText()) + assertEquals("common", File(gameDir, "Mods/CharacterEditor/Textures/Icon.png").readText()) + assertFalse(File(gameDir, "Mods/CharacterEditor/v1.6").exists()) + } + private fun install() = ModInstall( installId = "install", appId = "STEAM_1", diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt index 0a18502e79..3cc77cf643 100644 --- a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -91,6 +91,26 @@ class ModOwnershipManifestTest { ) } + @Test + fun staleVerification_checksOnlyFilesExplicitlyPreservedDuringDisable() { + val restoredTarget = temporaryFolder.newFile("restored.txt").apply { writeText("original") } + val preservedTarget = temporaryFolder.newFile("preserved.txt").apply { writeText("changed") } + val disabled = manifest("disabled", restoredTarget, "owned", priority = 1).copy( + state = ModOwnershipState.DISABLED, + files = listOf( + manifest("disabled", restoredTarget, "owned", priority = 1).files.single().copy(active = false), + manifest("disabled", preservedTarget, "owned", priority = 1).files.single().copy( + active = false, + disposition = ModOwnedFileDisposition.STALE_PRESERVED, + ), + ), + ) + + val findings = ModDeploymentVerifier.verifyStale(disabled).issues + + assertEquals(listOf(preservedTarget.absolutePath), findings.map { it.targetPath }) + } + @Test fun staleCleanup_removesOnlyUnchangedOwnedFiles() = runBlocking { val targetRoot = temporaryFolder.newFolder("game") diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt index 52a534d44d..46a33a9271 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt @@ -61,6 +61,18 @@ class PlacementWorkspaceModelsTest { assertTrue(folder.duplicateFolderWarning) } + @Test + fun everythingSelection_explainsThatThePackageFolderIsPreserved() { + val layout = placementLayoutModel( + RecipeDraft(targetRelativePath = "Mods"), + listOf(ModArchiveEntry("CharacterEditor/About/About.xml", directory = false, sizeBytes = 1)), + ) + + assertTrue(layout.visible) + assertFalse(layout.editable) + assertEquals("Mods/CharacterEditor/", layout.resultExample) + } + @Test fun virtualFolderName_rejectsTraversalReservedAndSeparators() { assertTrue(validVirtualDestinationFolderName("New Mods")) From d07a677d0bd61f6033f7494fbe37584771028f8d Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Tue, 25 Aug 2026 20:02:13 -0500 Subject: [PATCH 42/60] style: clean placement implementation --- .../app/gamenative/mods/ModArchiveIndex.kt | 4 +- .../gamenative/mods/ModDeploymentVerifier.kt | 6 +- .../app/gamenative/mods/NexusModManager.kt | 9 +- .../ui/component/dialog/NexusModsDialog.kt | 12 +- .../dialog/NexusModsPlacementSections.kt | 399 +++++++++--------- .../dialog/PlacementWorkspaceModels.kt | 8 +- 6 files changed, 235 insertions(+), 203 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index dfe6b8a76c..45eb693724 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -175,12 +175,14 @@ data class ModArchiveIndex( if (normalized.contains("/fomod/") || normalized.startsWith("fomod/")) { return ArchiveContentRole.INSTALLER_SUPPORT } + val rootDocumentation = + segments.size == 1 && listOf(".htm", ".html", ".rtf").any(name::endsWith) if ( segments.dropLast(1).any { it in documentationDirectories } || documentationNamePrefixes.any(name::startsWith) || name.endsWith(".md") || name.endsWith(".pdf") || - segments.size == 1 && listOf(".htm", ".html", ".rtf").any(name::endsWith) + rootDocumentation ) { return ArchiveContentRole.DOCUMENTATION } diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt index 35b91ef2cd..9ea6c8bf16 100644 --- a/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentVerifier.kt @@ -132,7 +132,11 @@ object ModDeploymentVerifier { resolution.issue?.let { return listOf(it) } val actual = resolution.actual if (actual == null) { - return if (stale) emptyList() else listOf(issue(ModVerificationIssueType.MISSING, target, "Required planned file is missing", installId)) + return if (stale) { + emptyList() + } else { + listOf(issue(ModVerificationIssueType.MISSING, target, "Required planned file is missing", installId)) + } } if (stale) { return listOf(issue(ModVerificationIssueType.STALE, actual, "A preserved stale managed file is still present", installId)) diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index 4c2560419f..b0c3a29259 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -762,7 +762,10 @@ object NexusModManager { created = 0, skipped = 0, backedUp = 0, - errors = mapOf(install.modName to "File tracking setup is only available for an older applied mod that is not tracked yet"), + errors = mapOf( + install.modName to + "File tracking setup is only available for an older applied mod that is not tracked yet", + ), manifests = emptyList(), ) } @@ -1268,7 +1271,9 @@ object NexusModManager { ModHealthSeverity.WARNING, "Disabled mod still has changed files in the game folder", buildString { - append("${findings.size} changed file(s) were kept to avoid deleting user changes. They can still affect the game while this mod is disabled. Review the placement to decide what to keep or remove; Apply order will not remove them.") + append("${findings.size} changed file(s) were kept to avoid deleting user changes. ") + append("They can still affect the game while this mod is disabled. ") + append("Review the placement to decide what to keep or remove; Apply order will not remove them.") findings.take(3).forEach { finding -> append("\n${finding.targetPath}") } }, install, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 8d61890788..7972fe6b73 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -3790,12 +3790,12 @@ fun NexusModsDialog( canUseLastPlacement = lastPlacementDrafts.isNotEmpty(), onPlacementChoiceChange = { choice -> placementApplyStatusMessage = null - val carriedAutomaticPlan = automaticPlacementResult?.recommended?.plan - ?.takeIf { - choice == PlacementChoice.CUSTOM && - placementChoice == PlacementChoice.AUTOMATIC - } - reviewedPlacementPlan = carriedAutomaticPlan + val carriedAutomaticPlan = automaticPlacementResult?.recommended?.plan + ?.takeIf { + choice == PlacementChoice.CUSTOM && + placementChoice == PlacementChoice.AUTOMATIC + } + reviewedPlacementPlan = carriedAutomaticPlan val currentDrafts = recipeDrafts.toList() placementChoice = choice recipeDrafts.clear() diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 15d01ea878..81f99bd5a7 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -204,9 +204,12 @@ internal fun PlacementSection( targetInspectionLoading = false } val applyBlocked = when { - placementChoice == PlacementChoice.AUTOMATIC -> automaticPlanLoading || targetInspectionLoading || - automaticPlan?.isComplete != true || - targetInspection?.ambiguousPaths?.isNotEmpty() == true + placementChoice == PlacementChoice.AUTOMATIC -> { + automaticPlanLoading || + targetInspectionLoading || + automaticPlan?.isComplete != true || + targetInspection?.ambiguousPaths?.isNotEmpty() == true + } visiblePlan != null -> !visiblePlan.isComplete else -> false } @@ -1080,11 +1083,12 @@ private fun PlacementDraftEditor( placementLayoutModel(draft, entries) } val recommendedKeepFolder = remember(draft.sourceSubpath, draft.targetRelativePath, entries, layout.visible) { - layout.visible && AutomaticPlacementPlanner.inferIncludeSourceDirectory( - selectedPaths = ModPlacementSources.decode(draft.sourceSubpath), - entries = entries, - targetRelativePath = draft.targetRelativePath, - ) + layout.visible && + AutomaticPlacementPlanner.inferIncludeSourceDirectory( + selectedPaths = ModPlacementSources.decode(draft.sourceSubpath), + entries = entries, + targetRelativePath = draft.targetRelativePath, + ) } Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { @@ -1600,228 +1604,241 @@ private fun ContainerDestinationPickerDialog( Modifier.padding(if (compactHeight) 12.dp else 20.dp), verticalArrangement = Arrangement.spacedBy(4.dp), ) { - Text( - stringResource(if (readOnly) R.string.nexus_destination_contents else R.string.nexus_destination_folder), - style = if (compactHeight) MaterialTheme.typography.titleLarge else MaterialTheme.typography.headlineSmall, - ) - if (currentDir == null || currentRoot == null) { Text( - text = stringResource(R.string.nexus_choose_game_container_location), - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, + stringResource(if (readOnly) R.string.nexus_destination_contents else R.string.nexus_destination_folder), + style = if (compactHeight) MaterialTheme.typography.titleLarge else MaterialTheme.typography.headlineSmall, ) - } else { - DestinationBreadcrumb(currentRoot, currentDir!!) { destination -> - currentDir = destination - selectedDestination = destination - query = "" + if (currentDir == null || currentRoot == null) { + Text( + text = stringResource(R.string.nexus_choose_game_container_location), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } else { + DestinationBreadcrumb(currentRoot, currentDir!!) { destination -> + currentDir = destination + selectedDestination = destination + query = "" + } } - } - if (roots.isNotEmpty()) { - Row( - modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), - horizontalArrangement = Arrangement.spacedBy(6.dp), - ) { - roots.forEach { root -> - OutlinedButton( - onClick = { - currentRootName = root.type.name - currentDir = root.dir - selectedDestination = root.dir - query = "" - }, - ) { - Text(root.label, maxLines = 1) + if (roots.isNotEmpty()) { + Row( + modifier = Modifier.fillMaxWidth().horizontalScroll(rememberScrollState()), + horizontalArrangement = Arrangement.spacedBy(6.dp), + ) { + roots.forEach { root -> + OutlinedButton( + onClick = { + currentRootName = root.type.name + currentDir = root.dir + selectedDestination = root.dir + query = "" + }, + ) { + Text(root.label, maxLines = 1) + } } } } } - } - if (currentDir != null) { - if (!compactHeight) Surface(modifier = Modifier.fillMaxWidth(), color = MaterialTheme.colorScheme.surfaceVariant) { - Row( - modifier = Modifier - .clickable { - val root = currentRoot - val parent = currentDir?.parentFile - currentDir = if (root != null && parent != null && parent.isInsideOrEqual(root.dir)) { - parent - } else { - null - } - selectedDestination = currentDir - query = "" + if (currentDir != null) { + if (!compactHeight) { + Surface(modifier = Modifier.fillMaxWidth(), color = MaterialTheme.colorScheme.surfaceVariant) { + Row( + modifier = Modifier + .clickable { + val root = currentRoot + val parent = currentDir?.parentFile + currentDir = if (root != null && parent != null && parent.isInsideOrEqual(root.dir)) { + parent + } else { + null + } + selectedDestination = currentDir + query = "" + } + .padding(horizontal = 20.dp, vertical = 10.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp), + ) { + Icon( + Icons.AutoMirrored.Filled.ArrowBack, + contentDescription = stringResource(R.string.back), + modifier = Modifier.size(18.dp), + ) + Text(currentDir?.name.orEmpty(), maxLines = 1, overflow = TextOverflow.Ellipsis) } - .padding(horizontal = 20.dp, vertical = 10.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(10.dp), - ) { - Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = stringResource(R.string.back), modifier = Modifier.size(18.dp)) - Text(currentDir?.name.orEmpty(), maxLines = 1, overflow = TextOverflow.Ellipsis) + } } + HorizontalDivider() + DestinationBrowserTools( + compact = compactHeight, + query = query, + onQueryChange = { query = it }, + showHidden = showHidden, + onShowHiddenChange = { showHidden = it }, + readOnly = readOnly, + onNewFolder = { + newFolderName = "" + showNewFolderDialog = true + }, + ) + HorizontalDivider() } - HorizontalDivider() - DestinationBrowserTools( - compact = compactHeight, - query = query, - onQueryChange = { query = it }, - showHidden = showHidden, - onShowHiddenChange = { showHidden = it }, - readOnly = readOnly, - onNewFolder = { - newFolderName = "" - showNewFolderDialog = true - }, - ) - HorizontalDivider() - } - if (currentDir == null) { - LazyColumn(modifier = Modifier.weight(1f).fillMaxWidth()) { - items(roots, key = { it.type.name }) { root -> - Row( - modifier = Modifier - .fillMaxWidth() - .clickable { - currentRootName = root.type.name - currentDir = root.dir - selectedDestination = root.dir - query = "" - } - .padding(horizontal = 20.dp, vertical = if (compactHeight) 8.dp else 12.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(12.dp), - ) { - Box( + if (currentDir == null) { + LazyColumn(modifier = Modifier.weight(1f).fillMaxWidth()) { + items(roots, key = { it.type.name }) { root -> + Row( modifier = Modifier - .size(36.dp) - .background( - color = MaterialTheme.colorScheme.primary.copy(alpha = 0.14f), - shape = RoundedCornerShape(8.dp), - ), - contentAlignment = Alignment.Center, + .fillMaxWidth() + .clickable { + currentRootName = root.type.name + currentDir = root.dir + selectedDestination = root.dir + query = "" + } + .padding(horizontal = 20.dp, vertical = if (compactHeight) 8.dp else 12.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), ) { + Box( + modifier = Modifier + .size(36.dp) + .background( + color = MaterialTheme.colorScheme.primary.copy(alpha = 0.14f), + shape = RoundedCornerShape(8.dp), + ), + contentAlignment = Alignment.Center, + ) { + Icon( + targetRootIcon(root.type), + contentDescription = null, + modifier = Modifier.size(20.dp), + tint = MaterialTheme.colorScheme.primary, + ) + } + Text(root.label, modifier = Modifier.weight(1f), maxLines = 1, overflow = TextOverflow.Ellipsis) Icon( - targetRootIcon(root.type), + Icons.AutoMirrored.Filled.ArrowForward, contentDescription = null, - modifier = Modifier.size(20.dp), - tint = MaterialTheme.colorScheme.primary, + modifier = Modifier.size(18.dp), + tint = MaterialTheme.colorScheme.onSurfaceVariant, ) } - Text(root.label, modifier = Modifier.weight(1f), maxLines = 1, overflow = TextOverflow.Ellipsis) - Icon( - Icons.AutoMirrored.Filled.ArrowForward, - contentDescription = null, - modifier = Modifier.size(18.dp), - tint = MaterialTheme.colorScheme.onSurfaceVariant, - ) } } - } - } else if (loading) { - Box(modifier = Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { - CircularProgressIndicator(modifier = Modifier.size(28.dp), strokeWidth = 3.dp) - } - } else if (browserEntries.isEmpty()) { - Box(modifier = Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { - Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(8.dp)) { - Icon( - Icons.Default.FolderOff, - contentDescription = null, - modifier = Modifier.size(32.dp), - tint = MaterialTheme.colorScheme.onSurfaceVariant, - ) - Text(stringResource(R.string.nexus_destination_folder_empty), color = MaterialTheme.colorScheme.onSurfaceVariant) + } else if (loading) { + Box(modifier = Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { + CircularProgressIndicator(modifier = Modifier.size(28.dp), strokeWidth = 3.dp) } - } - } else { - LazyColumn(modifier = Modifier.weight(1f).fillMaxWidth()) { - items(browserEntries, key = { "${it.file.absolutePath}:${it.virtual}" }) { entry -> - Row( - modifier = Modifier - .fillMaxWidth() - .clickable(enabled = entry.directory && !entry.virtual) { - currentDir = entry.file - selectedDestination = entry.file - query = "" - } - .padding(horizontal = 20.dp, vertical = if (compactHeight) 8.dp else 12.dp), - verticalAlignment = Alignment.CenterVertically, - horizontalArrangement = Arrangement.spacedBy(12.dp), - ) { + } else if (browserEntries.isEmpty()) { + Box(modifier = Modifier.weight(1f).fillMaxWidth(), contentAlignment = Alignment.Center) { + Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(8.dp)) { Icon( - if (entry.directory) Icons.Default.Folder else Icons.Default.Description, + Icons.Default.FolderOff, contentDescription = null, - tint = if (entry.directory) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant, + modifier = Modifier.size(32.dp), + tint = MaterialTheme.colorScheme.onSurfaceVariant, ) - Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) { - Text(entry.file.name, maxLines = 1, overflow = TextOverflow.Ellipsis) - DestinationEntryMetadata(entry, installNamesById, selectedInstallId) - } - if (entry.directory && !entry.virtual) { + Text( + stringResource(R.string.nexus_destination_folder_empty), + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } + } else { + LazyColumn(modifier = Modifier.weight(1f).fillMaxWidth()) { + items(browserEntries, key = { "${it.file.absolutePath}:${it.virtual}" }) { entry -> + Row( + modifier = Modifier + .fillMaxWidth() + .clickable(enabled = entry.directory && !entry.virtual) { + currentDir = entry.file + selectedDestination = entry.file + query = "" + } + .padding(horizontal = 20.dp, vertical = if (compactHeight) 8.dp else 12.dp), + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(12.dp), + ) { Icon( - Icons.AutoMirrored.Filled.ArrowForward, + if (entry.directory) Icons.Default.Folder else Icons.Default.Description, contentDescription = null, - modifier = Modifier.size(18.dp), - tint = MaterialTheme.colorScheme.onSurfaceVariant, + tint = if (entry.directory) { + MaterialTheme.colorScheme.primary + } else { + MaterialTheme.colorScheme.onSurfaceVariant + }, ) + Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(3.dp)) { + Text(entry.file.name, maxLines = 1, overflow = TextOverflow.Ellipsis) + DestinationEntryMetadata(entry, installNamesById, selectedInstallId) + } + if (entry.directory && !entry.virtual) { + Icon( + Icons.AutoMirrored.Filled.ArrowForward, + contentDescription = null, + modifier = Modifier.size(18.dp), + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } } + HorizontalDivider( + modifier = Modifier.padding(horizontal = 20.dp), + thickness = 0.5.dp, + color = MaterialTheme.colorScheme.outline.copy(alpha = 0.25f), + ) } - HorizontalDivider( - modifier = Modifier.padding(horizontal = 20.dp), - thickness = 0.5.dp, - color = MaterialTheme.colorScheme.outline.copy(alpha = 0.25f), - ) } } - } - HorizontalDivider() - Row( - modifier = Modifier - .fillMaxWidth() - .padding(horizontal = 20.dp, vertical = if (compactHeight) 6.dp else 12.dp), - horizontalArrangement = Arrangement.End, - verticalAlignment = Alignment.CenterVertically, - ) { - if (!readOnly) { - TextButton(onClick = onDismiss) { - Text(stringResource(R.string.cancel)) - } - } - val selectedRoot = currentRoot - val selectedDir = selectedDestination ?: currentDir - if (readOnly) { - Button(onClick = onDismiss, modifier = Modifier.padding(start = 8.dp)) { - Text(stringResource(R.string.close)) + HorizontalDivider() + Row( + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 20.dp, vertical = if (compactHeight) 6.dp else 12.dp), + horizontalArrangement = Arrangement.End, + verticalAlignment = Alignment.CenterVertically, + ) { + if (!readOnly) { + TextButton(onClick = onDismiss) { + Text(stringResource(R.string.cancel)) + } } - } else if (selectedRoot != null && selectedDir != null) { - Button( - onClick = { - val relative = runCatching { - selectedDir.canonicalFile.relativeToOrNull(selectedRoot.dir.canonicalFile) - ?.path - ?.replace(File.separatorChar, '/') - .orEmpty() - }.getOrDefault("") - onSelect( - currentDraft.copy( - targetRoot = selectedRoot.type.name, - targetRelativePath = relative, - ), - ) - }, - modifier = Modifier.padding(start = 8.dp), - ) { - Text(stringResource(R.string.nexus_select)) + val selectedRoot = currentRoot + val selectedDir = selectedDestination ?: currentDir + if (readOnly) { + Button(onClick = onDismiss, modifier = Modifier.padding(start = 8.dp)) { + Text(stringResource(R.string.close)) + } + } else if (selectedRoot != null && selectedDir != null) { + Button( + onClick = { + val relative = runCatching { + selectedDir.canonicalFile.relativeToOrNull(selectedRoot.dir.canonicalFile) + ?.path + ?.replace(File.separatorChar, '/') + .orEmpty() + }.getOrDefault("") + onSelect( + currentDraft.copy( + targetRoot = selectedRoot.type.name, + targetRelativePath = relative, + ), + ) + }, + modifier = Modifier.padding(start = 8.dp), + ) { + Text(stringResource(R.string.nexus_select)) + } } } } } } } - } if (showNewFolderDialog && !readOnly) { val validName = validVirtualDestinationFolderName(newFolderName) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index 97de948755..543518d62c 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -74,10 +74,14 @@ internal fun placementLayoutModel( val destination = draft.targetRelativePath.trim('/').ifBlank { "" } val result = when { selectingEverything && selectedNames.size == 1 -> "$destination/${selectedNames.single()}/" - selectingEverything -> "$destination/{${selectedNames.take(3).joinToString(", ")}${if (selectedNames.size > 3) ", ..." else ""}}/" + selectingEverything -> + "$destination/{${selectedNames.take(3).joinToString(", ")}" + + "${if (selectedNames.size > 3) ", ..." else ""}}/" selectedNames.isEmpty() || !draft.includeSourceDirectory -> "$destination/" selectedNames.size == 1 -> "$destination/${selectedNames.single()}/" - else -> "$destination/{${selectedNames.take(3).joinToString(", ")}${if (selectedNames.size > 3) ", ..." else ""}}/" + else -> + "$destination/{${selectedNames.take(3).joinToString(", ")}" + + "${if (selectedNames.size > 3) ", ..." else ""}}/" } return PlacementLayoutModel( visible = selectedNames.isNotEmpty(), From fd9acf616fba0ddc78553729a70179cb876de661 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Tue, 25 Aug 2026 23:24:41 -0500 Subject: [PATCH 43/60] fix: harden variant and FOMOD placement failures --- .../mods/AutomaticPlacementPlanner.kt | 8 +- .../gamenative/mods/FomodInstallPlanner.kt | 23 +++--- .../mods/GenericOptionSetDetector.kt | 16 +++- .../app/gamenative/mods/ModArchiveIndex.kt | 1 + .../ui/component/dialog/NexusModsDialog.kt | 64 +++++++++++++++- .../dialog/NexusModsFomodSections.kt | 43 +++++++++-- .../dialog/NexusModsPlacementSections.kt | 75 +++++++++++++++++-- app/src/main/res/values-da/strings.xml | 1 - app/src/main/res/values-de/strings.xml | 1 - app/src/main/res/values-es/strings.xml | 1 - app/src/main/res/values-fr/strings.xml | 1 - app/src/main/res/values-it/strings.xml | 1 - app/src/main/res/values-ja/strings.xml | 1 - app/src/main/res/values-ko/strings.xml | 1 - app/src/main/res/values-pl/strings.xml | 1 - app/src/main/res/values-pt-rBR/strings.xml | 1 - app/src/main/res/values-ro/strings.xml | 1 - app/src/main/res/values-ru/strings.xml | 1 - app/src/main/res/values-uk/strings.xml | 1 - app/src/main/res/values-zh-rCN/strings.xml | 1 - app/src/main/res/values-zh-rTW/strings.xml | 1 - app/src/main/res/values/strings.xml | 6 +- .../mods/AutomaticPlacementPlannerTest.kt | 74 ++++++++++++++++++ .../gamenative/mods/FomodEnvironmentTest.kt | 17 +++++ .../app/gamenative/mods/FomodInstallerTest.kt | 30 +++++++- .../dialog/NexusModsDialogHelpersTest.kt | 8 ++ 26 files changed, 334 insertions(+), 45 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index 805f2cd1a3..f3692de14e 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -39,9 +39,11 @@ object AutomaticPlacementPlanner { val fullIndex = ModArchiveIndex.build(entries) val optionGroups = GenericOptionSetDetector.detect(fullIndex) val validSelections = optionGroups.mapNotNull { group -> - selectedOptions[group.stableId] - ?.takeIf { selected -> group.choices.any { it.sourceDirectory == selected } } - ?.let { group.stableId to it } + val saved = selectedOptions[group.stableId] ?: selectedOptions.values.singleOrNull { saved -> + group.choices.any { it.sourceDirectory.equals(saved, ignoreCase = true) } + } + group.choices.firstOrNull { it.sourceDirectory.equals(saved, ignoreCase = true) } + ?.let { group.stableId to it.sourceDirectory } }.toMap() val excludedOptionRoots = optionGroups.flatMap { group -> val selected = validSelections[group.stableId] diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 8bfb2c760a..59ded9ef8d 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -14,6 +14,7 @@ data class FomodExpectedMapping( data class FomodSelectionEvaluation( val mappings: List, val flags: Map, + val warnings: List, val blockingIssues: List, ) @@ -44,13 +45,17 @@ object FomodSelectionEvaluator { } } } + val moduleDependencyState = installer.moduleDependencies.evaluate(flags, environment) + val warnings = buildList { + if (moduleDependencyState == FomodFactState.UNKNOWN && installer.moduleDependencies.hasFacts()) { + add("FOMOD game requirements could not be verified; the selected package version will be used") + } + } val blockers = buildList { addAll(installer.unsupportedWarnings) - when (installer.moduleDependencies.evaluate(flags, environment)) { + when (moduleDependencyState) { FomodFactState.FALSE -> add("The installed game does not satisfy this FOMOD's requirements") - FomodFactState.UNKNOWN -> if (installer.moduleDependencies.hasFacts()) { - add("FOMOD game requirements could not be determined safely") - } + FomodFactState.UNKNOWN -> Unit FomodFactState.TRUE -> Unit } if (installer.conditionalFileInstalls.any { it.dependencies.evaluate(flags, environment) == FomodFactState.UNKNOWN }) { @@ -72,7 +77,7 @@ object FomodSelectionEvaluator { add("FOMOD option availability depends on unknown game facts") } } - return FomodSelectionEvaluation(expected, flags, blockers.distinct()) + return FomodSelectionEvaluation(expected, flags, warnings.distinct(), blockers.distinct()) } private fun FomodDependencyExpression.hasFacts(): Boolean = @@ -142,18 +147,14 @@ object FomodPlanExpander { } } planned += missing - val blockers = buildList { - addAll(evaluation.blockingIssues) - if (missing.isNotEmpty()) add("${missing.size} selected FOMOD mapping(s) have missing or mismatched sources") - if (planned.any { it.status == PlannedFileStatus.UNSUPPORTED }) add("Some selected FOMOD destinations are invalid") - } return PlacementRiskPolicy.enforce(ModInstallPlan( files = planned.sortedWith( compareBy { it.normalizedTargetKey.orEmpty() } .thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) } .thenByDescending { it.priority }, ), - blockingIssues = blockers.distinct(), + warnings = evaluation.warnings, + blockingIssues = evaluation.blockingIssues, producerId = "fomod", producerVersion = 1, )) diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt index e62dede151..df79401c65 100644 --- a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -47,12 +47,23 @@ object GenericOptionSetDetector { file.normalizedKey.removePrefix("${node.normalizedKey}/") } } + val versionChoices = siblings.filter { it.displayPath.substringAfterLast('/').isVersionChoiceName() } + .mapTo(mutableSetOf()) { it.normalizedKey } + val versionFamilyHasEvidence = versionChoices.size >= 3 || siblings.any { root -> + root.normalizedKey in versionChoices && siblings.any { other -> + other != root && other.normalizedKey in versionChoices && + signatures.getValue(root).intersect(signatures.getValue(other)).isNotEmpty() + } + } val related = siblings.associateWith { root -> siblings.filter { other -> if (root == other) return@filter false val overlap = signatures.getValue(root).intersect(signatures.getValue(other)).size val smaller = minOf(signatures.getValue(root).size, signatures.getValue(other).size).coerceAtLeast(1) - overlap > 0 && (overlap.toDouble() / smaller >= 0.6 || root.optionStyleWrapper || other.optionStyleWrapper) + val versionAlternatives = versionFamilyHasEvidence && + root.normalizedKey in versionChoices && other.normalizedKey in versionChoices + versionAlternatives || + (overlap > 0 && (overlap.toDouble() / smaller >= 0.6 || root.optionStyleWrapper || other.optionStyleWrapper)) } } val visited = mutableSetOf() @@ -87,4 +98,7 @@ object GenericOptionSetDetector { ) }.sortedBy { it.choices.first().sourceDirectory.lowercase(Locale.ROOT) } } + + private fun String.isVersionChoiceName(): Boolean = + matches(Regex("^v?\\d+(?:[._-]\\d+)+(?:[-_ ].*)?$", RegexOption.IGNORE_CASE)) } diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index 45eb693724..f5ced534ae 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -195,6 +195,7 @@ data class ModArchiveIndex( private fun looksLikeOptionWrapper(name: String): Boolean { val normalized = name.lowercase(Locale.ROOT) return Regex("^\\d{1,2}[ _.-]").containsMatchIn(normalized) || + Regex("^v?\\d+(?:[._-]\\d+)+(?:[-_ ].*)?$").matches(normalized) || listOf("optional", "option", "variant", "choose", "pick one").any(normalized::contains) } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 7972fe6b73..6edc2c7836 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -328,10 +328,18 @@ internal data class PendingFomodResult( val drafts: List, val plan: ModInstallPlan?, val unsupportedCount: Int, + val unresolvedDetails: List, + val blockingIssues: List, val selectedOptions: List, val conditionalRuleCount: Int, ) +internal data class PlacementApplyFailure( + val installId: String, + val installName: String, + val errors: Map, +) + internal data class PendingApply( val install: ModInstall, val recipes: List, @@ -762,6 +770,31 @@ private fun InstallHealthSection( } } +@Composable +private fun PlacementApplyFailureSection( + failure: PlacementApplyFailure, + onReconfigure: () -> Unit, +) { + NexusSectionCard { + Text( + stringResource(R.string.nexus_apply_failure_title), + style = MaterialTheme.typography.titleMedium, + fontWeight = FontWeight.SemiBold, + color = MaterialTheme.colorScheme.error, + ) + Text(failure.installName, style = MaterialTheme.typography.labelLarge) + Text( + stringResource(R.string.nexus_apply_failure_description), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + PlacementApplyFailureDetails(failure.errors) + OutlinedButton(onClick = onReconfigure, modifier = Modifier.fillMaxWidth()) { + Text(stringResource(R.string.nexus_review_placement)) + } + } +} + @OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class) @Composable fun NexusModsDialog( @@ -862,6 +895,7 @@ fun NexusModsDialog( var modApplyInProgress by remember { mutableStateOf(false) } var profileApplyInProgress by remember { mutableStateOf(false) } var placementApplyStatusMessage by remember { mutableStateOf(null) } + var placementApplyFailure by remember { mutableStateOf(null) } var pendingProfileNameEdit by remember { mutableStateOf(null) } var pendingProfileDelete by remember { mutableStateOf(null) } var placementChoice by remember { mutableStateOf(PlacementChoice.AUTOMATIC) } @@ -3301,6 +3335,7 @@ fun NexusModsDialog( selectedPreviousOwnership = ownership.second } val message = if (result.errors.isEmpty()) { + placementApplyFailure = null lastPlacementDrafts = recipes.map { it.toDraft() } placementNeededInstallIds = placementNeededInstallIds - install.installId val cleanupSuffix = if (result.warnings.isNotEmpty()) { @@ -3317,7 +3352,8 @@ fun NexusModsDialog( cleanupSuffix, ) } else { - context.getString(R.string.nexus_applied_with_errors, result.errors.size) + placementApplyFailure = PlacementApplyFailure(install.installId, install.modName, result.errors) + context.getString(R.string.nexus_apply_failed_rolled_back, result.errors.size) } placementApplyStatusMessage = message SnackbarManager.show(message) @@ -3344,6 +3380,11 @@ fun NexusModsDialog( applyRecipesInternal(install, recipes, allowOverwrite, reviewedPlan) } catch (e: Exception) { val message = e.message ?: context.getString(R.string.nexus_failed_to_apply_mod) + placementApplyFailure = PlacementApplyFailure( + install.installId, + install.modName, + mapOf(install.modName to message), + ) placementApplyStatusMessage = message SnackbarManager.show(message) } finally { @@ -3454,6 +3495,11 @@ fun NexusModsDialog( } } catch (e: Exception) { val message = e.message ?: context.getString(R.string.nexus_scan_placement_conflicts_failed) + placementApplyFailure = PlacementApplyFailure( + install.installId, + install.modName, + mapOf(install.modName to message), + ) placementApplyStatusMessage = message SnackbarManager.show(message) } finally { @@ -3511,7 +3557,8 @@ fun NexusModsDialog( fun exportHealthReport(report: ModHealthReport) = shareDiagnostic("mod-health-${libraryItem.appId}.txt", report.sanitizedManifest()) - val issueCount = conflictReports.size + bethesdaPluginIssues.size + bethesdaPluginAssetIssues.size + (healthReport?.issues?.size ?: 0) + val issueCount = conflictReports.size + bethesdaPluginIssues.size + bethesdaPluginAssetIssues.size + + (healthReport?.issues?.size ?: 0) + if (placementApplyFailure == null) 0 else 1 fun selectInstallForPlacement(install: ModInstall) { selectedInstall = install @@ -3874,6 +3921,10 @@ fun NexusModsDialog( recipeDrafts += resolvedDrafts }, applyStatusMessage = placementApplyStatusMessage, + applyErrors = placementApplyFailure + ?.takeIf { it.installId == install.installId } + ?.errors + .orEmpty(), onExportPlan = { plan -> exportPlacementPlan(install, plan) }, onSaveAndApply = ::saveAndApply, ) @@ -3881,6 +3932,15 @@ fun NexusModsDialog( } ManageModsTab.ISSUES -> { + placementApplyFailure?.let { failure -> + PlacementApplyFailureSection( + failure = failure, + onReconfigure = { + installs.firstOrNull { it.installId == failure.installId } + ?.let(::selectInstallForPlacement) + }, + ) + } InstallHealthSection( report = healthReport, loading = healthLoading, diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index 0f89977914..96dfeda5ea 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -55,6 +55,7 @@ import app.gamenative.mods.FomodGroupType import app.gamenative.mods.FomodEnvironmentSnapshot import app.gamenative.mods.FomodInstaller import app.gamenative.mods.ModInstallPlan +import app.gamenative.mods.PlannedFileStatus import app.gamenative.mods.FomodPluginType import app.gamenative.mods.FomodRecipeGenerator import app.gamenative.mods.effectiveType @@ -349,9 +350,17 @@ internal fun FomodWizardDialog( pendingResult = PendingFomodResult( drafts = result.recipes.map { it.toDraft() }, plan = result.plan, - unsupportedCount = result.plan?.let { plan -> - plan.unresolvedCount + plan.blockingIssues.size - } ?: (result.unsupportedMappings.size + result.blockingIssues.size), + unsupportedCount = result.plan?.unresolvedCount + ?: result.unsupportedMappings.size, + unresolvedDetails = result.plan?.files.orEmpty() + .filter { file -> + file.status == PlannedFileStatus.UNSUPPORTED || + file.status == PlannedFileStatus.MISSING || + file.status == PlannedFileStatus.CONFLICTED + } + .map { file -> "${file.sourceRelativePath}: ${file.reason}" }, + blockingIssues = result.plan?.blockingIssues + ?: result.blockingIssues, selectedOptions = selectedOptions, conditionalRuleCount = installer.conditionalFileInstalls.size, ) @@ -424,6 +433,22 @@ internal fun FomodWizardDialog( style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.error, ) + result.unresolvedDetails.take(4).forEach { detail -> + Text( + detail, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } + } + if (result.blockingIssues.isNotEmpty()) { + result.blockingIssues.take(4).forEach { issue -> + Text( + issue, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.error, + ) + } } result.selectedOptions.take(12).forEach { option -> Text(option, style = MaterialTheme.typography.bodySmall) @@ -443,9 +468,17 @@ internal fun FomodWizardDialog( pendingResult = null onApply(result.drafts, result.plan, result.unsupportedCount) }, - enabled = result.unsupportedCount == 0, + enabled = result.blockingIssues.isEmpty(), ) { - Text(stringResource(R.string.nexus_fomod_apply_choices)) + Text( + stringResource( + if (result.unsupportedCount > 0) { + R.string.nexus_review_placement + } else { + R.string.nexus_fomod_apply_choices + }, + ), + ) } }, dismissButton = { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 81f99bd5a7..08624ba5fd 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -163,6 +163,7 @@ internal fun PlacementSection( onRemoveDraft: (Int) -> Unit, onFomodRecipes: (List, ModInstallPlan?, Int) -> Unit, applyStatusMessage: String?, + applyErrors: Map = emptyMap(), onExportPlan: (ModInstallPlan) -> Unit, onSaveAndApply: () -> Unit, ) { @@ -329,6 +330,11 @@ internal fun PlacementSection( } } } else if (configuredPlan != null) { + val unresolvedSources = configuredPlan.files.filter { + it.status == PlannedFileStatus.UNSUPPORTED || + it.status == PlannedFileStatus.MISSING || + it.status == PlannedFileStatus.CONFLICTED + }.map { it.sourceRelativePath }.distinct() PlacementPlanReview( automaticPlacement = null, plan = configuredPlan, @@ -339,7 +345,9 @@ internal fun PlacementSection( ownershipManifests = ownershipManifests, selectedInstallId = install.installId, installNamesById = installNamesById, - onResolve = null, + onResolve = unresolvedSources.takeIf { it.isNotEmpty() }?.let { sources -> + { onResolveAutomaticPlan(sources) } + }, onUseCandidate = onUseAutomaticCandidate, onExport = { onExportPlan(configuredPlan) }, ) @@ -455,9 +463,12 @@ internal fun PlacementSection( Text( text = message, style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.primary, + color = if (applyErrors.isEmpty()) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.error, ) } + if (applyErrors.isNotEmpty()) { + PlacementApplyFailureDetails(applyErrors) + } if (canRestorePrevious) { OutlinedButton( @@ -549,6 +560,46 @@ internal fun PlacementSection( } } +@Composable +internal fun PlacementApplyFailureDetails(errors: Map) { + Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.errorContainer) { + Column(Modifier.fillMaxWidth().padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { + Text( + stringResource(R.string.nexus_apply_failure_details, errors.size), + style = MaterialTheme.typography.labelLarge, + color = MaterialTheme.colorScheme.onErrorContainer, + ) + errors.entries.take(8).forEach { (path, reason) -> + Text( + compactPlacementErrorPath(path), + style = MaterialTheme.typography.bodySmall, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.onErrorContainer, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + Text( + reason, + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onErrorContainer, + ) + } + if (errors.size > 8) { + Text( + stringResource(R.string.nexus_more_prefixed, errors.size - 8), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onErrorContainer, + ) + } + } + } +} + +internal fun compactPlacementErrorPath(path: String): String { + val normalized = path.replace('\\', '/').trimEnd('/') + return normalized.split('/').filter(String::isNotBlank).takeLast(4).joinToString("/").ifBlank { path } +} + @Composable private fun PlacementDraftPager( page: PlacementDraftPage, @@ -620,16 +671,30 @@ private fun PlacementPlanReview( ), style = MaterialTheme.typography.bodySmall, ) - val replacedDefaultCount = plan.files.count { file -> + val replacedDefaults = plan.files.filter { file -> file.status == PlannedFileStatus.INTENTIONALLY_IGNORED && file.reason.startsWith("Replaced by selected FOMOD file") } - if (replacedDefaultCount > 0) { + if (replacedDefaults.isNotEmpty()) { Text( - stringResource(R.string.nexus_fomod_defaults_replaced, replacedDefaultCount), + stringResource(R.string.nexus_fomod_defaults_replaced, replacedDefaults.size), style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.primary, ) + replacedDefaults.take(4).forEach { replaced -> + Text( + stringResource( + R.string.nexus_fomod_selected_winner, + replaced.targetRelativePath.orEmpty(), + replaced.reason.removePrefix("Replaced by selected FOMOD file "), + ), + style = MaterialTheme.typography.bodySmall, + fontFamily = FontFamily.Monospace, + color = MaterialTheme.colorScheme.primary, + maxLines = 2, + overflow = TextOverflow.Ellipsis, + ) + } } TextButton(onClick = { showWhy = !showWhy }) { Text(if (showWhy) stringResource(R.string.nexus_hide_placement_reason) else stringResource(R.string.nexus_why_this_placement)) diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 0a6d3149eb..de5dfe64af 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -1925,7 +1925,6 @@ Anvendelse af mod-filer Anvendte elementer: %1$d, sikkerhedskopier: %2$d%3$s ; gamle filer efterladt på plads: %1$d - Anvendt med fejl: %1$d Mod-filer anvendes allerede. Kunne ikke anvende mod Konfigurer FOMOD-installationsprogrammet, eller vælg Brugerdefineret placering, før du ansøger. diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 4d94d37a00..fcace679ea 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -1995,7 +1995,6 @@ Anwenden von Mod-Dateien Angewandte %1$d Artikel, gesichert %2$d%3$s ; alte Dateien an Ort und Stelle belassen: %1$d - Angewendet mit Fehlern: %1$d Mod-Dateien werden bereits angewendet. Mod konnte nicht angewendet werden Konfigurieren Sie vor der Anwendung das FOMOD-Installationsprogramm oder wählen Sie „Benutzerdefinierte Platzierung“. diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 37f37755a6..a9dcdc7bc9 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2053,7 +2053,6 @@ Aplicar archivos mod Elementos aplicados: %1$d, copias de seguridad: %2$d%3$s ; archivos antiguos dejados en su lugar: %1$d - Aplicado con errores: %1$d Los archivos Mod ya se están aplicando. No se pudo aplicar el mod Configure el instalador FOMOD o elija Ubicación personalizada antes de realizar la solicitud. diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 3efc09e35f..f2d91c6738 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2073,7 +2073,6 @@ Application des fichiers mod Éléments appliqués : %1$d, sauvegardes : %2$d%3$s ; anciens fichiers laissés en place : %1$d - Appliqué avec les erreurs %1$d Les fichiers Mod sont déjà appliqués. Échec de l\'application du mod Configurez le programme d\'installation FOMOD ou choisissez Placement personnalisé avant de postuler. diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 25638fb7f7..072ff4c045 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2046,7 +2046,6 @@ Applicazione dei file mod Elemento/i %1$d applicato/i, sottoposto a backup %2$d%3$s ; %1$d vecchi file lasciati al loro posto - Applicato con errore/i %1$d I file mod sono già applicati. Impossibile applicare il mod Configura il programma di installazione FOMOD o scegli Posizionamento personalizzato prima dell\'applicazione. diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 316e4bab93..73282bf068 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2011,7 +2011,6 @@ MOD ファイルの適用 適用された %1$d 項目、バックアップされた %2$d%3$s ; %1$d 古いファイルがそのまま残されている - %1$d エラーが適用されました Mod ファイルはすでに適用されています。 MODの適用に失敗しました 適用する前に、FOMOD インストーラーを設定するか、カスタム配置を選択してください。 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 5f75b9ae28..20c5bbbbc7 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2052,7 +2052,6 @@ 모드 파일 적용 적용됨 %1$d 항목, 백업됨 %2$d%3$s ; %1$d 이전 파일이 그대로 남아 있습니다. - %1$d 오류와 함께 적용됨 Mod 파일이 이미 적용되고 있습니다. 모드 적용 실패 적용하기 전에 FOMOD 설치 프로그램을 구성하거나 사용자 정의 배치를 선택하십시오. diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 1774bb9405..12e8198e54 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2055,7 +2055,6 @@ Stosowanie plików modów Zastosowane elementy: %1$d, kopie zapasowe: %2$d%3$s ; %1$d stare pliki pozostawione na miejscu - Zastosowano z błędami %1$d Pliki modów są już stosowane. Nie udało się zastosować mod Skonfiguruj instalator FOMOD lub przed zastosowaniem wybierz opcję Umieszczenie niestandardowe. diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 8b3643d622..a83f212632 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -1925,7 +1925,6 @@ Aplicando arquivos mod Itens aplicados: %1$d, backups: %2$d%3$s ; arquivos antigos deixados no lugar: %1$d - Aplicado com erros: %1$d Os arquivos Mod já estão sendo aplicados. Falha ao aplicar o mod Configure o instalador FOMOD ou escolha Posicionamento personalizado antes de aplicar. diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index bdd9922db5..fdd9ed28a4 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2057,7 +2057,6 @@ Aplicarea fișierelor mod Elemente aplicate: %1$d, copii de rezervă: %2$d%3$s ; fișiere vechi lăsate pe loc: %1$d - Aplicat cu erori: %1$d Fișierele mod sunt deja aplicate. Nu s-a aplicat mod Configurați programul de instalare FOMOD sau alegeți Plasare personalizată înainte de a aplica. diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 90655ecf78..eb063df73c 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -1983,7 +1983,6 @@ https://gamenative.app Применение файлов модов Применены элементы %1$d, резервная копия %2$d%3$s ; %1$d старые файлы остались на месте - Применяется при ошибках %1$d. Файлы модов уже применяются. Не удалось применить мод. Перед подачей заявки настройте установщик FOMOD или выберите «Пользовательское размещение». diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 36c4f3d4e9..adc52bf121 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2051,7 +2051,6 @@ Застосування файлів мод Застосовані елементи: %1$d, резервні копії: %2$d%3$s ; %1$d старі файли, залишені на місці - Застосовано з помилками %1$d Модифікаційні файли вже застосовуються. Не вдалося застосувати мод Налаштуйте інсталятор FOMOD або виберіть Нестандартне розміщення перед застосуванням. diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 2bffe6b840..2441078583 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2072,7 +2072,6 @@ 应用 mod 文件 已应用%1$d项目，备份%2$d%3$s ; %1$d 旧文件保留在原处 - 应用时出现 %1$d 错误 Mod 文件已被应用。 应用模组失败 配置FOMOD 安装程序或在应用之前选择自定义放置。 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 2079c42d2b..2a3e4d10c5 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2063,7 +2063,6 @@ 正在套用模組檔案 已套用 %1$d 個項目，備份 %2$d%3$s ; %1$d 個舊檔案保留在原處 - 套用時出現 %1$d 個錯誤 模組檔案已在套用中。 套用模組失敗 設定 FOMOD 安裝程式或在套用之前選擇自訂放置。 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 2b0e24f59e..eb1b65bdad 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2101,6 +2101,7 @@ Placement review %1$d of %2$d files planned • %3$d ignored • %4$d need review %1$d default file(s) replaced by your FOMOD choices + %1$s ← %2$s Ranked suggestions %1$d. %2$s — %3$d%% coverage Case merge: %1$s @@ -2173,7 +2174,10 @@ Applied %1$d item(s), backed up %2$d%3$s Placement complete for %1$d item(s): %2$d updated, %3$d already current, %4$d backed up%5$s ; %1$d old file(s) left in place - Applied with %1$d error(s) + Install failed; safe rollback attempted (%1$d error(s)) + Last mod install failed + The mod was not marked as applied. Changes were rolled back where they could be verified safely. Review the file errors below, then return to Placement to correct or retry this mod. + %1$d file error(s) Mod files are already being applied. Failed to apply mod Configure the FOMOD installer or choose Custom placement before applying. diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index d9a1bb2857..5dd0408179 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -227,6 +227,80 @@ class AutomaticPlacementPlannerTest { ) } + @Test + fun provenModDirectory_treatsDifferentlyShapedVersionFoldersAsOneChoice() { + val entries = archive( + "CharacterEditor/About/About.xml", + "CharacterEditor/Defs/CharEditor.xml", + "CharacterEditor/Textures/Icon.png", + "CharacterEditor/v1.0/0Harmony.dll", + "CharacterEditor/v1.0/CharacterEditor.dll", + "CharacterEditor/v1.1/Assemblies/CharacterEditor.dll", + "CharacterEditor/v1.3/Assemblies/CharacterEditor.dll", + "CharacterEditor/v1.3/Defs/GradientHairMasks.xml", + "CharacterEditor/v1.6/Assemblies/CharacterEditor.dll", + "CharacterEditor/v1.6/Defs/LifeStageGiant.xml", + "CharacterEditor/v1.6/Gradients/GradientHairMasks.xml", + ) + val context = AutomaticPlacementContext( + defaultTargetRelativePath = "Mods", + defaultTargetIsProven = true, + ) + val initial = AutomaticPlacementPlanner.plan("RimWorld", entries, context = context) + val optionGroup = initial.optionGroups.single() + + assertEquals( + setOf( + "CharacterEditor/v1.0", + "CharacterEditor/v1.1", + "CharacterEditor/v1.3", + "CharacterEditor/v1.6", + ), + optionGroup.choices.mapTo(mutableSetOf()) { it.sourceDirectory }, + ) + assertEquals( + setOf("CharacterEditor/About", "CharacterEditor/Defs", "CharacterEditor/Textures"), + optionGroup.commonSourceDirectories.toSet(), + ) + + val plan = AutomaticPlacementPlanner.plan( + gameName = "RimWorld", + entries = entries, + selectedOptions = mapOf("previous-detector-id" to "CharacterEditor/v1.6"), + context = context, + ).recommended!!.plan + + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals( + setOf( + "Mods/CharacterEditor/About/About.xml", + "Mods/CharacterEditor/Defs/CharEditor.xml", + "Mods/CharacterEditor/Textures/Icon.png", + "Mods/CharacterEditor/Assemblies/CharacterEditor.dll", + "Mods/CharacterEditor/Defs/LifeStageGiant.xml", + "Mods/CharacterEditor/Gradients/GradientHairMasks.xml", + ), + plan.files.filter { it.status == PlannedFileStatus.PLACED }.map { it.targetRelativePath }.toSet(), + ) + assertTrue( + plan.files.filter { "/v1." in it.sourceRelativePath && !it.sourceRelativePath.startsWith("CharacterEditor/v1.6/") } + .all { it.status == PlannedFileStatus.INTENTIONALLY_IGNORED }, + ) + } + + @Test + fun unrelatedPairOfNumberedFolders_isNotAssumedToBeAChoice() { + val result = AutomaticPlacementPlanner.plan( + gameName = "Numbered content", + entries = archive( + "Package/v1.0/Textures/First.dds", + "Package/v2.0/Sounds/Second.wav", + ), + ) + + assertTrue(result.optionGroups.isEmpty()) + } + @Test fun provenTargetContainer_isMergedWithoutDuplicatingItsFolderName() { val result = AutomaticPlacementPlanner.plan( diff --git a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt index 0f2ca576e5..2f126b33ec 100644 --- a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt @@ -53,6 +53,23 @@ class FomodEnvironmentTest { assertTrue(result.blockingIssues.any { "unknown" in it.lowercase() }) } + @Test + fun unknownModuleGameVersion_warnsWithoutBlockingExplicitChoices() { + val installer = FomodInstaller( + moduleName = "Versioned installer", + requiredFiles = emptyList(), + steps = emptyList(), + moduleDependencies = FomodDependencyExpression( + gameDependencies = listOf(FomodGameDependency("1.6.629")), + ), + ) + + val result = FomodSelectionEvaluator.evaluate(installer, emptySet()) + + assertTrue(result.blockingIssues.isEmpty()) + assertTrue(result.warnings.any { "could not be verified" in it }) + } + @Test fun environment_discoversScriptExtenderVersionAndDllArchitecture() { val root = createTempDirectory("fomod-environment").toFile() diff --git a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt index 12a0e5a4bf..5e7e9d564f 100644 --- a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt @@ -394,6 +394,26 @@ class FomodInstallerTest { assertEquals(listOf("PatchA"), result.recipes.map { it.sourceSubpath }) } + @Test + fun missingSelectedMapping_isAResolvableFileIssueWithoutADuplicateBlocker() { + val installer = FomodInstaller( + moduleName = "Missing source", + requiredFiles = listOf(FomodFileMapping("Missing.dll", "Missing.dll", priority = 0, directory = false)), + steps = emptyList(), + ) + + val plan = FomodRecipeGenerator.generateForPluginKeys( + installId = "missing", + installer = installer, + selectedPluginKeys = emptySet(), + extractedRoot = tempDir, + ).plan!! + + assertEquals(1, plan.unresolvedCount) + assertTrue(plan.blockingIssues.isEmpty()) + assertTrue(!plan.isComplete) + } + @Test fun equalPrioritySelectedBodyFiles_overrideRequiredDefaultsDuringMaterialization() = runBlocking { val moduleConfig = writeModuleConfig( @@ -405,11 +425,15 @@ class FomodInstallerTest { - - - + + Vanilla + + + + + """.trimIndent(), ) diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt index 8fb3a7386a..fdfe6ad61e 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/NexusModsDialogHelpersTest.kt @@ -101,6 +101,14 @@ class NexusModsDialogHelpersTest { assertEquals("", drafts.last().targetRoot) } + @Test + fun placementErrors_showTheUsefulPathTail() { + assertEquals( + "Mods/CharacterEditor/v1.6/CharacterEditor.dll", + compactPlacementErrorPath("/data/user/0/app/game/Mods/CharacterEditor/v1.6/CharacterEditor.dll"), + ) + } + @Test fun collectionEmbeddedMetadata_avoidsSeparateModInfoLookup() { val collectionFile = NexusCollectionFile( From 319b31a01aea657f542ca7ca74d165b01284f7e8 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Wed, 26 Aug 2026 20:17:25 -0500 Subject: [PATCH 44/60] fix: allow explicit choices with unknown FOMOD hints --- .../gamenative/mods/FomodInstallPlanner.kt | 12 ++--- .../gamenative/mods/FomodEnvironmentTest.kt | 46 +++++++++++++++++++ 2 files changed, 52 insertions(+), 6 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 59ded9ef8d..00e9e971f5 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -50,6 +50,12 @@ object FomodSelectionEvaluator { if (moduleDependencyState == FomodFactState.UNKNOWN && installer.moduleDependencies.hasFacts()) { add("FOMOD game requirements could not be verified; the selected package version will be used") } + if ( + installer.steps.flatMap { it.groups }.flatMap { it.plugins }.flatMap { it.typePatterns } + .any { it.dependencies.evaluate(flags, environment) == FomodFactState.UNKNOWN } + ) { + add("FOMOD option availability could not be verified; your explicit choices will be used") + } } val blockers = buildList { addAll(installer.unsupportedWarnings) @@ -70,12 +76,6 @@ object FomodSelectionEvaluator { ) { add("FOMOD option availability depends on unsupported game facts") } - if ( - installer.steps.flatMap { it.groups }.flatMap { it.plugins }.flatMap { it.typePatterns } - .any { it.dependencies.evaluate(flags, environment) == FomodFactState.UNKNOWN } - ) { - add("FOMOD option availability depends on unknown game facts") - } } return FomodSelectionEvaluation(expected, flags, warnings.distinct(), blockers.distinct()) } diff --git a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt index 2f126b33ec..764b33a450 100644 --- a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt @@ -70,6 +70,36 @@ class FomodEnvironmentTest { assertTrue(result.warnings.any { "could not be verified" in it }) } + @Test + fun unknownOptionAvailability_warnsWithoutBlockingSelectedVersion() { + val installer = FomodInstaller( + moduleName = "Version-gated installer", + requiredFiles = emptyList(), + steps = listOf( + FomodStep( + name = "Main", + groups = listOf( + FomodGroup( + name = "DLL", + type = FomodGroupType.SELECT_EXACTLY_ONE, + plugins = listOf( + versionedPlugin("New game version", "New/Example.dll", "1.6.629"), + versionedPlugin("Old game version", "Old/Example.dll", "1.6.353"), + ), + ), + ), + ), + ), + ) + + val selected = setOf(FomodRecipeGenerator.pluginKey(0, 0, 0)) + val result = FomodSelectionEvaluator.evaluate(installer, selected) + + assertEquals(listOf("New/Example.dll"), result.mappings.map { it.mapping.source }) + assertTrue(result.blockingIssues.isEmpty()) + assertTrue(result.warnings.any { "explicit choices" in it }) + } + @Test fun environment_discoversScriptExtenderVersionAndDllArchitecture() { val root = createTempDirectory("fomod-environment").toFile() @@ -109,5 +139,21 @@ class FomodEnvironmentTest { } } + private fun versionedPlugin(name: String, source: String, version: String) = FomodPlugin( + name = name, + description = "", + imagePath = "", + type = FomodPluginType.OPTIONAL, + files = listOf(FomodFileMapping(source, "SKSE/Plugins/Example.dll", 0, false)), + typePatterns = listOf( + FomodTypePattern( + dependencies = FomodDependencyExpression( + gameDependencies = listOf(FomodGameDependency(version)), + ), + type = FomodPluginType.RECOMMENDED, + ), + ), + ) + private fun assertTrue(value: Boolean) = org.junit.Assert.assertTrue(value) } From 0b39c9153e4b33d267b8beb2cfa5c2e90704f680 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Thu, 27 Aug 2026 11:03:31 -0500 Subject: [PATCH 45/60] fix: distinguish package variants from content folders --- .../mods/GenericOptionSetDetector.kt | 26 +++++++++++++- .../gamenative/mods/ModArchiveExtractor.kt | 2 ++ .../ui/component/dialog/NexusModsDialog.kt | 7 +--- .../mods/AutomaticPlacementPlannerTest.kt | 36 +++++++++++++++++++ 4 files changed, 64 insertions(+), 7 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt index df79401c65..53a3999e87 100644 --- a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -15,6 +15,13 @@ data class GenericOptionGroup( ) object GenericOptionSetDetector { + private val installBoundaryPrefixes = buildSet { + add("data") + ModPlacementRulePacks.builtIns + .flatMap { it.directoryTargets.values } + .mapTo(this) { normalizeArchiveDisplayPath(it).lowercase(Locale.ROOT) } + } + fun detect(index: ModArchiveIndex): List { if (index.hasFomod) return emptyList() val directories = index.nodes.filter { it.descendantFileCount > 0 } @@ -55,6 +62,19 @@ object GenericOptionSetDetector { signatures.getValue(root).intersect(signatures.getValue(other)).isNotEmpty() } } + val parentLooksLikeOptionContainer = siblings.first().normalizedKey + .substringBeforeLast('/', "") + .substringAfterLast('/') + .let { parent -> + listOf("option", "variant", "choose", "choice", "pick one").any(parent::contains) + } + val installBoundaries = siblings.associateWith { root -> + signatures.getValue(root).mapNotNullTo(mutableSetOf()) { relative -> + installBoundaryPrefixes.firstOrNull { boundary -> + relative == boundary || relative.startsWith("$boundary/") + } + } + } val related = siblings.associateWith { root -> siblings.filter { other -> if (root == other) return@filter false @@ -62,8 +82,12 @@ object GenericOptionSetDetector { val smaller = minOf(signatures.getValue(root).size, signatures.getValue(other).size).coerceAtLeast(1) val versionAlternatives = versionFamilyHasEvidence && root.normalizedKey in versionChoices && other.normalizedKey in versionChoices + val wrapperEvidence = root.optionStyleWrapper || + other.optionStyleWrapper || + parentLooksLikeOptionContainer || + installBoundaries.getValue(root).intersect(installBoundaries.getValue(other)).isNotEmpty() versionAlternatives || - (overlap > 0 && (overlap.toDouble() / smaller >= 0.6 || root.optionStyleWrapper || other.optionStyleWrapper)) + (wrapperEvidence && overlap > 0 && overlap.toDouble() / smaller >= 0.6) } } val visited = mutableSetOf() diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveExtractor.kt b/app/src/main/java/app/gamenative/mods/ModArchiveExtractor.kt index f92179943b..f5f057a283 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveExtractor.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveExtractor.kt @@ -371,6 +371,8 @@ object ModArchiveExtractor { return when { message.contains("encrypted", ignoreCase = true) -> UnsupportedModArchiveException("Encrypted $label archives are not supported") + message.contains("checksum", ignoreCase = true) -> + IOException("$label archive is damaged or incomplete (checksum validation failed). Retry the download.", error) message.contains("multi-volume", ignoreCase = true) || message.contains("multi volume", ignoreCase = true) || message.contains("volume", ignoreCase = true) -> diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 6edc2c7836..e15dc922cc 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -3837,12 +3837,7 @@ fun NexusModsDialog( canUseLastPlacement = lastPlacementDrafts.isNotEmpty(), onPlacementChoiceChange = { choice -> placementApplyStatusMessage = null - val carriedAutomaticPlan = automaticPlacementResult?.recommended?.plan - ?.takeIf { - choice == PlacementChoice.CUSTOM && - placementChoice == PlacementChoice.AUTOMATIC - } - reviewedPlacementPlan = carriedAutomaticPlan + reviewedPlacementPlan = null val currentDrafts = recipeDrafts.toList() placementChoice = choice recipeDrafts.clear() diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index 5dd0408179..0d4ce8dbac 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -301,6 +301,42 @@ class AutomaticPlacementPlannerTest { assertTrue(result.optionGroups.isEmpty()) } + @Test + fun ordinaryContentNamespacesWithMatchingLayouts_areNotPackageVariants() { + val cases = listOf( + archive( + "Package/dungeons/cove/shared/room.darkest", + "Package/dungeons/crypts/shared/room.darkest", + "Package/dungeons/town/shared/room.darkest", + ), + archive( + "CreativeMode/interface/cheatingtable/window.config", + "CreativeMode/interface/furnituretable/window.config", + "CreativeMode/interface/spawningtable/window.config", + ), + ) + + cases.forEach { entries -> + assertTrue(GenericOptionSetDetector.detect(ModArchiveIndex.build(entries)).isEmpty()) + } + } + + @Test + fun structuralWrappersAroundAnInstallRoot_areStillPackageVariants() { + val result = AutomaticPlacementPlanner.plan( + gameName = "Modded game", + entries = archive( + "Blue/Data/textures/shared.dds", + "Red/Data/textures/shared.dds", + ), + ) + + assertEquals( + setOf("Blue", "Red"), + result.optionGroups.single().choices.mapTo(mutableSetOf()) { it.sourceDirectory }, + ) + } + @Test fun provenTargetContainer_isMergedWithoutDuplicatingItsFolderName() { val result = AutomaticPlacementPlanner.plan( From 29f33190f0b279dee740495ae34ae729b6dcec8a Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Fri, 28 Aug 2026 19:39:09 -0500 Subject: [PATCH 46/60] fix: ignore documentation when detecting package variants --- .../mods/AutomaticPlacementPlanner.kt | 5 +++- .../mods/GenericOptionSetDetector.kt | 12 +++++--- .../app/gamenative/mods/ModArchiveIndex.kt | 14 ++++++++- .../dialog/NexusModsPlacementSections.kt | 21 +++++++++---- app/src/main/res/values/strings.xml | 2 +- .../mods/AutomaticPlacementPlannerTest.kt | 30 +++++++++++++++++++ 6 files changed, 71 insertions(+), 13 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index f3692de14e..34e5977524 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -448,7 +448,10 @@ object AutomaticPlacementPlanner { drafts.forEach { draft -> ModPlacementSources.decode(draft.sourceSubpath).ifEmpty { listOf("") }.forEach { source -> val sourceIsDirectory = source.isBlank() || index.isDirectory(source) - index.filesUnder(source).forEach { file -> + index.filesUnder(source).forEach fileLoop@ { file -> + if (!file.role.participatesInAutomaticPlacement() && file.role != ArchiveContentRole.INVALID) { + return@fileLoop + } val relative = when { source.isBlank() -> file.displayPath !sourceIsDirectory -> file.displayPath.substringAfterLast('/') diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt index 53a3999e87..96e800f1fd 100644 --- a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -50,11 +50,15 @@ object GenericOptionSetDetector { ): List { if (siblings.size < 2) return emptyList() val signatures = siblings.associateWith { node -> - index.filesUnder(node.displayPath).mapTo(mutableSetOf()) { file -> - file.normalizedKey.removePrefix("${node.normalizedKey}/") - } + index.filesUnder(node.displayPath) + .filter { it.role.participatesInAutomaticPlacement() } + .mapTo(mutableSetOf()) { file -> + file.normalizedKey.removePrefix("${node.normalizedKey}/") + } + } + val versionChoices = siblings.filter { + signatures.getValue(it).isNotEmpty() && it.displayPath.substringAfterLast('/').isVersionChoiceName() } - val versionChoices = siblings.filter { it.displayPath.substringAfterLast('/').isVersionChoiceName() } .mapTo(mutableSetOf()) { it.normalizedKey } val versionFamilyHasEvidence = versionChoices.size >= 3 || siblings.any { root -> root.normalizedKey in versionChoices && siblings.any { other -> diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index f5ced534ae..407a0c9ac2 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -178,7 +178,7 @@ data class ModArchiveIndex( val rootDocumentation = segments.size == 1 && listOf(".htm", ".html", ".rtf").any(name::endsWith) if ( - segments.dropLast(1).any { it in documentationDirectories } || + segments.dropLast(1).any(::isDocumentationDirectory) || documentationNamePrefixes.any(name::startsWith) || name.endsWith(".md") || name.endsWith(".pdf") || @@ -192,6 +192,15 @@ data class ModArchiveIndex( return ArchiveContentRole.INSTALLABLE } + private fun isDocumentationDirectory(segment: String): Boolean { + val name = segment.trim(' ', '_', '-', '.') + return name in documentationDirectories || + name.startsWith("readme") || + name.startsWith("documentation") || + name.startsWith("manual") || + name.startsWith("screenshot") + } + private fun looksLikeOptionWrapper(name: String): Boolean { val normalized = name.lowercase(Locale.ROOT) return Regex("^\\d{1,2}[ _.-]").containsMatchIn(normalized) || @@ -212,6 +221,9 @@ data class ModArchiveIndex( } } +internal fun ArchiveContentRole.participatesInAutomaticPlacement(): Boolean = + this == ArchiveContentRole.INSTALLABLE || this == ArchiveContentRole.RISKY_ROOT + internal fun normalizeArchiveDisplayPath(path: String): String = path.trim().replace('\\', '/').split('/').filter { it.isNotBlank() && it != "." }.joinToString("/") diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 08624ba5fd..c810c8c78f 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -753,14 +753,23 @@ private fun PlacementPlanReview( color = MaterialTheme.colorScheme.error, ) if (onResolve != null) { + val resolveCount = plan.unresolvedCount + ambiguousPaths.size Button(onClick = onResolve, modifier = Modifier.fillMaxWidth()) { - Text(stringResource(R.string.nexus_resolve_files, plan.unresolvedCount + ambiguousPaths.size)) + Text( + if (resolveCount > 0) { + stringResource(R.string.nexus_resolve_files, resolveCount) + } else { + stringResource(R.string.nexus_custom_placement) + }, + ) + } + if (resolveCount > 0) { + Text( + stringResource(R.string.nexus_resolve_files_description), + style = MaterialTheme.typography.bodySmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) } - Text( - stringResource(R.string.nexus_resolve_files_description), - style = MaterialTheme.typography.bodySmall, - color = MaterialTheme.colorScheme.onSurfaceVariant, - ) } } if (diff?.hasChanges == true) { diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index eb1b65bdad..7a3dc69b22 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1980,7 +1980,7 @@ Install method Advanced placement Hide advanced placement - Automatic placement is recommended. Open advanced placement only to choose presets, reuse an earlier layout, or map files yourself. + Automatic placement is a best estimate. Check that the planned files and destinations match the mod’s installation instructions. If they do not, open Advanced placement and choose Custom to map them yourself. At the destination, install Top-level folders keep their names; root files go directly in the destination Contents of %1$s diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index 0d4ce8dbac..481bf612ca 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -337,6 +337,36 @@ class AutomaticPlacementPlannerTest { ) } + @Test + fun readmeTrees_areIgnoredAndNeverBecomePackageVariants() { + val entries = archive( + "Campaign Module/Module.ini", + "Campaign Module/troops.txt", + "Campaign Module/_README_PACKAGE/OPTIONAL_FONT_ENG/font.dds", + "Campaign Module/_README_PACKAGE/OPTIONAL_FONT_RUS_UKR_ENG/font.dds", + ) + val result = AutomaticPlacementPlanner.plan( + gameName = "Module game", + entries = entries, + context = AutomaticPlacementContext( + defaultTargetRelativePath = "Modules", + defaultTargetIsProven = true, + ), + ) + + assertTrue(result.optionGroups.isEmpty()) + val plan = result.recommended!!.plan + assertTrue(plan.blockingIssues.toString(), plan.isComplete) + assertEquals( + setOf("Campaign Module/Module.ini", "Campaign Module/troops.txt"), + plan.files.filter { it.status == PlannedFileStatus.PLACED }.mapTo(mutableSetOf()) { it.sourceRelativePath }, + ) + assertTrue( + plan.files.filter { "/_README_PACKAGE/" in it.sourceRelativePath } + .all { it.status == PlannedFileStatus.INTENTIONALLY_IGNORED }, + ) + } + @Test fun provenTargetContainer_isMergedWithoutDuplicatingItsFolderName() { val result = AutomaticPlacementPlanner.plan( From dfd10d409dfc469972f3103aebc6ef3e7d82c4b7 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 5 Sep 2026 18:14:24 -0500 Subject: [PATCH 47/60] Harden mod placement validation and recovery --- .../java/app/gamenative/di/DatabaseModule.kt | 5 +- .../mods/AutomaticPlacementPlanner.kt | 8 +- .../app/gamenative/mods/FomodEnvironment.kt | 9 +- .../gamenative/mods/FomodInstallPlanner.kt | 2 +- .../app/gamenative/mods/FomodInstaller.kt | 19 +-- .../app/gamenative/mods/ModArchiveIndex.kt | 23 +++- .../gamenative/mods/ModDiagnosticSanitizer.kt | 6 + .../app/gamenative/mods/ModMaterializer.kt | 20 +++- .../gamenative/mods/ModOwnershipManifest.kt | 6 +- .../ui/component/dialog/NexusModsDialog.kt | 16 +-- .../dialog/NexusModsFomodSections.kt | 5 +- .../dialog/PlacementWorkspaceModels.kt | 3 +- .../mods/AutomaticPlacementPlannerTest.kt | 25 ++++ .../gamenative/mods/FomodEnvironmentTest.kt | 34 ++++++ .../app/gamenative/mods/FomodInstallerTest.kt | 51 ++++++++ .../mods/ModInstallPlanContractTest.kt | 4 +- .../gamenative/mods/ModMaterializerTest.kt | 111 ++++++++++++++++-- .../mods/ModOwnershipManifestTest.kt | 23 +++- 18 files changed, 316 insertions(+), 54 deletions(-) diff --git a/app/src/main/java/app/gamenative/di/DatabaseModule.kt b/app/src/main/java/app/gamenative/di/DatabaseModule.kt index 840e4a5712..d41a7034c4 100644 --- a/app/src/main/java/app/gamenative/di/DatabaseModule.kt +++ b/app/src/main/java/app/gamenative/di/DatabaseModule.kt @@ -39,7 +39,10 @@ class DatabaseModule { ROOM_MIGRATION_V24_to_V25, ROOM_MIGRATION_V25_to_V26, ) - .fallbackToDestructiveMigrationFrom(true, 16) + // Versions 1-6 predate the first retained migration. Version 16 has no + // 16 -> 17 migration because that historical schema could contain a + // duplicated column. Every newer supported schema migrates in place. + .fallbackToDestructiveMigrationFrom(true, 1, 2, 3, 4, 5, 6, 16) .build() } diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index 34e5977524..1ac4696dc1 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -95,7 +95,11 @@ object AutomaticPlacementPlanner { .thenBy { it.id }, ) val baseline = legacy.firstOrNull() - val bestGenerated = generatedCandidates.maxWithOrNull(compareBy { it.score }.thenBy { it.id }) + val bestGenerated = generatedCandidates.maxWithOrNull( + compareBy { it.plan.isComplete } + .thenBy { it.score } + .thenByDescending { it.id }, + ) val recommendedBase = when { bestGenerated == null -> baseline baseline == null -> bestGenerated @@ -462,7 +466,7 @@ object AutomaticPlacementPlanner { source.substringAfterLast('/').takeIf { sourceIsDirectory && source.isNotBlank() && draft.includeSourceDirectory }, relative.takeIf(String::isNotBlank), ).joinToString("/") - val targetKey = WindowsPathIdentity.targetKey(draft.targetRoot, targetPath) + val targetKey = ModTargetResolver.normalizedTargetKey(draft.targetRoot, targetPath) placedBySource[file.normalizedKey] = PlannedModFile( sourceRelativePath = file.displayPath, targetRoot = draft.targetRoot, diff --git a/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt index a7c65151d3..8bca257a4f 100644 --- a/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt +++ b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt @@ -110,8 +110,13 @@ object FomodEnvironmentSnapshotBuilder { (gameRootDir != null && resolveRequestedFile(gameRootDir, requested).isFile) } .mapTo(mutableSetOf()) { it.substringAfterLast('/').lowercase(Locale.ROOT) } - val activePlugins = pluginsFile?.takeIf(File::isFile)?.readLines().orEmpty() - .map { it.trim().removePrefix("*").substringBefore('#').trim().lowercase(Locale.ROOT) } + val pluginLines = pluginsFile?.takeIf(File::isFile)?.readLines().orEmpty() + .map { it.substringBefore('#').trim() } + .filter(String::isNotBlank) + val usesEnabledMarkers = pluginLines.any { it.startsWith('*') } + val activePlugins = pluginLines.asSequence() + .filter { !usesEnabledMarkers || it.startsWith('*') } + .map { it.removePrefix("*").trim().lowercase(Locale.ROOT) } .filterTo(mutableSetOf(), String::isNotBlank) val pluginMasters = presentPlugins.associateWith { plugin -> val file = resolveRequestedFile(gameRootDir, plugin) diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index 00e9e971f5..fe92f672c2 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -172,7 +172,7 @@ object FomodPlanExpander { destination: String, mode: String, ): ExpandedFomodFile { - val targetKey = WindowsPathIdentity.targetKey(targetRoot, destination) + val targetKey = ModTargetResolver.normalizedTargetKey(targetRoot, destination) return ExpandedFomodFile( file = PlannedModFile( sourceRelativePath = source.canonicalFile.relativeTo(extractedRoot).path.replace(File.separatorChar, '/'), diff --git a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt index b9e28b594b..e61f82f4bd 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt @@ -8,6 +8,7 @@ import org.w3c.dom.Node import timber.log.Timber import java.io.File import java.io.IOException +import java.util.Locale import javax.xml.parsers.DocumentBuilderFactory data class FomodInstaller( @@ -333,19 +334,19 @@ object FomodParser { ) } - private fun groupType(value: String): FomodGroupType = when (value.lowercase()) { + private fun groupType(value: String): FomodGroupType = when (value.lowercase(Locale.ROOT)) { "selectexactlyone" -> FomodGroupType.SELECT_EXACTLY_ONE "selectatmostone" -> FomodGroupType.SELECT_AT_MOST_ONE "selectatleastone" -> FomodGroupType.SELECT_AT_LEAST_ONE else -> FomodGroupType.SELECT_ANY } - private fun dependencyOperator(value: String): FomodDependencyOperator = when (value.lowercase()) { + private fun dependencyOperator(value: String): FomodDependencyOperator = when (value.lowercase(Locale.ROOT)) { "or" -> FomodDependencyOperator.OR else -> FomodDependencyOperator.AND } - private fun requiredFileState(value: String): FomodRequiredFileState = when (value.lowercase()) { + private fun requiredFileState(value: String): FomodRequiredFileState = when (value.lowercase(Locale.ROOT)) { "inactive" -> FomodRequiredFileState.INACTIVE "missing" -> FomodRequiredFileState.MISSING else -> FomodRequiredFileState.ACTIVE @@ -375,7 +376,7 @@ object FomodParser { .orEmpty() private fun pluginTypeFromName(typeName: String?): FomodPluginType = - when (typeName.orEmpty().lowercase()) { + when (typeName.orEmpty().lowercase(Locale.ROOT)) { "required" -> FomodPluginType.REQUIRED "recommended" -> FomodPluginType.RECOMMENDED "notusable" -> FomodPluginType.NOT_USABLE @@ -473,7 +474,7 @@ object FomodRecipeGenerator { ) } return FomodRecipeGenerationResult( - recipes = recipes.distinctBy { Triple(it.sourceSubpath, it.targetRoot, it.targetRelativePath + "/" + it.targetFileName) }, + recipes = recipes.distinctBy(::recipeIdentity), unsupportedMappings = emptyList(), plan = plan, blockingIssues = plan.blockingIssues, @@ -551,7 +552,6 @@ object FomodRecipeGenerator { mode: String, ): FomodRecipeGenerationResult { val recipes = mutableListOf() - val unsupported = mutableListOf() selectedFiles .sortedWith(compareBy { it.priority }.thenBy { it.source }) .forEach { mapping -> @@ -581,11 +581,14 @@ object FomodRecipeGenerator { } return FomodRecipeGenerationResult( - recipes = recipes.distinctBy { Triple(it.sourceSubpath, it.targetRoot, it.targetRelativePath) }, - unsupportedMappings = unsupported, + recipes = recipes.distinctBy(::recipeIdentity), + unsupportedMappings = emptyList(), ) } + private fun recipeIdentity(recipe: ModPlacementRecipe): List = + listOf(recipe.sourceSubpath, recipe.targetRoot, recipe.targetRelativePath, recipe.targetFileName) + private fun joinPath(left: String, right: String): String = listOf(left, right) .map { it.trim().trim('/', '\\') } diff --git a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt index 407a0c9ac2..96da067cf4 100644 --- a/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt +++ b/app/src/main/java/app/gamenative/mods/ModArchiveIndex.kt @@ -95,6 +95,8 @@ data class ModArchiveIndex( "install instructions", "installation instructions", ) + private val documentationExtensions = setOf("htm", "html", "md", "pdf", "rtf", "txt") + private val documentationBoundaries = setOf(' ', '_', '-', '.') fun build(entries: List): ModArchiveIndex { val indexedFiles = entries.asSequence() @@ -156,7 +158,8 @@ data class ModArchiveIndex( return ModArchiveIndex( files = indexedFiles, nodes = nodes, - caseCollisions = indexedFiles.groupBy { it.normalizedKey } + caseCollisions = indexedFiles.filter { it.normalizedKey.isNotBlank() } + .groupBy { it.normalizedKey } .filterValues { variants -> variants.map { it.displayPath }.distinct().size > 1 } .mapValues { (_, variants) -> variants.map { it.displayPath }.distinct().sorted() }, ) @@ -179,7 +182,7 @@ data class ModArchiveIndex( segments.size == 1 && listOf(".htm", ".html", ".rtf").any(name::endsWith) if ( segments.dropLast(1).any(::isDocumentationDirectory) || - documentationNamePrefixes.any(name::startsWith) || + looksLikeDocumentationFileName(name) || name.endsWith(".md") || name.endsWith(".pdf") || rootDocumentation @@ -195,12 +198,20 @@ data class ModArchiveIndex( private fun isDocumentationDirectory(segment: String): Boolean { val name = segment.trim(' ', '_', '-', '.') return name in documentationDirectories || - name.startsWith("readme") || - name.startsWith("documentation") || - name.startsWith("manual") || - name.startsWith("screenshot") + listOf("readme", "documentation", "manual", "screenshot").any { prefix -> hasPrefixAtBoundary(name, prefix) } } + private fun looksLikeDocumentationFileName(name: String): Boolean { + val extension = name.substringAfterLast('.', "") + return documentationNamePrefixes.any { prefix -> + hasPrefixAtBoundary(name, prefix) || + (name.startsWith(prefix) && extension in documentationExtensions) + } + } + + private fun hasPrefixAtBoundary(value: String, prefix: String): Boolean = + value.startsWith(prefix) && (value.length == prefix.length || value[prefix.length] in documentationBoundaries) + private fun looksLikeOptionWrapper(name: String): Boolean { val normalized = name.lowercase(Locale.ROOT) return Regex("^\\d{1,2}[ _.-]").containsMatchIn(normalized) || diff --git a/app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt b/app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt index 5decb6d565..c493d926dd 100644 --- a/app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt +++ b/app/src/main/java/app/gamenative/mods/ModDiagnosticSanitizer.kt @@ -1,14 +1,20 @@ package app.gamenative.mods object ModDiagnosticSanitizer { + private val urlUserInfo = Regex("(?i)(https?://)[^\\s/@]+@") private val urlQuery = Regex("(?i)(https?://[^\\s?#]+)\\?[^\\s#]+") private val signedQuery = Regex("(?i)([?&](?:token|key|auth|authorization|signature|sig|expires)\\s*=)[^&#\\s]+") + private val secretAssignment = Regex( + "(?i)\\b((?:api[-_ ]?key|token|authorization|auth|signature|secret)\\s*[:=]\\s*(?:bearer\\s+)?)[^&#\\s,;]+", + ) private val windowsPath = Regex("(?i)(?:[A-Z]:[\\\\/])(?:[^\\s\\r\\n]+)") private val androidPath = Regex("(? "${match.groupValues[1]}@" } .replace(urlQuery) { match -> "${match.groupValues[1]}?" } .replace(signedQuery) { match -> "${match.groupValues[1]}" } + .replace(secretAssignment) { match -> "${match.groupValues[1]}" } .replace(windowsPath, "") .replace(androidPath, "") .replace('\n', ' ') diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index 2c30841979..d6a57e7db1 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -196,6 +196,7 @@ object ModMaterializer { backupRoot: File, allowOverwrite: Boolean, ): ModPlacementResult = withContext(Dispatchers.IO) { + if (!plan.isComplete) return@withContext blockedResult(plan) var created = 0 var skipped = 0 var backedUp = 0 @@ -254,6 +255,7 @@ object ModMaterializer { captureTargetHashes = false, reviewedPlan = reviewedPlan, ) + if (!plan.isComplete) return@withContext blockedResult(plan) val errors = linkedMapOf().apply { putAll(plan.errors) } plan.operations.forEach { entry -> @@ -445,7 +447,7 @@ object ModMaterializer { } }.sortedWith(compareBy { it.normalizedTargetKey }.thenBy { it.sourceRelativePath.lowercase(Locale.ROOT) }) if (files.isEmpty()) { - errors[install.modName] = "The reviewed placement does not contain any materialized files" + errors[install.modName] = "The saved placement does not contain any files to install" } val manualPlan = PlacementRiskPolicy.enforce(ModInstallPlan( files = files.map { file -> @@ -453,7 +455,7 @@ object ModMaterializer { sourceRelativePath = file.sourceRelativePath, targetRoot = file.targetRoot, targetRelativePath = file.targetRelativePath, - normalizedTargetKey = WindowsPathIdentity.targetKey(file.targetRoot, file.targetRelativePath), + normalizedTargetKey = ModTargetResolver.normalizedTargetKey(file.targetRoot, file.targetRelativePath), status = PlannedFileStatus.PLACED, origin = PlacementOrigin.MANUAL_RECIPE, mode = file.mode.name, @@ -493,7 +495,7 @@ object ModMaterializer { source == null || !source.isFile -> errors[planned.sourceRelativePath] = "Reviewed source file is missing or case-ambiguous" targetRoot == null || targetRelativePath == null -> errors[planned.sourceRelativePath] = "Reviewed target is missing" else -> { - val logicalKey = WindowsPathIdentity.targetKey(targetRoot, targetRelativePath) + val logicalKey = ModTargetResolver.normalizedTargetKey(targetRoot, targetRelativePath) if (logicalKey == null || logicalKey != planned.normalizedTargetKey) { errors[planned.sourceRelativePath] = "Reviewed target identity changed before apply" return@forEach @@ -555,6 +557,18 @@ object ModMaterializer { return source.takeIf { it.path.startsWith(extractedRoot.path + File.separator) } } + private fun blockedResult(plan: ModMaterializationPlan): ModPlacementResult { + val errors = linkedMapOf().apply { + putAll(plan.errors) + plan.reviewedPlan.blockingIssues.forEachIndexed { index, issue -> putIfAbsent("plan:$index", issue) } + plan.reviewedPlan.files + .filter { it.status != PlannedFileStatus.PLACED && it.status != PlannedFileStatus.INTENTIONALLY_IGNORED } + .forEach { file -> putIfAbsent(file.sourceRelativePath, file.reason) } + if (isEmpty()) put("plan", "The reviewed placement plan is incomplete") + } + return ModPlacementResult(0, 0, 0, errors, emptyList()) + } + private fun plannedEntries( install: ModInstall, recipe: ModPlacementRecipe, diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index 948db67a56..78a846abd2 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -306,7 +306,11 @@ object ModProfileOverlayPlanner { ModDeploymentVerification(emptyList()) } else { ModDeploymentVerifier.verify( - current.copy(targets = current.targets.filterKeys(changedWinnerKeys::contains)), + // Reordering rebuilds the entire managed overlay, not only the + // targets whose winner changes. Verify every current winner so + // unrelated user edits cannot be removed during that rebuild. + current, + ModVerificationDepth.CHANGED_CONTENT, ) }, ) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index e15dc922cc..ab4389878c 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -1875,17 +1875,6 @@ fun NexusModsDialog( } effectiveAllowOverwrite = true } - if (plan.rebuildManagedOverlay && transactionDisabledSkipped > 0) { - return@withGameLock ProfileOrderApplyResult( - errors = 0, - bethesdaGame = null, - plugins = emptyList(), - pluginIssues = emptyList(), - pluginAssetIssues = emptyList(), - disabledSkipped = transactionDisabledSkipped, - ) - } - var errors = 0 for (install in plan.installsToApply) { val recipes = plan.recipesByInstallId[install.installId].orEmpty() @@ -1921,7 +1910,10 @@ fun NexusModsDialog( ) } errors += applyResult.errors.size - if (applyResult.errors.isNotEmpty()) break + // A rebuild disables every configured install first. Keep + // restoring later installs even if one plan fails so a + // single bad mod cannot leave the rest disabled. + if (applyResult.errors.isNotEmpty() && !plan.rebuildManagedOverlay) break } val game = BethesdaPluginManager.detectGame(libraryItem.name) if (errors == 0 && game != null) { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index 96dfeda5ea..e3989ad6f3 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -175,7 +175,10 @@ internal fun FomodWizardDialog( val allowed = group.plugins.indices.mapTo(mutableSetOf()) { pluginIndex -> FomodRecipeGenerator.pluginKey(parts[0], parts[1], pluginIndex) } - put(groupKey, selected.intersect(allowed)) + val restored = selected.intersect(allowed) + if (selected.isEmpty() || restored.isNotEmpty()) { + put(groupKey, restored) + } } } } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index 543518d62c..53263ff00e 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -7,6 +7,7 @@ import app.gamenative.mods.ModOwnershipState import app.gamenative.mods.ModPlacementSources import app.gamenative.mods.ModPlanChangeType import app.gamenative.mods.ModReconfigurationDiff +import app.gamenative.mods.ModTargetResolver import app.gamenative.mods.PlannedFileStatus import app.gamenative.mods.PlannedModFile import app.gamenative.mods.ResolvedModTargetRoot @@ -165,7 +166,7 @@ private fun destinationBrowserEntry( val relative = runCatching { file.canonicalFile.relativeTo(root.dir.canonicalFile).path.replace(File.separatorChar, '/') }.getOrDefault("") - val logicalKey = WindowsPathIdentity.targetKey(root.type.name, relative) + val logicalKey = ModTargetResolver.normalizedTargetKey(root.type.name, relative) val absoluteKey = WindowsPathIdentity.absoluteKey(file) val exactPlan = planFiles.filter { it.normalizedTargetKey == logicalKey } val directoryPrefix = logicalKey?.let { "$it/" } diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index 481bf612ca..0f14335cf7 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -367,6 +367,31 @@ class AutomaticPlacementPlannerTest { ) } + @Test + fun documentationPrefixes_doNotHideInstallableFoldersOrBinariesWithSimilarNames() { + val index = ModArchiveIndex.build( + archive( + "ManualTransmission/ManualTransmission.dll", + "ScreenshotsEnhanced/ScreenshotsEnhanced.esp", + "_README_PACKAGE/guide.txt", + "ReadMeFirst.txt", + ), + ) + + assertEquals( + ArchiveContentRole.INSTALLABLE, + index.files.single { it.displayPath.endsWith("ManualTransmission.dll") }.role, + ) + assertEquals( + ArchiveContentRole.INSTALLABLE, + index.files.single { it.displayPath.endsWith("ScreenshotsEnhanced.esp") }.role, + ) + assertTrue( + index.files.filter { it.displayPath.contains("README", ignoreCase = true) } + .all { it.role == ArchiveContentRole.DOCUMENTATION }, + ) + } + @Test fun provenTargetContainer_isMergedWithoutDuplicatingItsFolderName() { val result = AutomaticPlacementPlanner.plan( diff --git a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt index 764b33a450..f48ea29ace 100644 --- a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt @@ -129,6 +129,40 @@ class FomodEnvironmentTest { } } + @Test + fun environment_honorsModernPluginMarkersAndLegacyUnmarkedLists() { + val root = createTempDirectory("fomod-plugin-state").toFile() + try { + File(root, "Data/Enabled.esp").apply { parentFile?.mkdirs(); writeText("enabled") } + File(root, "Data/Disabled.esp").writeText("disabled") + val installer = FomodInstaller( + moduleName = "Plugin state", + requiredFiles = emptyList(), + steps = emptyList(), + moduleDependencies = FomodDependencyExpression( + pluginDependencies = listOf( + FomodPluginDependency("Enabled.esp", FomodRequiredFileState.ACTIVE), + FomodPluginDependency("Disabled.esp", FomodRequiredFileState.INACTIVE), + ), + ), + ) + val pluginsFile = File(root, "plugins.txt") + pluginsFile.writeText("*Enabled.esp\nDisabled.esp\n") + + val modern = FomodEnvironmentSnapshotBuilder.build(installer, "Skyrim Special Edition", root, pluginsFile) + + assertEquals(setOf("enabled.esp"), modern.activePlugins) + assertEquals(setOf("enabled.esp", "disabled.esp"), modern.presentPlugins) + + pluginsFile.writeText("Enabled.esp\nDisabled.esp\n") + val legacy = FomodEnvironmentSnapshotBuilder.build(installer, "Skyrim Special Edition", root, pluginsFile) + + assertEquals(setOf("enabled.esp", "disabled.esp"), legacy.activePlugins) + } finally { + root.deleteRecursively() + } + } + private fun peHeader(machine: Int): ByteArray = ByteArray(512).also { bytes -> bytes[0] = 'M'.code.toByte() bytes[1] = 'Z'.code.toByte() diff --git a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt index 5e7e9d564f..5e4f97d0c0 100644 --- a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt @@ -10,6 +10,7 @@ import org.junit.Assert.assertTrue import org.junit.Before import org.junit.Test import java.io.File +import java.util.Locale import kotlin.io.path.createTempDirectory class FomodInstallerTest { @@ -77,6 +78,40 @@ class FomodInstallerTest { assertEquals("1.6.0", installer.moduleDependencies.gameDependencies.single().version) } + @Test + fun parse_isIndependentOfTheDeviceLanguage() { + val previousLocale = Locale.getDefault() + try { + Locale.setDefault(Locale.forLanguageTag("tr-TR")) + val moduleConfig = writeModuleConfig( + """ + + + + + + + + + + + + + + + + """.trimIndent(), + ) + + val installer = FomodParser.parse(moduleConfig) + + assertEquals(FomodGroupType.SELECT_EXACTLY_ONE, installer.steps.single().groups.single().type) + assertEquals(FomodPluginType.REQUIRED, installer.steps.single().groups.single().plugins.single().type) + } finally { + Locale.setDefault(previousLocale) + } + } + @Test fun generate_convertsSelectedFilesToPlacementRecipes() { val installer = FomodInstaller( @@ -597,6 +632,22 @@ class FomodInstallerTest { ) } + @Test + fun generate_preservesDistinctDestinationNamesForTheSameSourceFile() { + val installer = FomodInstaller( + moduleName = "Renamed files", + requiredFiles = listOf( + FomodFileMapping("Shared/config.ini", "First.ini", 0, directory = false), + FomodFileMapping("Shared/config.ini", "Second.ini", 1, directory = false), + ), + steps = emptyList(), + ) + + val result = FomodRecipeGenerator.generate("install", installer, emptySet()) + + assertEquals(setOf("First.ini", "Second.ini"), result.recipes.mapTo(mutableSetOf()) { it.targetFileName }) + } + private fun writeModuleConfig(xml: String): File { val file = File(tempDir, "fomod/ModuleConfig.xml") file.parentFile?.mkdirs() diff --git a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt index a7219dd13b..4a4c536034 100644 --- a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt @@ -40,10 +40,12 @@ class ModInstallPlanContractTest { fun diagnosticSanitizer_removesCredentialsAndAbsolutePaths() { val sanitized = ModDiagnosticSanitizer.text( "C:\\Games\\Skyrim\\Data https://example.invalid/file?X-Amz-Credential=secret&X-Amz-Signature=123 " + - "/data/user/0/app/file", + "/data/user/0/app/file https://user:password@example.invalid/file " + + "Authorization: Bearer header-secret apikey=key-secret", ) assertFalse("secret" in sanitized) + assertFalse("password" in sanitized) assertFalse("C:\\Games" in sanitized) assertFalse("/data/user" in sanitized) } diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index 5a3a3ef2e8..d784996e57 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -452,7 +452,7 @@ class ModMaterializerTest { } @Test - fun overwriteCopy_partialApplyFailureCanBeRolledBack() = runBlocking { + fun overwriteCopy_invalidSavedPlacementFailsBeforeWritingFiles() = runBlocking { File(extracted, "new.txt").writeText("new") val install = install() val recipes = listOf( @@ -469,18 +469,6 @@ class ModMaterializerTest { allowOverwrite = true, ) assertTrue(result.errors.isNotEmpty()) - assertEquals("new", File(gameDir, "new.txt").readText()) - - val restoreSkipped = ModMaterializer.restoreBackups(result.manifests) - val restoredTargets = result.manifests.map { it.targetPath }.filterNot { it in restoreSkipped }.toSet() - ModMaterializer.removeAppliedFiles( - install = install, - recipes = recipes, - gameRootDir = gameDir, - winePrefix = "", - restoredOverwriteTargets = restoredTargets, - ) - assertFalse(File(gameDir, "new.txt").exists()) } @@ -862,6 +850,103 @@ class ModMaterializerTest { assertFalse(File(gameDir, "Mods/CharacterEditor/v1.6").exists()) } + @Test + fun apply_refusesToMaterializeAnyPartOfAnIncompleteReviewedPlan() = runBlocking { + File(extracted, "ready.txt").writeText("ready") + val targetPath = "Data/ready.txt" + val reviewed = ModInstallPlan( + files = listOf( + PlannedModFile( + sourceRelativePath = "ready.txt", + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = targetPath, + normalizedTargetKey = ModTargetResolver.normalizedTargetKey(ModTargetRoot.GAME_DIR.name, targetPath), + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.MANUAL_RECIPE, + reason = "fixture", + ), + PlannedModFile( + sourceRelativePath = "unresolved.txt", + status = PlannedFileStatus.UNSUPPORTED, + origin = PlacementOrigin.MANUAL_RECIPE, + reason = "No destination was proven", + ), + ), + ) + val plan = ModMaterializer.materializationPlan(install(), emptyList(), gameDir, "", reviewedPlan = reviewed) + + val result = ModMaterializer.apply(install(), plan, backupDir, allowOverwrite = true) + + assertEquals(0, result.created) + assertTrue(result.errors.containsKey("unresolved.txt")) + assertFalse(File(gameDir, targetPath).exists()) + } + + @Test + fun repairMissingTargets_refusesAnIncompleteReviewedPlan() = runBlocking { + File(extracted, "ready.txt").writeText("ready") + val targetPath = "Data/ready.txt" + val reviewed = ModInstallPlan( + files = listOf( + PlannedModFile( + sourceRelativePath = "ready.txt", + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = targetPath, + normalizedTargetKey = ModTargetResolver.normalizedTargetKey(ModTargetRoot.GAME_DIR.name, targetPath), + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.MANUAL_RECIPE, + reason = "fixture", + ), + PlannedModFile( + sourceRelativePath = "unresolved.txt", + status = PlannedFileStatus.UNSUPPORTED, + origin = PlacementOrigin.MANUAL_RECIPE, + reason = "No destination was proven", + ), + ), + ) + + val result = ModMaterializer.repairMissingTargets( + install = install().copy(status = ModInstallStatus.APPLIED.name), + recipes = emptyList(), + gameRootDir = gameDir, + winePrefix = "", + reviewedPlan = reviewed, + ) + + assertEquals(0, result.created) + assertTrue(result.errors.containsKey("unresolved.txt")) + assertFalse(File(gameDir, targetPath).exists()) + } + + @Test + fun reviewedCustomAbsoluteTarget_usesTheCanonicalTargetIdentity() = runBlocking { + File(extracted, "asset.bin").writeText("payload") + val target = File(gameDir, "Custom/asset.bin") + val reviewed = ModInstallPlan( + files = listOf( + PlannedModFile( + sourceRelativePath = "asset.bin", + targetRoot = ModTargetRoot.CUSTOM_ABSOLUTE.name, + targetRelativePath = target.absolutePath, + normalizedTargetKey = ModTargetResolver.normalizedTargetKey( + ModTargetRoot.CUSTOM_ABSOLUTE.name, + target.absolutePath, + ), + status = PlannedFileStatus.PLACED, + origin = PlacementOrigin.MANUAL_RECIPE, + reason = "fixture", + ), + ), + ).withRiskApproval(true) + val plan = ModMaterializer.materializationPlan(install(), emptyList(), gameDir, "", reviewedPlan = reviewed) + + val result = ModMaterializer.apply(install(), plan, backupDir, allowOverwrite = true) + + assertTrue(result.errors.toString(), result.errors.isEmpty()) + assertEquals("payload", target.readText()) + } + private fun install() = ModInstall( installId = "install", appId = "STEAM_1", diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt index 3cc77cf643..6d84100dde 100644 --- a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -61,6 +61,25 @@ class ModOwnershipManifestTest { assertTrue(transition.currentVerification.successful) } + @Test + fun overlayTransition_verifiesUnchangedTargetsBeforeRebuildingTheWholeOverlay() { + val shared = temporaryFolder.newFile("shared-rebuild.txt").apply { writeText("low") } + val unrelated = temporaryFolder.newFile("unrelated.txt").apply { writeText("owned") } + val low = manifest("low", shared, ModOwnershipStore.sha256(shared), priority = 20) + val high = manifest("high", shared, "different", priority = 10) + val other = manifest("other", unrelated, ModOwnershipStore.sha256(unrelated), priority = 5) + unrelated.appendText("-user edit") + + val transition = ModProfileOverlayPlanner.transition( + listOf(low, high, other), + desiredPriorities = mapOf("low" to 10, "high" to 20, "other" to 5), + ) + + assertTrue(transition.requiresRebuild) + assertFalse(transition.safeToRebuild) + assertEquals(listOf(unrelated.absolutePath), transition.currentVerification.issues.map { it.targetPath }) + } + @Test fun changedContentVerification_hashesOnlyWhenRecordedMetadataChanged() { val target = temporaryFolder.newFile("metadata.txt").apply { writeText("owned") } @@ -249,8 +268,8 @@ class ModOwnershipManifestTest { normalizedTargetKey = WindowsPathIdentity.absoluteKey(target), mode = ModPlacementMode.OVERWRITE_COPY.name, installedHash = hash, - installedSize = 1, - installedMtime = 1, + installedSize = target.takeIf(File::isFile)?.length() ?: 1, + installedMtime = target.takeIf(File::isFile)?.lastModified() ?: 1, disposition = ModOwnedFileDisposition.OVERWROTE, priority = priority, ), From d2223da53d2d714f797e82a327db9bd5fa6825e5 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 5 Sep 2026 18:20:03 -0500 Subject: [PATCH 48/60] Guard destination folder selection --- .../ui/component/dialog/NexusModsPlacementSections.kt | 8 +++++--- .../app/gamenative/mods/ModInstallPlanContractTest.kt | 2 ++ 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index c810c8c78f..5adf7b3be2 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -1940,10 +1940,12 @@ private fun ContainerDestinationPickerDialog( confirmButton = { Button( onClick = { - selectedDestination = File(currentDir, newFolderName.trim()) - showNewFolderDialog = false + currentDir?.let { parent -> + selectedDestination = File(parent, newFolderName.trim()) + showNewFolderDialog = false + } }, - enabled = validName, + enabled = validName && currentDir != null, ) { Text(stringResource(R.string.nexus_use_folder)) } }, dismissButton = { diff --git a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt index 4a4c536034..a6c2c9f9f2 100644 --- a/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModInstallPlanContractTest.kt @@ -74,11 +74,13 @@ class ModInstallPlanContractTest { fun oneRiskPolicy_protectsExecutableRootsRegardlessOfPlanOrigin() { val rootDll = file("dxgi.dll", PlannedFileStatus.PLACED, "FOMOD mapping").copy( targetRelativePath = "dxgi.dll", + normalizedTargetKey = "game_dir:dxgi.dll", origin = PlacementOrigin.FOMOD_OPTION, ) val dataDll = rootDll.copy( sourceRelativePath = "MCMHelper.dll", targetRelativePath = "Data/SKSE/Plugins/MCMHelper.dll", + normalizedTargetKey = "game_dir:data/skse/plugins/mcmhelper.dll", ) val guarded = PlacementRiskPolicy.enforce(ModInstallPlan(listOf(rootDll, dataDll))) From 089a33e391c479d552cc32cae6e54944ea52b31f Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 5 Sep 2026 18:29:33 -0500 Subject: [PATCH 49/60] Fix placement selection state and labels --- .../app/gamenative/ui/component/dialog/NexusModsDialog.kt | 8 +++++--- app/src/main/res/values-da/strings.xml | 2 +- app/src/main/res/values-de/strings.xml | 2 +- app/src/main/res/values-es/strings.xml | 2 +- app/src/main/res/values-fr/strings.xml | 2 +- app/src/main/res/values-it/strings.xml | 2 +- app/src/main/res/values-ko/strings.xml | 2 +- app/src/main/res/values-pl/strings.xml | 2 +- app/src/main/res/values-pt-rBR/strings.xml | 2 +- app/src/main/res/values-ro/strings.xml | 2 +- app/src/main/res/values-ru/strings.xml | 2 +- app/src/main/res/values-uk/strings.xml | 2 +- app/src/main/res/values/strings.xml | 2 +- 13 files changed, 17 insertions(+), 15 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index ab4389878c..15eb146489 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -3349,9 +3349,11 @@ fun NexusModsDialog( } placementApplyStatusMessage = message SnackbarManager.show(message) - selectedInstall = install.copy( - status = if (result.errors.isEmpty()) ModInstallStatus.APPLIED.name else install.status, - ) + if (selectedInstall?.installId == install.installId) { + selectedInstall = install.copy( + status = if (result.errors.isEmpty()) ModInstallStatus.APPLIED.name else install.status, + ) + } } fun applyRecipes( diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 075d83f60a..fc1e3f7db9 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2335,7 +2335,7 @@ Mappen %1$s og dens indhold Flet indholdet af valgte mapper Behold navnene på hver valgt mappe - (Anbefalet) + \u0020(Anbefalet) Resultat: %1$s Dette opretter et gentaget mappenavn som Data/Data. Vælg indhold, medmindre moddet kræver den ekstra mappe. Hvorfor denne placering? diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 5afb28c158..7f3d084499 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2405,7 +2405,7 @@ Ordner %1$s und sein Inhalt Inhalte ausgewählter Ordner zusammenführen Namen aller ausgewählten Ordner beibehalten - (Empfohlen) + \u0020(Empfohlen) Ergebnis: %1$s Dadurch entsteht ein doppelter Ordnername wie Data/Data. Wähle Inhalte, sofern der Mod den zusätzlichen Ordner nicht ausdrücklich benötigt. Warum diese Platzierung? diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 1c4023df24..278c64f7d2 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2463,7 +2463,7 @@ Carpeta %1$s y su contenido Combinar el contenido de las carpetas seleccionadas Conservar el nombre de cada carpeta seleccionada - (Recomendado) + \u0020(Recomendado) Resultado: %1$s Esto crea un nombre de carpeta repetido, como Data/Data. Elige el contenido salvo que el mod requiera la carpeta adicional. ¿Por qué esta colocación? diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 420bebf0e5..9b4467d8ec 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2465,7 +2465,7 @@ Dossier %1$s et son contenu Fusionner le contenu des dossiers sélectionnés Conserver le nom de chaque dossier sélectionné - (Recommandé) + \u0020(Recommandé) Résultat : %1$s Cela crée un nom de dossier répété, comme Data/Data. Choisissez le contenu sauf si le mod exige le dossier supplémentaire. Pourquoi ce placement ? diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 515e200b08..8cdb107ade 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2456,7 +2456,7 @@ Cartella %1$s e relativo contenuto Unisci il contenuto delle cartelle selezionate Mantieni il nome di ogni cartella selezionata - (Consigliato) + \u0020(Consigliato) Risultato: %1$s Verrà ripetuto un nome di cartella, ad esempio Data/Data. Scegli il contenuto, a meno che la mod non richieda la cartella aggiuntiva. Perché questo posizionamento? diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index c4d0549422..cb91606faf 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2459,7 +2459,7 @@ %1$s 폴더와 그 내용 선택한 폴더 내용 병합 선택한 각 폴더 이름 유지 - (권장) + \u0020(권장) 결과: %1$s Data/Data처럼 폴더 이름이 반복됩니다. 모드에 추가 폴더가 필요한 경우가 아니면 내용을 선택하세요. 이 배치를 선택한 이유 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 975763e01e..93b93335ad 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2471,7 +2471,7 @@ Folder %1$s i jego zawartość Scal zawartość wybranych folderów Zachowaj nazwę każdego wybranego folderu - (Zalecane) + \u0020(Zalecane) Wynik: %1$s Powstanie powtórzona nazwa folderu, np. Data/Data. Wybierz zawartość, chyba że mod wymaga dodatkowego folderu. Dlaczego to rozmieszczenie? diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index f6a2393bb9..42a88804c8 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2335,7 +2335,7 @@ Pasta %1$s e seu conteúdo Mesclar o conteúdo das pastas selecionadas Manter o nome de cada pasta selecionada - (Recomendado) + \u0020(Recomendado) Resultado: %1$s Isso cria um nome de pasta repetido, como Data/Data. Escolha o conteúdo, a menos que o mod exija a pasta adicional. Por que este posicionamento? diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index b1aeeb221f..f7a657c788 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2470,7 +2470,7 @@ Folderul %1$s și conținutul său Îmbină conținutul folderelor selectate Păstrează numele fiecărui folder selectat - (Recomandat) + \u0020(Recomandat) Rezultat: %1$s Aceasta creează un nume de folder repetat, precum Data/Data. Alege conținutul dacă modul nu necesită folderul suplimentar. De ce această plasare? diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index dbec700d48..b1829aee5f 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2399,7 +2399,7 @@ https://gamenative.app Папку %1$s и её содержимое Объединить содержимое выбранных папок Сохранить имя каждой выбранной папки - (Рекомендуется) + \u0020(Рекомендуется) Результат: %1$s Это создаст повторяющееся имя папки, например Data/Data. Выберите содержимое, если моду не нужна дополнительная папка. Почему выбрано это размещение? diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index e85310da13..a5e1180b59 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2467,7 +2467,7 @@ Папку %1$s та її вміст Об’єднати вміст вибраних папок Зберегти назву кожної вибраної папки - (Рекомендовано) + \u0020(Рекомендовано) Результат: %1$s Це створить повторювану назву папки, наприклад Data/Data. Виберіть вміст, якщо мод не вимагає додаткової папки. Чому це розміщення? diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 18ccee34d2..a1ce295820 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2052,7 +2052,7 @@ %1$s folder and its contents Merge selected folder contents Keep each selected folder name - (Recommended) + \u0020(Recommended) Result: %1$s This creates a repeated folder name such as Data/Data. Choose contents unless the mod specifically requires the extra folder. Why this placement? From efaba72ec3cd6a79bf0553ca8a8b1ab550a93835 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 5 Sep 2026 18:34:31 -0500 Subject: [PATCH 50/60] Avoid boxing placement generation state --- .../java/app/gamenative/ui/component/dialog/NexusModsDialog.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 15eb146489..ad7ad73b3d 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -45,6 +45,7 @@ import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.collectAsState import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableFloatStateOf +import androidx.compose.runtime.mutableLongStateOf import androidx.compose.runtime.mutableStateMapOf import androidx.compose.runtime.mutableStateListOf import androidx.compose.runtime.mutableStateOf @@ -862,7 +863,7 @@ fun NexusModsDialog( var localImportRetryInstallId by rememberSaveable(libraryItem.appId) { mutableStateOf(null) } - var localInspectionGeneration by remember { mutableStateOf(0L) } + var localInspectionGeneration by remember { mutableLongStateOf(0L) } var pendingCollectionSelection by remember { mutableStateOf(null) } var selectedCollectionKeys by remember { mutableStateOf>(emptySet()) } val collectionQueue = remember { mutableStateMapOf() } From b85ce688e89910ba95b294d738c8808eba44a8fa Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 5 Sep 2026 18:45:08 -0500 Subject: [PATCH 51/60] Complete placement label translations --- app/src/main/res/values-da/strings.xml | 3 +++ app/src/main/res/values-de/strings.xml | 3 +++ app/src/main/res/values-es/strings.xml | 3 +++ app/src/main/res/values-fr/strings.xml | 3 +++ app/src/main/res/values-it/strings.xml | 3 +++ app/src/main/res/values-ja/strings.xml | 3 +++ app/src/main/res/values-ko/strings.xml | 3 +++ app/src/main/res/values-pl/strings.xml | 3 +++ app/src/main/res/values-pt-rBR/strings.xml | 3 +++ app/src/main/res/values-ro/strings.xml | 3 +++ app/src/main/res/values-ru/strings.xml | 3 +++ app/src/main/res/values-uk/strings.xml | 3 +++ app/src/main/res/values-zh-rCN/strings.xml | 3 +++ app/src/main/res/values-zh-rTW/strings.xml | 3 +++ 14 files changed, 42 insertions(+) diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index fc1e3f7db9..a969aaac07 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2429,4 +2429,7 @@ %1$.1f°/s %1$d ms Nulstil gyroindstillinger + Gennemgå placering + Mapper på øverste niveau beholder deres navne; filer i roden placeres direkte i destinationen + %1$d standardfil(er) erstattet af dine FOMOD-valg diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 7f3d084499..6d2dfcf2a5 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2499,4 +2499,7 @@ %1$.1f°/s %1$d ms Gyro-Einstellungen zurücksetzen + Platzierung prüfen + Ordner der obersten Ebene behalten ihre Namen; Dateien im Stammverzeichnis werden direkt am Ziel abgelegt + %1$d Standarddatei(en) durch deine FOMOD-Auswahl ersetzt diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 278c64f7d2..280c7abed7 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2557,4 +2557,7 @@ %1$.1f°/s %1$d ms Restablecer ajustes del giroscopio + Revisar colocación + Las carpetas de nivel superior conservan sus nombres; los archivos raíz se colocan directamente en el destino + %1$d archivo(s) predeterminado(s) reemplazado(s) por tus opciones de FOMOD diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 9b4467d8ec..ec608b4a3b 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2559,4 +2559,7 @@ %1$.1f°/s %1$d ms Réinitialiser les réglages du gyroscope + Vérifier le placement + Les dossiers de premier niveau conservent leur nom ; les fichiers racine sont placés directement dans la destination + %1$d fichier(s) par défaut remplacé(s) par vos choix FOMOD diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 8cdb107ade..f84cf6d11e 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2550,4 +2550,7 @@ %1$.1f°/s %1$d ms Ripristina impostazioni giroscopio + Controlla posizionamento + Le cartelle di primo livello mantengono i loro nomi; i file nella radice vengono inseriti direttamente nella destinazione + %1$d file predefinito/i sostituito/i dalle tue scelte FOMOD diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index e53c02ae94..8d983c8ff7 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2512,4 +2512,7 @@ %1$.1f°/秒 %1$d ミリ秒 ジャイロ設定をリセット + 配置を確認 + 最上位フォルダーは名前を保持し、ルートファイルは移動先に直接配置されます + FOMOD の選択により %1$d 個の既定ファイルを置き換えました diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index cb91606faf..062eeb7635 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2553,4 +2553,7 @@ %1$.1f°/초 %1$d ms 자이로 설정 초기화 + 배치 검토 + 최상위 폴더는 이름을 유지하고 루트 파일은 대상에 직접 배치됩니다 + FOMOD 선택으로 기본 파일 %1$d개 교체됨 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 93b93335ad..33b1a8f918 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2565,4 +2565,7 @@ %1$.1f°/s %1$d ms Resetuj ustawienia żyroskopu + Sprawdź rozmieszczenie + Foldery najwyższego poziomu zachowują nazwy; pliki główne trafiają bezpośrednio do miejsca docelowego + Liczba plików domyślnych zastąpionych przez wybory FOMOD: %1$d diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 42a88804c8..674442dc2a 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2429,4 +2429,7 @@ %1$.1f°/s %1$d ms Redefinir configurações do giroscópio + Revisar posicionamento + As pastas de nível superior mantêm seus nomes; os arquivos da raiz vão diretamente para o destino + %1$d arquivo(s) padrão substituído(s) pelas suas escolhas no FOMOD diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index f7a657c788..56c83662a2 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2564,4 +2564,7 @@ %1$.1f°/s %1$d ms Resetează setările giroscopului + Verifică plasarea + Folderele de nivel superior își păstrează numele; fișierele rădăcină ajung direct la destinație + %1$d fișier(e) implicit(e) înlocuit(e) de opțiunile FOMOD diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index b1829aee5f..d2bc6e1268 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2493,4 +2493,7 @@ https://gamenative.app %1$.1f°/с %1$d мс Сбросить настройки гироскопа + Проверить размещение + Папки верхнего уровня сохраняют свои имена; файлы из корня помещаются непосредственно в папку назначения + Файлов по умолчанию заменено выбранными параметрами FOMOD: %1$d diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index a5e1180b59..15a114b2dc 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2561,4 +2561,7 @@ %1$.1f°/с %1$d мс Скинути налаштування гіроскопа + Перевірити розміщення + Папки верхнього рівня зберігають свої назви; файли з кореня розміщуються безпосередньо в папці призначення + Файлів за замовчуванням замінено вибраними параметрами FOMOD: %1$d diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index fd5b697656..b8b3e73678 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2573,4 +2573,7 @@ %1$.1f°/秒 %1$d 毫秒 重置陀螺仪设置 + 检查放置方式 + 顶层文件夹保留其名称；根目录文件直接放入目标位置 + FOMOD 选择替换了 %1$d 个默认文件 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 857b8ff031..87d91383a6 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2564,4 +2564,7 @@ %1$.1f°/秒 %1$d 毫秒 重設陀螺儀設定 + 檢查放置方式 + 頂層資料夾保留其名稱；根目錄檔案直接放入目標位置 + FOMOD 選項取代了 %1$d 個預設檔案 From 9d3bd8a06bea031fb37e067ba0213d00900e4621 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 5 Sep 2026 18:54:01 -0500 Subject: [PATCH 52/60] Resolve placement review findings --- .../ui/component/dialog/NexusModsDialog.kt | 19 ++++++---- .../dialog/NexusModsPlacementSections.kt | 13 +++++-- .../dialog/PlacementWorkspaceModels.kt | 7 +++- app/src/main/res/values-da/strings.xml | 3 +- app/src/main/res/values-de/strings.xml | 3 +- app/src/main/res/values-es/strings.xml | 3 +- app/src/main/res/values-fr/strings.xml | 3 +- app/src/main/res/values-it/strings.xml | 3 +- app/src/main/res/values-ja/strings.xml | 3 +- app/src/main/res/values-ko/strings.xml | 3 +- app/src/main/res/values-pl/strings.xml | 3 +- app/src/main/res/values-pt-rBR/strings.xml | 3 +- app/src/main/res/values-ro/strings.xml | 3 +- app/src/main/res/values-ru/strings.xml | 3 +- app/src/main/res/values-uk/strings.xml | 3 +- app/src/main/res/values-zh-rCN/strings.xml | 3 +- app/src/main/res/values-zh-rTW/strings.xml | 3 +- app/src/main/res/values/strings.xml | 4 +- .../dialog/PlacementWorkspaceModelsTest.kt | 37 ++++++++++++++++++- 19 files changed, 92 insertions(+), 30 deletions(-) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index ad7ad73b3d..d52d2f1d55 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -2798,17 +2798,22 @@ fun NexusModsDialog( val bethesdaGameForMod = BethesdaPluginManager.detectGame(libraryItem.name) val fomodAutoSelection = fomodInstaller?.let { installer -> bethesdaGameForMod?.let { game -> - FomodAutoSelector.selectDeterministic( - installId = install.installId, - installer = installer, - targetRelativePath = game.dataDirName, - environment = FomodEnvironmentSnapshotBuilder.build( + val environment = withContext(Dispatchers.IO) { + FomodEnvironmentSnapshotBuilder.build( installer = installer, gameName = libraryItem.name, gameRootDir = gameRootDir, pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game), - ), - ) + ) + } + withContext(Dispatchers.Default) { + FomodAutoSelector.selectDeterministic( + installId = install.installId, + installer = installer, + targetRelativePath = game.dataDirName, + environment = environment, + ) + } } } val assessment = ModArchiveInstallAssessor.assess( diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 5adf7b3be2..d3faabbef4 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -648,14 +648,19 @@ private fun PlacementPlanReview( onUseCandidate: (AutomaticPlacementCandidate) -> Unit, onExport: () -> Unit, ) { + val stalePlacementReason = stringResource(R.string.nexus_stale_placement_reason) var showWhy by remember(plan.digest) { mutableStateOf(false) } var showAllFiles by remember(plan.digest) { mutableStateOf(false) } var browseTarget by remember(plan.digest) { mutableStateOf(null) } - var rows by remember(plan.digest, diff, roots) { mutableStateOf>(emptyList()) } - var rowsLoading by remember(plan.digest, diff, roots) { mutableStateOf(true) } - LaunchedEffect(plan, diff, roots) { + var rows by remember(plan.digest, diff, roots, stalePlacementReason) { + mutableStateOf>(emptyList()) + } + var rowsLoading by remember(plan.digest, diff, roots, stalePlacementReason) { mutableStateOf(true) } + LaunchedEffect(plan, diff, roots, stalePlacementReason) { rowsLoading = true - rows = withContext(Dispatchers.IO) { placementReviewRows(plan, diff, roots) } + rows = withContext(Dispatchers.IO) { + placementReviewRows(plan, diff, roots, stalePlacementReason) + } rowsLoading = false } Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.surface) { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index 53263ff00e..baf83a36e2 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -168,7 +168,9 @@ private fun destinationBrowserEntry( }.getOrDefault("") val logicalKey = ModTargetResolver.normalizedTargetKey(root.type.name, relative) val absoluteKey = WindowsPathIdentity.absoluteKey(file) - val exactPlan = planFiles.filter { it.normalizedTargetKey == logicalKey } + val exactPlan = logicalKey?.let { key -> + planFiles.filter { it.normalizedTargetKey == key } + }.orEmpty() val directoryPrefix = logicalKey?.let { "$it/" } val receivesFiles = file.isDirectory && directoryPrefix != null && planFiles.any { it.status == PlannedFileStatus.PLACED && it.normalizedTargetKey?.startsWith(directoryPrefix) == true @@ -240,6 +242,7 @@ internal fun placementReviewRows( plan: ModInstallPlan, diff: ModReconfigurationDiff?, roots: List, + staleReason: String, ): List { val changesBySource = diff?.changes.orEmpty().groupBy { it.sourceRelativePath } val rows = plan.files.map { file -> @@ -275,7 +278,7 @@ internal fun placementReviewRows( category = PlacementReviewCategory.REMOVED, source = change.sourceRelativePath, previousTarget = change.previousTarget, - reason = "No longer produced by this placement", + reason = staleReason, ) } return rows.sortedWith(compareBy { it.category.ordinal }.thenBy { it.source.lowercase(Locale.ROOT) }) diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index a969aaac07..1f91940c32 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2303,7 +2303,8 @@ Genanvend manglende filer Registrer filejerskab Filejerskab blev registreret uden at ændre spilfilerne. - Filejerskab kunne ikke registreres (%1$d problem(er)) + Kunne ikke kontrollere og registrere installerede filer (%1$d problem(er)) + Produceres ikke længere af denne placering Gendan forrige udrulning Erstatter den aktuelle filplaceringsplan med den senest fungerende plan for dette mod. Gendanner forrige udrulning… diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 6d2dfcf2a5..6c36494f5e 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2373,7 +2373,8 @@ Fehlende Dateien erneut anwenden Dateibesitz übernehmen Der Dateibesitz wurde erfasst, ohne Spieldateien zu ändern. - Dateibesitz konnte nicht übernommen werden (%1$d Problem(e)) + Installierte Dateien konnten nicht überprüft und erfasst werden (%1$d Problem(e)) + Wird von dieser Platzierung nicht mehr erzeugt Vorherige Bereitstellung wiederherstellen Ersetzt den aktuellen Dateiplatzierungsplan durch den letzten funktionierenden Plan dieses Mods. Vorherige Bereitstellung wird wiederhergestellt… diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 280c7abed7..351d00b0c9 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2431,7 +2431,8 @@ Reaplicar archivos que faltan Adoptar propiedad de archivos La propiedad de los archivos se registró sin modificar los archivos del juego. - No se pudo adoptar la propiedad de los archivos (%1$d problema(s)) + No se pudieron verificar y registrar los archivos instalados (%1$d problema(s)) + Esta colocación ya no genera este archivo Restaurar despliegue anterior Sustituye el plan de ubicación actual por el último plan funcional de este mod. Restaurando el despliegue anterior… diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index ec608b4a3b..b6db89f225 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2433,7 +2433,8 @@ Réappliquer les fichiers manquants Adopter la propriété des fichiers La propriété des fichiers a été enregistrée sans modifier les fichiers du jeu. - Impossible d’adopter la propriété des fichiers (%1$d problème(s)) + Impossible de vérifier et de suivre les fichiers installés (%1$d problème(s)) + Ce placement ne produit plus ce fichier Restaurer le déploiement précédent Remplace le plan de placement actuel par le dernier plan fonctionnel de ce mod. Restauration du déploiement précédent… diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index f84cf6d11e..adc1a25f44 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2424,7 +2424,8 @@ Riapplica i file mancanti Acquisisci proprietà dei file La proprietà dei file è stata registrata senza modificare i file di gioco. - Impossibile acquisire la proprietà dei file (%1$d problema/i) + Impossibile verificare e registrare i file installati (%1$d problema/i) + Non viene più prodotto da questo posizionamento Ripristina distribuzione precedente Sostituisce il piano di posizionamento corrente con l’ultimo piano funzionante di questa mod. Ripristino della distribuzione precedente… diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 8d983c8ff7..be938327b8 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2386,7 +2386,8 @@ 不足しているファイルを再適用 ファイル所有情報を登録 ゲームファイルを変更せずに所有情報を登録しました。 - ファイル所有情報を登録できませんでした（問題 %1$d 件） + インストール済みファイルを確認して追跡できませんでした（問題 %1$d 件） + この配置では生成されなくなりました 以前の配置を復元 現在のファイル配置プランを、この Mod で最後に動作したプランに置き換えます。 以前の配置を復元中… diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 062eeb7635..54671e7f53 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2427,7 +2427,8 @@ 누락된 파일 다시 적용 파일 소유권 등록 게임 파일을 변경하지 않고 파일 소유권을 등록했습니다. - 파일 소유권을 등록하지 못했습니다(문제 %1$d개) + 설치된 파일을 확인하고 추적하지 못했습니다(문제 %1$d개) + 이 배치에서 더 이상 생성되지 않음 이전 배포 복원 현재 파일 배치 계획을 이 모드에서 마지막으로 작동한 계획으로 바꿉니다. 이전 배포 복원 중… diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 33b1a8f918..b570ae413b 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2439,7 +2439,8 @@ Zastosuj ponownie brakujące pliki Przejmij własność plików Własność plików została zapisana bez zmiany plików gry. - Nie udało się przejąć własności plików (%1$d problem(y)) + Nie udało się zweryfikować i śledzić zainstalowanych plików (%1$d problem(y)) + Nie jest już tworzony przez to rozmieszczenie Przywróć poprzednie wdrożenie Zastępuje bieżący plan rozmieszczenia ostatnim działającym planem tego moda. Przywracanie poprzedniego wdrożenia… diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 674442dc2a..9a1c8ffe91 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2303,7 +2303,8 @@ Reaplicar arquivos ausentes Adotar propriedade dos arquivos A propriedade dos arquivos foi registrada sem alterar os arquivos do jogo. - Não foi possível adotar a propriedade dos arquivos (%1$d problema(s)) + Não foi possível verificar e rastrear os arquivos instalados (%1$d problema(s)) + Não é mais produzido por este posicionamento Restaurar implantação anterior Substitui o plano de posicionamento atual pelo último plano funcional deste mod. Restaurando a implantação anterior… diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 56c83662a2..c63c5df538 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2438,7 +2438,8 @@ Reaplică fișierele lipsă Preia proprietatea fișierelor Proprietatea fișierelor a fost înregistrată fără modificarea fișierelor jocului. - Proprietatea fișierelor nu a putut fi preluată (%1$d problemă(e)) + Fișierele instalate nu au putut fi verificate și urmărite (%1$d problemă(e)) + Nu mai este produs de această plasare Restaurează implementarea anterioară Înlocuiește planul curent de amplasare cu ultimul plan funcțional al acestui mod. Se restaurează implementarea anterioară… diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index d2bc6e1268..511dfb0094 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2367,7 +2367,8 @@ https://gamenative.app Повторно применить отсутствующие файлы Принять владение файлами Владение файлами зарегистрировано без изменения файлов игры. - Не удалось принять владение файлами (проблем: %1$d) + Не удалось проверить и отслеживать установленные файлы (проблем: %1$d) + Больше не создаётся этим вариантом размещения Восстановить предыдущее развёртывание Заменяет текущий план размещения последним рабочим планом этого мода. Восстановление предыдущего развёртывания… diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 15a114b2dc..974fad0ab0 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2435,7 +2435,8 @@ Повторно застосувати відсутні файли Прийняти володіння файлами Володіння файлами зареєстровано без зміни файлів гри. - Не вдалося прийняти володіння файлами (проблем: %1$d) + Не вдалося перевірити й відстежувати встановлені файли (проблем: %1$d) + Більше не створюється цим варіантом розміщення Відновити попереднє розгортання Замінює поточний план розміщення останнім робочим планом цього мода. Відновлення попереднього розгортання… diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index b8b3e73678..68e43ce1b5 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2447,7 +2447,8 @@ 重新应用缺失文件 接管文件所有权 已记录文件所有权，未更改游戏文件。 - 无法接管文件所有权（%1$d 个问题） + 无法验证和跟踪已安装的文件（%1$d 个问题） + 此放置方案不再生成该文件 恢复上一次部署 将当前文件放置计划替换为此模组上一次正常工作的计划。 正在恢复上一次部署… diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 87d91383a6..4b5865c093 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2438,7 +2438,8 @@ 重新套用遺失檔案 接管檔案所有權 已記錄檔案所有權，未變更遊戲檔案。 - 無法接管檔案所有權（%1$d 個問題） + 無法驗證並追蹤已安裝的檔案（%1$d 個問題） + 此放置方案不再產生此檔案 還原上一次部署 將目前檔案放置計畫替換為此模組上一次正常運作的計畫。 正在還原上一次部署… diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index a1ce295820..0e7334d08b 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2182,8 +2182,8 @@ Reapply missing files Verify and track files Verified files were adopted without changing them - Could not safely adopt ownership (%1$d issue(s)) - Could not verify and track installed files (%1$d issue(s)) + Could not verify and track installed files (%1$d issue(s)) + No longer produced by this placement Restore previous deployment Returns this mod to its previous reviewed file plan. Externally modified files are preserved. Restoring previous deployment diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt index 46a33a9271..ee99254f68 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt @@ -147,6 +147,36 @@ class PlacementWorkspaceModelsTest { assertTrue(entries.single().virtual) } + @Test + fun destinationBrowser_doesNotMatchPlansWithoutTargetKeys() { + val rootDir = temporaryFolder.newFolder("unresolved-game") + val unmanaged = File(rootDir, "unmanaged.bin").apply { writeText("game") } + val root = ResolvedModTargetRoot(ModTargetRoot.GAME_DIR, "Game", rootDir) + val unresolvedPlan = ModInstallPlan( + files = listOf( + PlannedModFile( + sourceRelativePath = "unknown.bin", + status = PlannedFileStatus.CONFLICTED, + origin = PlacementOrigin.GAME_RULE, + reason = "No target", + ), + ), + ) + + val entry = destinationBrowserEntries( + rootDir, + root, + unresolvedPlan, + emptyList(), + "selected", + false, + "", + ).single { it.file == unmanaged } + + assertFalse(DestinationEntryImpact.PLAN_CONFLICT in entry.impacts) + assertTrue(DestinationEntryImpact.GAME_OR_UNMANAGED in entry.impacts) + } + @Test fun reviewRows_groupPlanAndReconfigurationChanges() { val rootDir = temporaryFolder.newFolder("review-game") @@ -180,7 +210,12 @@ class PlacementWorkspaceModelsTest { ), ) - val categories = placementReviewRows(plan, diff, listOf(root)).groupingBy { it.category }.eachCount() + val categories = placementReviewRows( + plan, + diff, + listOf(root), + staleReason = "No longer produced by this placement", + ).groupingBy { it.category }.eachCount() assertEquals(1, categories[PlacementReviewCategory.ADDED]) assertEquals(1, categories[PlacementReviewCategory.REPLACED]) From 0d431cb36c0d81580beca6844af5c2dfaafec476 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 5 Sep 2026 19:02:08 -0500 Subject: [PATCH 53/60] Clarify file tracking translations --- app/src/main/res/values-da/strings.xml | 4 ++-- app/src/main/res/values-de/strings.xml | 4 ++-- app/src/main/res/values-es/strings.xml | 4 ++-- app/src/main/res/values-fr/strings.xml | 4 ++-- app/src/main/res/values-it/strings.xml | 4 ++-- app/src/main/res/values-ja/strings.xml | 4 ++-- app/src/main/res/values-ko/strings.xml | 4 ++-- app/src/main/res/values-pl/strings.xml | 4 ++-- app/src/main/res/values-pt-rBR/strings.xml | 4 ++-- app/src/main/res/values-ro/strings.xml | 4 ++-- app/src/main/res/values-ru/strings.xml | 4 ++-- app/src/main/res/values-uk/strings.xml | 4 ++-- app/src/main/res/values-zh-rCN/strings.xml | 4 ++-- app/src/main/res/values-zh-rTW/strings.xml | 4 ++-- app/src/main/res/values/strings.xml | 2 +- 15 files changed, 29 insertions(+), 29 deletions(-) diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 1f91940c32..9a031d21de 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2301,8 +2301,8 @@ DLL-, EXE- og indlæserfiler kan ændre, hvordan spillet starter. Bekræft kun, når arkivet er betroet, og forhåndsvisningen matcher installationsvejledningen. Opretter filplaceringsplan… Genanvend manglende filer - Registrer filejerskab - Filejerskab blev registreret uden at ændre spilfilerne. + Kontrollér og registrer filer + Filerne blev kontrolleret og registreret uden at ændre dem. Kunne ikke kontrollere og registrere installerede filer (%1$d problem(er)) Produceres ikke længere af denne placering Gendan forrige udrulning diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 6c36494f5e..0862ec9dd4 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2371,8 +2371,8 @@ DLL-, EXE- und Loader-Dateien können den Spielstart verändern. Nur bestätigen, wenn das Archiv vertrauenswürdig ist und die Vorschau der Installationsanleitung entspricht. Dateiplatzierungsplan wird erstellt… Fehlende Dateien erneut anwenden - Dateibesitz übernehmen - Der Dateibesitz wurde erfasst, ohne Spieldateien zu ändern. + Dateien prüfen und erfassen + Die Dateien wurden geprüft und erfasst, ohne sie zu ändern. Installierte Dateien konnten nicht überprüft und erfasst werden (%1$d Problem(e)) Wird von dieser Platzierung nicht mehr erzeugt Vorherige Bereitstellung wiederherstellen diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 351d00b0c9..fa01b6cbbd 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2429,8 +2429,8 @@ Los archivos DLL, EXE y de carga pueden cambiar el inicio del juego. Confirma solo si confías en el archivo y la vista previa coincide con sus instrucciones de instalación. Creando el plan de ubicación de archivos… Reaplicar archivos que faltan - Adoptar propiedad de archivos - La propiedad de los archivos se registró sin modificar los archivos del juego. + Verificar y registrar archivos + Los archivos se verificaron y registraron sin modificarlos. No se pudieron verificar y registrar los archivos instalados (%1$d problema(s)) Esta colocación ya no genera este archivo Restaurar despliegue anterior diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index b6db89f225..2f17f713c2 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2431,8 +2431,8 @@ Les fichiers DLL, EXE et de chargement peuvent modifier le démarrage du jeu. Confirmez uniquement si l’archive est fiable et si l’aperçu correspond à ses instructions d’installation. Création du plan de placement des fichiers… Réappliquer les fichiers manquants - Adopter la propriété des fichiers - La propriété des fichiers a été enregistrée sans modifier les fichiers du jeu. + Vérifier et suivre les fichiers + Les fichiers ont été vérifiés et sont désormais suivis sans avoir été modifiés. Impossible de vérifier et de suivre les fichiers installés (%1$d problème(s)) Ce placement ne produit plus ce fichier Restaurer le déploiement précédent diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index adc1a25f44..f1c7c6bcc7 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2422,8 +2422,8 @@ I file DLL, EXE e loader possono cambiare il modo in cui si avvia il gioco. Conferma solo se l’archivio è attendibile e l’anteprima corrisponde alle istruzioni di installazione. Creazione del piano di posizionamento dei file… Riapplica i file mancanti - Acquisisci proprietà dei file - La proprietà dei file è stata registrata senza modificare i file di gioco. + Verifica e registra i file + I file sono stati verificati e registrati senza modificarli. Impossibile verificare e registrare i file installati (%1$d problema/i) Non viene più prodotto da questo posizionamento Ripristina distribuzione precedente diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index be938327b8..9e2c15ea57 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2384,8 +2384,8 @@ DLL、EXE、ローダーファイルはゲームの起動方法を変更することがあります。信頼できるアーカイブで、プレビューがインストール手順と一致する場合のみ確認してください。 ファイル配置プランを作成中… 不足しているファイルを再適用 - ファイル所有情報を登録 - ゲームファイルを変更せずに所有情報を登録しました。 + ファイルを確認して追跡 + ファイルを変更せずに確認し、追跡対象にしました。 インストール済みファイルを確認して追跡できませんでした（問題 %1$d 件） この配置では生成されなくなりました 以前の配置を復元 diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index 54671e7f53..aacb06689b 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2425,8 +2425,8 @@ DLL, EXE 및 로더 파일은 게임 시작 방식을 바꿀 수 있습니다. 아카이브를 신뢰할 수 있고 미리보기가 설치 안내와 일치할 때만 확인하세요. 파일 배치 계획 생성 중… 누락된 파일 다시 적용 - 파일 소유권 등록 - 게임 파일을 변경하지 않고 파일 소유권을 등록했습니다. + 파일 확인 및 추적 + 파일을 변경하지 않고 확인하여 추적하도록 등록했습니다. 설치된 파일을 확인하고 추적하지 못했습니다(문제 %1$d개) 이 배치에서 더 이상 생성되지 않음 이전 배포 복원 diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index b570ae413b..dc23b2f24b 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2437,8 +2437,8 @@ Pliki DLL, EXE i moduły ładujące mogą zmienić sposób uruchamiania gry. Potwierdź tylko wtedy, gdy archiwum jest zaufane, a podgląd odpowiada instrukcji instalacji. Tworzenie planu rozmieszczenia plików… Zastosuj ponownie brakujące pliki - Przejmij własność plików - Własność plików została zapisana bez zmiany plików gry. + Zweryfikuj i śledź pliki + Pliki zweryfikowano i objęto śledzeniem bez ich zmieniania. Nie udało się zweryfikować i śledzić zainstalowanych plików (%1$d problem(y)) Nie jest już tworzony przez to rozmieszczenie Przywróć poprzednie wdrożenie diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index 9a1c8ffe91..9aec35cb52 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2301,8 +2301,8 @@ Arquivos DLL, EXE e de carregamento podem mudar como o jogo inicia. Confirme somente se o arquivo for confiável e a prévia corresponder às instruções de instalação. Criando o plano de posicionamento de arquivos… Reaplicar arquivos ausentes - Adotar propriedade dos arquivos - A propriedade dos arquivos foi registrada sem alterar os arquivos do jogo. + Verificar e rastrear arquivos + Os arquivos foram verificados e rastreados sem alterações. Não foi possível verificar e rastrear os arquivos instalados (%1$d problema(s)) Não é mais produzido por este posicionamento Restaurar implantação anterior diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index c63c5df538..7b1bd0577f 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2436,8 +2436,8 @@ Fișierele DLL, EXE și de încărcare pot schimba modul în care pornește jocul. Confirmă numai dacă arhiva este de încredere, iar previzualizarea corespunde instrucțiunilor de instalare. Se creează planul de amplasare a fișierelor… Reaplică fișierele lipsă - Preia proprietatea fișierelor - Proprietatea fișierelor a fost înregistrată fără modificarea fișierelor jocului. + Verifică și urmărește fișierele + Fișierele au fost verificate și urmărite fără a fi modificate. Fișierele instalate nu au putut fi verificate și urmărite (%1$d problemă(e)) Nu mai este produs de această plasare Restaurează implementarea anterioară diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 511dfb0094..755ea48229 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2365,8 +2365,8 @@ https://gamenative.app Файлы DLL, EXE и загрузчики могут изменить запуск игры. Подтверждайте, только если архиву можно доверять, а предпросмотр совпадает с инструкцией по установке. Создание плана размещения файлов… Повторно применить отсутствующие файлы - Принять владение файлами - Владение файлами зарегистрировано без изменения файлов игры. + Проверить и отслеживать файлы + Файлы проверены и добавлены в отслеживание без изменений. Не удалось проверить и отслеживать установленные файлы (проблем: %1$d) Больше не создаётся этим вариантом размещения Восстановить предыдущее развёртывание diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 974fad0ab0..34184016ed 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2433,8 +2433,8 @@ Файли DLL, EXE та завантажувачі можуть змінити запуск гри. Підтверджуйте, лише якщо архіву можна довіряти, а попередній перегляд відповідає інструкції зі встановлення. Створення плану розміщення файлів… Повторно застосувати відсутні файли - Прийняти володіння файлами - Володіння файлами зареєстровано без зміни файлів гри. + Перевірити й відстежувати файли + Файли перевірено й додано до відстеження без змін. Не вдалося перевірити й відстежувати встановлені файли (проблем: %1$d) Більше не створюється цим варіантом розміщення Відновити попереднє розгортання diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 68e43ce1b5..902cf741e2 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2445,8 +2445,8 @@ DLL、EXE 和加载器文件可能改变游戏的启动方式。仅当压缩包可信且预览与安装说明一致时才确认。 正在生成文件放置计划… 重新应用缺失文件 - 接管文件所有权 - 已记录文件所有权，未更改游戏文件。 + 验证并跟踪文件 + 已验证并跟踪文件，未进行任何更改。 无法验证和跟踪已安装的文件（%1$d 个问题） 此放置方案不再生成该文件 恢复上一次部署 diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index 4b5865c093..c65ea17c34 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2436,8 +2436,8 @@ DLL、EXE 和載入器檔案可能改變遊戲的啟動方式。僅在壓縮檔可信且預覽與安裝說明一致時確認。 正在建立檔案放置計畫… 重新套用遺失檔案 - 接管檔案所有權 - 已記錄檔案所有權，未變更遊戲檔案。 + 驗證並追蹤檔案 + 已驗證並追蹤檔案，未進行任何變更。 無法驗證並追蹤已安裝的檔案（%1$d 個問題） 此放置方案不再產生此檔案 還原上一次部署 diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 0e7334d08b..a7820f22a8 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -2181,7 +2181,7 @@ Building the file placement plan… Reapply missing files Verify and track files - Verified files were adopted without changing them + Verified files are now tracked without changing them Could not verify and track installed files (%1$d issue(s)) No longer produced by this placement Restore previous deployment From ee496fb7ed77193048a1dbbf701a2644dba582fb Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 12 Sep 2026 18:53:44 -0500 Subject: [PATCH 54/60] Harden placement and deployment edge cases --- .../mods/AutomaticPlacementPlanner.kt | 24 +++++++++- .../gamenative/mods/BethesdaPluginManager.kt | 2 +- .../app/gamenative/mods/FomodAutoSelector.kt | 1 - .../app/gamenative/mods/FomodEnvironment.kt | 4 +- .../gamenative/mods/FomodInstallPlanner.kt | 9 ++-- .../app/gamenative/mods/FomodInstaller.kt | 3 -- .../gamenative/mods/ModConfigurationDraft.kt | 32 +++++++++----- .../gamenative/mods/ModDeploymentJournal.kt | 6 +++ .../app/gamenative/mods/ModMaterializer.kt | 44 ++++++++++++++----- .../gamenative/mods/ModOwnershipManifest.kt | 15 +++---- .../app/gamenative/mods/NexusModManager.kt | 33 +++++++------- .../gamenative/mods/WindowsTargetNamespace.kt | 3 +- .../dialog/NexusModsFomodSections.kt | 3 +- .../dialog/NexusModsPlacementSections.kt | 8 +++- .../mods/AutomaticPlacementPlannerTest.kt | 18 ++++++++ .../mods/BethesdaPluginManagerTest.kt | 28 ++++++++++++ .../gamenative/mods/FomodEnvironmentTest.kt | 22 ++++++++++ .../app/gamenative/mods/FomodInstallerTest.kt | 2 - .../mods/ModConfigurationDraftTest.kt | 14 ++++++ .../mods/ModDeploymentJournalTest.kt | 17 ++++++- .../gamenative/mods/ModMaterializerTest.kt | 24 ++++++++++ .../mods/ModOwnershipManifestTest.kt | 40 ++++++++++++++--- 22 files changed, 284 insertions(+), 68 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt index 1ac4696dc1..844cb08834 100644 --- a/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/AutomaticPlacementPlanner.kt @@ -449,6 +449,7 @@ object AutomaticPlacementPlanner { evidence: List, ): AutomaticPlacementCandidate { val placedBySource = linkedMapOf() + val conflictingSourceKeys = mutableSetOf() drafts.forEach { draft -> ModPlacementSources.decode(draft.sourceSubpath).ifEmpty { listOf("") }.forEach { source -> val sourceIsDirectory = source.isBlank() || index.isDirectory(source) @@ -467,7 +468,7 @@ object AutomaticPlacementPlanner { relative.takeIf(String::isNotBlank), ).joinToString("/") val targetKey = ModTargetResolver.normalizedTargetKey(draft.targetRoot, targetPath) - placedBySource[file.normalizedKey] = PlannedModFile( + val planned = PlannedModFile( sourceRelativePath = file.displayPath, targetRoot = draft.targetRoot, targetRelativePath = targetPath, @@ -480,6 +481,26 @@ object AutomaticPlacementPlanner { evidence = evidence, risk = if (file.role == ArchiveContentRole.RISKY_ROOT) PlacementRisk.UNSAFE else PlacementRisk.SAFE, ) + val previous = placedBySource[file.normalizedKey] + when { + file.normalizedKey in conflictingSourceKeys -> Unit + previous != null && previous.normalizedTargetKey != planned.normalizedTargetKey -> { + conflictingSourceKeys += file.normalizedKey + placedBySource[file.normalizedKey] = previous.copy( + status = PlannedFileStatus.CONFLICTED, + reason = "One archive file maps to multiple destinations", + evidence = (previous.evidence + planned.evidence).distinct(), + risk = if ( + previous.risk == PlacementRisk.UNSAFE || planned.risk == PlacementRisk.UNSAFE + ) { + PlacementRisk.UNSAFE + } else { + PlacementRisk.REVIEW + }, + ) + } + else -> placedBySource[file.normalizedKey] = planned + } } } } @@ -522,6 +543,7 @@ object AutomaticPlacementPlanner { val blockers = buildList { if (index.caseCollisions.isNotEmpty()) add("Archive contains case-colliding file paths") if (classified.any { it.status == PlannedFileStatus.UNSUPPORTED }) add("Some installable files have no proven destination") + if (conflictingSourceKeys.isNotEmpty()) add("One or more archive files map to multiple destinations") if (duplicateTargets.isNotEmpty()) add("Multiple files target the same Windows path") if (classified.any { it.risk == PlacementRisk.UNSAFE }) add(ModInstallPlan.RISKY_ROOT_REVIEW_BLOCKER) } diff --git a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt index d7bb16a2be..645330038b 100644 --- a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt +++ b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt @@ -108,7 +108,7 @@ object BethesdaPluginManager { ) check(plan.isComplete) { plan.errors.values.joinToString() } plan.files - .filter { file -> file.source.extension.lowercase() in pluginExtensions } + .filter { file -> file.target.extension.lowercase() in pluginExtensions } .map { file -> file.source to file.target } } pluginFiles.map { (source, target) -> diff --git a/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt b/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt index 45c5884bf3..160791696a 100644 --- a/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt +++ b/app/src/main/java/app/gamenative/mods/FomodAutoSelector.kt @@ -78,7 +78,6 @@ object FomodAutoSelector { mode = ModPlacementMode.OVERWRITE_COPY.name, environment = environment, ) - if (result.unsupportedMappings.isNotEmpty()) return null if (result.recipes.isEmpty()) return null return FomodAutoSelectionResult( diff --git a/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt index 8bca257a4f..036139ad72 100644 --- a/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt +++ b/app/src/main/java/app/gamenative/mods/FomodEnvironment.kt @@ -22,6 +22,7 @@ data class FomodEnvironmentSnapshot( val gameName: String = "", val gameVersion: String? = null, val fileFacts: Map = emptyMap(), + val pluginStateKnown: Boolean = false, val presentPlugins: Set = emptySet(), val activePlugins: Set = emptySet(), val pluginMasters: Map> = emptyMap(), @@ -43,7 +44,7 @@ data class FomodEnvironmentSnapshot( val present = when { key in activePlugins -> true key in presentPlugins -> true - presentPlugins.isNotEmpty() -> false + pluginStateKnown -> false else -> return FomodFactState.UNKNOWN } return requiredState(dependency.state, present, key in activePlugins, isPlugin = true) @@ -135,6 +136,7 @@ object FomodEnvironmentSnapshotBuilder { gameName = gameName, gameVersion = gameVersion, fileFacts = fileFacts, + pluginStateKnown = gameRootDir != null, presentPlugins = presentPlugins, activePlugins = activePlugins, pluginMasters = pluginMasters, diff --git a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt index fe92f672c2..ec6d5d3e59 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstallPlanner.kt @@ -27,6 +27,9 @@ object FomodSelectionEvaluator { val selectedPlugins = FomodRecipeGenerator.selectedPluginsForKeys(installer, selectedPluginKeys, environment) val flags = linkedMapOf() selectedPlugins.forEach { plugin -> plugin.conditionFlags.forEach { (name, value) -> flags[name] = value } } + val conditionalStates = installer.conditionalFileInstalls.map { conditional -> + conditional to conditional.dependencies.evaluate(flags, environment) + } var ordinal = 0 val expected = buildList { installer.requiredFiles.forEach { mapping -> @@ -37,8 +40,8 @@ object FomodSelectionEvaluator { add(FomodExpectedMapping(mapping, PlacementOrigin.FOMOD_OPTION, ordinal++)) } } - installer.conditionalFileInstalls.forEach { conditional -> - if (conditional.dependencies.evaluate(flags, environment) == FomodFactState.TRUE) { + conditionalStates.forEach { (conditional, state) -> + if (state == FomodFactState.TRUE) { conditional.files.forEach { mapping -> add(FomodExpectedMapping(mapping, PlacementOrigin.FOMOD_CONDITIONAL, ordinal++)) } @@ -64,7 +67,7 @@ object FomodSelectionEvaluator { FomodFactState.UNKNOWN -> Unit FomodFactState.TRUE -> Unit } - if (installer.conditionalFileInstalls.any { it.dependencies.evaluate(flags, environment) == FomodFactState.UNKNOWN }) { + if (conditionalStates.any { (_, state) -> state == FomodFactState.UNKNOWN }) { add("A selected FOMOD conditional depends on unknown game facts") } if (installer.conditionalFileInstalls.any { it.dependencies.unsupportedCount() > 0 }) { diff --git a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt index e61f82f4bd..0db3d05773 100644 --- a/app/src/main/java/app/gamenative/mods/FomodInstaller.kt +++ b/app/src/main/java/app/gamenative/mods/FomodInstaller.kt @@ -137,7 +137,6 @@ fun FomodPlugin.effectiveType( data class FomodRecipeGenerationResult( val recipes: List, - val unsupportedMappings: List, val plan: ModInstallPlan? = null, val blockingIssues: List = emptyList(), ) @@ -475,7 +474,6 @@ object FomodRecipeGenerator { } return FomodRecipeGenerationResult( recipes = recipes.distinctBy(::recipeIdentity), - unsupportedMappings = emptyList(), plan = plan, blockingIssues = plan.blockingIssues, ) @@ -582,7 +580,6 @@ object FomodRecipeGenerator { return FomodRecipeGenerationResult( recipes = recipes.distinctBy(::recipeIdentity), - unsupportedMappings = emptyList(), ) } diff --git a/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt b/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt index 662cbc461f..0307714e84 100644 --- a/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt +++ b/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt @@ -82,20 +82,28 @@ object ModConfigurationDraftStore { } } - fun write(root: File, draft: ModConfigurationDraft) { + fun write(root: File, draft: ModConfigurationDraft): Boolean { val target = file(root, draft.installId) val temp = File(target.parentFile, "${target.name}.tmp") - target.parentFile?.mkdirs() - FileOutputStream(temp).use { output -> - output.write(json.encodeToString(draft.copy(updatedAt = System.currentTimeMillis())).toByteArray(Charsets.UTF_8)) - output.fd.sync() - } - runCatching { - Files.move(temp.toPath(), target.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING) - }.getOrElse { - temp.copyTo(target, overwrite = true) - temp.delete() - } + return runCatching { + target.parentFile?.mkdirs() + FileOutputStream(temp).use { output -> + output.write(json.encodeToString(draft.copy(updatedAt = System.currentTimeMillis())).toByteArray(Charsets.UTF_8)) + output.fd.sync() + } + runCatching { + Files.move(temp.toPath(), target.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING) + }.getOrElse { + temp.copyTo(target, overwrite = true) + temp.delete() + } + }.fold( + onSuccess = { true }, + onFailure = { + temp.delete() + false + }, + ) } fun delete(root: File, installId: String) { diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt index e2f51ed23d..46c4a57ea7 100644 --- a/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt @@ -69,6 +69,12 @@ object ModDeploymentJournalStore { fun readAll(root: File): List = journalDir(root).listFiles().orEmpty().filter { it.isFile && it.extension == "json" }.mapNotNull(::readFile) + fun delete(root: File, installId: String) { + val current = journalFile(root, installId) + current.delete() + File(current.parentFile, "${current.name}.tmp").delete() + } + fun reconcile(root: File): List = readAll(root).map { journal -> when (journal.checkpoint) { ModDeploymentCheckpoint.PLANNED, diff --git a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt index d6a57e7db1..aed6f87808 100644 --- a/app/src/main/java/app/gamenative/mods/ModMaterializer.kt +++ b/app/src/main/java/app/gamenative/mods/ModMaterializer.kt @@ -318,6 +318,9 @@ object ModMaterializer { restoredOverwriteTargets: Set = emptySet(), ): List = withContext(Dispatchers.IO) { val skipped = mutableListOf() + val restoredOverwriteTargetKeys = restoredOverwriteTargets.mapTo(mutableSetOf()) { + WindowsPathIdentity.absoluteKey(File(it)) + } val plan = materializationPlan(install, recipes, gameRootDir, winePrefix, captureTargetHashes = false) plan.operations.forEach { entry -> runCatching { @@ -338,7 +341,7 @@ object ModMaterializer { skipped = skipped, allowOwnedDirectoryDelete = false, reportChangedFiles = true, - ignoredChangedTargets = restoredOverwriteTargets, + ignoredChangedTargetKeys = restoredOverwriteTargetKeys, removeLegacySentinel = true, ) } @@ -386,6 +389,30 @@ object ModMaterializer { } }.onFailure { skipped += file.target.absolutePath } } + + plan.operations.asReversed() + .filter { operation -> + operation.mode == ModPlacementMode.COPY && + operation.source.isDirectory && + !operation.targetExistedBefore + } + .forEach { operation -> + runCatching { + val operationTargetPath = operation.target.absoluteFile.toPath().normalize() + val preservedTargetExists = plan.files.any { file -> + file.mode == ModPlacementMode.COPY && + file.target.absoluteFile.toPath().normalize().startsWith(operationTargetPath) && + (file.target.exists() || Files.isSymbolicLink(file.target.toPath())) + } + if (!preservedTargetExists) { + val sentinel = File(operation.target, COPY_SENTINEL) + if (sentinel.isFile && sentinel.readText() == plan.installId) { + check(sentinel.delete()) { "Could not remove rollback marker" } + } + deleteEmptyDirs(operation.target, stopAt = operation.target.parentFile) + } + }.onFailure { skipped += operation.target.absolutePath } + } skipped.distinct() } @@ -809,7 +836,7 @@ object ModMaterializer { skipped: MutableList, allowOwnedDirectoryDelete: Boolean, reportChangedFiles: Boolean, - ignoredChangedTargets: Set = emptySet(), + ignoredChangedTargetKeys: Set = emptySet(), removeLegacySentinel: Boolean = false, ) { if (!target.exists() && !Files.isSymbolicLink(target.toPath())) return @@ -826,13 +853,13 @@ object ModMaterializer { .filter { it.isFile } .forEach { sourceFile -> val targetFile = safeChildTarget(target, sourceFile.relativeTo(source).path) - removeCopiedFileIfUnchanged(targetFile, sourceFile, skipped, reportChangedFiles, ignoredChangedTargets) + removeCopiedFileIfUnchanged(targetFile, sourceFile, skipped, reportChangedFiles, ignoredChangedTargetKeys) } if (allowOwnedDirectoryDelete || removeLegacySentinel) { deleteEmptyDirs(target, stopAt = target.parentFile) } } else { - removeCopiedFileIfUnchanged(target, source, skipped, reportChangedFiles, ignoredChangedTargets) + removeCopiedFileIfUnchanged(target, source, skipped, reportChangedFiles, ignoredChangedTargetKeys) } } @@ -841,17 +868,14 @@ object ModMaterializer { source: File, skipped: MutableList, reportChangedFiles: Boolean, - ignoredChangedTargets: Set = emptySet(), + ignoredChangedTargetKeys: Set = emptySet(), ) { if (!target.exists() || !target.isFile || !source.isFile) return val targetKey = WindowsPathIdentity.absoluteKey(target) - val ignoredKeys = ignoredChangedTargets.asSequence() - .map { WindowsPathIdentity.absoluteKey(File(it)) } - .toSet() - if (targetKey in ignoredKeys) return + if (targetKey in ignoredChangedTargetKeys) return if (sha256(target) == sha256(source)) { target.delete() - } else if (reportChangedFiles && targetKey !in ignoredKeys) { + } else if (reportChangedFiles) { skipped += target.absolutePath } } diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index 78a846abd2..919487b939 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -92,12 +92,16 @@ data class ModOwnershipManifest( ) fun ModOwnershipManifest.reviewedPlanOrNull(): ModInstallPlan? { - val ownedBySourceAndTarget = files.associateBy { it.sourceRelativePath to it.normalizedTargetKey } + val ownedBySourceAndTarget = files.associateBy { + Triple(it.sourceRelativePath, it.targetRoot, it.targetRelativePath) + } val planned = if (decisions.isNotEmpty()) { decisions.mapNotNull { decision -> val status = runCatching { PlannedFileStatus.valueOf(decision.status) }.getOrNull() ?: return@mapNotNull null val origin = runCatching { PlacementOrigin.valueOf(decision.origin) }.getOrDefault(PlacementOrigin.MANUAL_RECIPE) - val owned = ownedBySourceAndTarget[decision.sourceRelativePath to decision.normalizedTargetKey] + val owned = ownedBySourceAndTarget[ + Triple(decision.sourceRelativePath, decision.targetRoot, decision.targetRelativePath), + ] ?: files.firstOrNull { it.sourceRelativePath == decision.sourceRelativePath } PlannedModFile( sourceRelativePath = decision.sourceRelativePath, @@ -336,7 +340,7 @@ object ModOwnershipStore { .filter { it.isFile && it.name.endsWith(".json.zst") && !it.name.endsWith(".previous.json.zst") } .mapNotNull(::readFile) - fun writePending(root: File, manifest: ModOwnershipManifest) { + fun write(root: File, manifest: ModOwnershipManifest) { val current = currentFile(root, manifest.installId) val previous = previousFile(root, manifest.installId) val temp = File(current.parentFile, "${current.name}.tmp") @@ -353,11 +357,6 @@ object ModOwnershipStore { moveReplacing(temp, current) } - fun commit(root: File, installId: String) { - // Keep one prior deployment so a successful reconfigure can be undone without - // retaining an unbounded history. The next write rotates it atomically. - } - fun delete(root: File, installId: String) { currentFile(root, installId).delete() previousFile(root, installId).delete() diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index b0c3a29259..4b0104d4d4 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -653,8 +653,7 @@ object NexusModManager { priority = priority, preservedStale = staleCleanup.preserved, ) - ModOwnershipStore.writePending(ownershipRoot, ownership) - ModOwnershipStore.commit(ownershipRoot, install.installId) + ModOwnershipStore.write(ownershipRoot, ownership) if (install.status != ModInstallStatus.APPLIED.name) { dao.updateInstallStatus(install.installId, ModInstallStatus.APPLIED.name) } @@ -795,8 +794,7 @@ object NexusModManager { profileId = profileId, priority = priority, ) - ModOwnershipStore.writePending(root, ownership) - ModOwnershipStore.commit(root, install.installId) + ModOwnershipStore.write(root, ownership) ModPlacementResult(0, plan.files.size, 0, emptyMap(), emptyList()) } } @@ -880,20 +878,16 @@ object NexusModManager { return@withContext listOf("Verify and track this mod's installed files before disabling or removing it safely") } val cleanup = ModOwnershipReconciler.removeOwnedFiles(ownership, manifests, restoreBackups = restoreBackups) - ModOwnershipStore.writePending( + val preservedByTarget = cleanup.preserved.associateBy { it.normalizedTargetKey } + ModOwnershipStore.write( ownershipRoot, ownership.copy( state = ModOwnershipState.DISABLED, files = ownership.files.map { file -> - if (file.normalizedTargetKey in cleanup.preserved.map { it.normalizedTargetKey }.toSet()) { - cleanup.preserved.first { it.normalizedTargetKey == file.normalizedTargetKey } - } else { - file.copy(active = false) - } + preservedByTarget[file.normalizedTargetKey] ?: file.copy(active = false) }, ), ) - ModOwnershipStore.commit(ownershipRoot, install.installId) dao.updateInstallEnabled(install.installId, false, ModInstallStatus.DISABLED.name) cleanup.skippedPaths } @@ -910,7 +904,9 @@ object NexusModManager { val dao = dao(context) dao.deleteOverwriteManifests(install.installId) dao.deleteInstall(install.installId) - ModOwnershipStore.delete(cacheRoot(context, install.appId), install.installId) + val installCacheRoot = cacheRoot(context, install.appId) + ModOwnershipStore.delete(installCacheRoot, install.installId) + ModDeploymentJournalStore.delete(installCacheRoot, install.installId) if (install.archivePath.isNotBlank()) { val archiveFile = File(install.archivePath) archiveFile.delete() @@ -1163,7 +1159,9 @@ object NexusModManager { } val ownershipRoot = cacheRoot(context, appId) - val journals = ModDeploymentJournalStore.reconcile(ownershipRoot).associateBy { it.installId } + val journals = ModDeploymentCoordinator.withGameLock(appId) { + ModDeploymentJournalStore.reconcile(ownershipRoot) + }.associateBy { it.installId } val ownershipByInstallId = installs.mapNotNull { install -> ModOwnershipStore.read(ownershipRoot, install.installId)?.let { install.installId to it } }.toMap() @@ -1178,6 +1176,9 @@ object NexusModManager { overlay, ModVerificationDepth.CHANGED_CONTENT, ).issues + val overlayInstallIds = overlay.targets.values.asSequence() + .flatMap { it.contributors.asSequence() } + .mapTo(mutableSetOf()) { it.installId } installs.forEach { install -> val status = runCatching { ModInstallStatus.valueOf(install.status) }.getOrNull() @@ -1247,7 +1248,7 @@ object NexusModManager { ) } } - if (ownership == null && extracted.isDirectory) { + if ((ownership == null || install.installId !in overlayInstallIds) && extracted.isDirectory) { val missing = missingAppliedTargets(install, recipes, gameRootDir, winePrefix).take(3) if (missing.isNotEmpty()) { add( @@ -1361,7 +1362,9 @@ object NexusModManager { } suspend fun reconcilePendingDeploymentsForApp(context: Context, appId: String): List = - withContext(Dispatchers.IO) { ModDeploymentJournalStore.reconcile(cacheRoot(context, appId)) } + ModDeploymentCoordinator.withGameLock(appId) { + withContext(Dispatchers.IO) { ModDeploymentJournalStore.reconcile(cacheRoot(context, appId)) } + } fun hasMissingAppliedTargets( install: ModInstall, diff --git a/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt index b2767e364c..e033f765d2 100644 --- a/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt +++ b/app/src/main/java/app/gamenative/mods/WindowsTargetNamespace.kt @@ -89,6 +89,7 @@ class WindowsTargetNamespace( } object WindowsPathIdentity { + private val invalidSegmentChars = setOf('<', '>', ':', '"', '|', '?', '*') private val reservedNames = buildSet { addAll(listOf("con", "prn", "aux", "nul")) (1..9).forEach { index -> @@ -125,6 +126,6 @@ object WindowsPathIdentity { private fun isUnsafeWindowsSegment(segment: String): Boolean { val key = segmentKey(segment) if (key.isBlank() || key.substringBefore('.') in reservedNames) return true - return segment.any { it.code < 32 || it in setOf('<', '>', ':', '"', '|', '?', '*') } + return segment.any { it.code < 32 || it in invalidSegmentChars } } } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt index e3989ad6f3..5e1aaeaf86 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsFomodSections.kt @@ -353,8 +353,7 @@ internal fun FomodWizardDialog( pendingResult = PendingFomodResult( drafts = result.recipes.map { it.toDraft() }, plan = result.plan, - unsupportedCount = result.plan?.unresolvedCount - ?: result.unsupportedMappings.size, + unsupportedCount = result.plan?.unresolvedCount ?: 0, unresolvedDetails = result.plan?.files.orEmpty() .filter { file -> file.status == PlannedFileStatus.UNSUPPORTED || diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index d3faabbef4..08167a62b2 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -5,6 +5,7 @@ import androidx.compose.foundation.clickable import androidx.compose.foundation.horizontalScroll import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.itemsIndexed import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box @@ -98,6 +99,7 @@ import app.gamenative.mods.ResolvedModTargetRoot import app.gamenative.ui.component.NoExtractOutlinedTextField import app.gamenative.utils.StorageUtils import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.delay import kotlinx.coroutines.withContext import java.io.File import java.text.DateFormat @@ -890,7 +892,10 @@ private fun PlacementPlanFilesDialog( ) } } - items(groupRows, key = { "${group.name}:${it.source}:${it.target}:${it.previousTarget}" }) { row -> + itemsIndexed( + groupRows, + key = { index, row -> "${group.name}:${row.source}:${row.target}:${row.previousTarget}:$index" }, + ) { _, row -> Column( modifier = Modifier.fillMaxWidth().padding(horizontal = 20.dp, vertical = 10.dp), verticalArrangement = Arrangement.spacedBy(4.dp), @@ -1634,6 +1639,7 @@ private fun ContainerDestinationPickerDialog( if (dir != null && dir.isDirectory) { loading = true try { + delay(150) val root = currentRoot browserEntries = withContext(Dispatchers.IO) { if (root == null) { diff --git a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt index 0f14335cf7..ad074d8733 100644 --- a/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt +++ b/app/src/test/java/app/gamenative/mods/AutomaticPlacementPlannerTest.kt @@ -189,6 +189,24 @@ class AutomaticPlacementPlannerTest { ) } + @Test + fun combinedRules_blockOneSourceMappedToDifferentDestinations() { + val result = AutomaticPlacementPlanner.plan( + gameName = "Classic game", + entries = archive("Mods/Plugin.dll"), + context = AutomaticPlacementContext( + defaultTargetRelativePath = "Packages", + defaultTargetIsProven = true, + existingGameDirectories = setOf("Mods"), + ), + ) + + val combined = result.candidates.single { it.id == "rules:combined-v1" } + + assertEquals(PlannedFileStatus.CONFLICTED, combined.plan.files.single().status) + assertTrue(combined.plan.blockingIssues.any { "multiple destinations" in it.lowercase() }) + } + @Test fun provenModDirectory_preservesPackageWrapperAndStripsOnlySelectedVariant() { val entries = archive( diff --git a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt index 7be9318663..47b2667ded 100644 --- a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt +++ b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt @@ -83,6 +83,34 @@ class BethesdaPluginManagerTest { assertEquals(false, plugins.single().enabled) } + @Test + fun detectPlugins_usesRenamedTargetExtension() = runBlocking { + val install = install() + File(install.extractedPath, "Choice/Plugin.bin").apply { + parentFile?.mkdirs() + writeText("plugin") + } + val renamedRecipe = ModPlacementRecipe( + installId = install.installId, + sourceSubpath = "Choice/Plugin.bin", + targetRoot = ModTargetRoot.GAME_DIR.name, + targetRelativePath = "Data", + targetFileName = "Renamed.esp", + mode = ModPlacementMode.OVERWRITE_COPY.name, + ) + + val plugins = BethesdaPluginManager.detectPlugins( + installs = listOf(install), + recipesByInstallId = mapOf(install.installId to listOf(renamedRecipe)), + prioritiesByInstallId = emptyMap(), + gameRootDir = gameDir, + winePrefix = "", + pluginsFile = null, + ) + + assertEquals(listOf("Renamed.esp"), plugins.map { it.fileName }) + } + @Test fun detectPlugins_canDefaultNewPluginsToEnabled() = runBlocking { val install = install() diff --git a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt index f48ea29ace..24e517ae61 100644 --- a/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodEnvironmentTest.kt @@ -163,6 +163,28 @@ class FomodEnvironmentTest { } } + @Test + fun inspectedEmptyPluginState_provesMissingDependency() { + val root = createTempDirectory("fomod-empty-plugin-state").toFile() + try { + val dependency = FomodPluginDependency("Absent.esp", FomodRequiredFileState.MISSING) + val installer = FomodInstaller( + moduleName = "Missing plugin dependency", + requiredFiles = emptyList(), + steps = emptyList(), + moduleDependencies = FomodDependencyExpression(pluginDependencies = listOf(dependency)), + ) + + val snapshot = FomodEnvironmentSnapshotBuilder.build(installer, "Skyrim Special Edition", root) + + assertTrue(snapshot.pluginStateKnown) + assertEquals(FomodFactState.TRUE, snapshot.evaluate(dependency)) + assertEquals(FomodFactState.UNKNOWN, FomodEnvironmentSnapshot().evaluate(dependency)) + } finally { + root.deleteRecursively() + } + } + private fun peHeader(machine: Int): ByteArray = ByteArray(512).also { bytes -> bytes[0] = 'M'.code.toByte() bytes[1] = 'Z'.code.toByte() diff --git a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt index 5e4f97d0c0..5e54b7a5a4 100644 --- a/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt +++ b/app/src/test/java/app/gamenative/mods/FomodInstallerTest.kt @@ -151,7 +151,6 @@ class FomodInstallerTest { mode = ModPlacementMode.OVERWRITE_COPY.name, ) - assertTrue(result.unsupportedMappings.isEmpty()) assertEquals( listOf("Common->Data", "Option->Data/textures", "Plugins/Example.esp->Data"), result.recipes.map { "${it.sourceSubpath}->${it.targetRelativePath}" }, @@ -227,7 +226,6 @@ class FomodInstallerTest { selectedPluginNames = emptySet(), ) - assertTrue(result.unsupportedMappings.isEmpty()) assertEquals("Renamed.esp", result.recipes.single().targetFileName) } diff --git a/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt b/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt index 4a97027c86..9a4fe01a1e 100644 --- a/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt @@ -3,6 +3,7 @@ package app.gamenative.mods import app.gamenative.data.ModInstall import java.io.File import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse import org.junit.Assert.assertNull import org.junit.Rule import org.junit.Test @@ -33,6 +34,19 @@ class ModConfigurationDraftTest { assertNull(ModConfigurationDraftStore.read(root, install)) } + @Test + fun writeFailure_isBestEffortAndLeavesNoTemporaryFile() { + val invalidRoot = temporaryFolder.newFile("not-a-directory") + val draft = ModConfigurationDraft( + installId = "install", + archiveIdentity = "archive", + placementChoice = "AUTOMATIC", + ) + + assertFalse(ModConfigurationDraftStore.write(invalidRoot, draft)) + assertFalse(File(invalidRoot, "configuration/install.json.tmp").exists()) + } + private fun install(hash: String) = ModInstall( installId = "install", appId = "game", diff --git a/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt b/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt index 203cc19752..106e395932 100644 --- a/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModDeploymentJournalTest.kt @@ -1,7 +1,10 @@ package app.gamenative.mods import app.gamenative.data.ModPlacementMode +import java.io.File import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull import org.junit.Assert.assertTrue import org.junit.Rule import org.junit.Test @@ -55,7 +58,7 @@ class ModDeploymentJournalTest { ) val journal = ModDeploymentJournalStore.begin(root, "install", "game", plan) ModDeploymentJournalStore.checkpoint(root, journal, ModDeploymentCheckpoint.VERIFYING) - ModOwnershipStore.writePending( + ModOwnershipStore.write( root, ModOwnershipManifest( installId = "install", @@ -88,5 +91,17 @@ class ModDeploymentJournalTest { ) } + @Test + fun delete_removesCurrentAndTemporaryJournalFiles() { + val root = temporaryFolder.newFolder("delete") + ModDeploymentJournalStore.begin(root, "install", "game", emptyPlan()) + val temporary = File(root, "journals/install.json.tmp").apply { writeText("partial") } + + ModDeploymentJournalStore.delete(root, "install") + + assertNull(ModDeploymentJournalStore.read(root, "install")) + assertFalse(temporary.exists()) + } + private fun emptyPlan() = ModMaterializationPlan("install", emptyList(), emptyList()) } diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index d784996e57..75190fdf0e 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -806,6 +806,30 @@ class ModMaterializerTest { assertFalse(created.exists()) } + @Test + fun rollbackAppliedPlan_removesOwnedCopyDirectoryMarkerAndDirectory() = runBlocking { + File(extracted, "Package/file.txt").apply { + parentFile?.mkdirs() + writeText("payload") + } + val plan = ModMaterializer.materializationPlan( + install(), + listOf(recipe(ModPlacementMode.COPY, targetRelativePath = "Mods")), + gameDir, + "", + ) + val copiedDirectory = File(gameDir, "Mods/Package") + + val applied = ModMaterializer.apply(install(), plan, backupDir, allowOverwrite = false) + assertTrue(applied.errors.toString(), applied.errors.isEmpty()) + assertTrue(copiedDirectory.isDirectory) + + val rollbackSkipped = ModMaterializer.rollbackAppliedPlan(plan) + + assertTrue(rollbackSkipped.toString(), rollbackSkipped.isEmpty()) + assertFalse(copiedDirectory.exists()) + } + @Test fun reviewedPackageVariant_materializesInsideItsPreservedWrapper() = runBlocking { val paths = listOf( diff --git a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt index 6d84100dde..822993b426 100644 --- a/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModOwnershipManifestTest.kt @@ -19,8 +19,7 @@ class ModOwnershipManifestTest { val root = temporaryFolder.newFolder("cache") val low = manifest("low", "Data/Scripts/X.pex", "one", priority = 10) val high = manifest("high", "data/scripts/x.pex", "two", priority = 20) - ModOwnershipStore.writePending(root, low) - ModOwnershipStore.commit(root, low.installId) + ModOwnershipStore.write(root, low) assertEquals(low, ModOwnershipStore.read(root, low.installId)) val overlay = ModProfileOverlayPlanner.build(listOf(high, low), mapOf("high" to 20, "low" to 10)) @@ -213,10 +212,8 @@ class ModOwnershipManifestTest { planProducerVersion = 2, ) val second = first.copy(planDigest = "second", files = first.files.map { it.copy(installedHash = "two") }) - ModOwnershipStore.writePending(root, first) - ModOwnershipStore.commit(root, first.installId) - ModOwnershipStore.writePending(root, second) - ModOwnershipStore.commit(root, second.installId) + ModOwnershipStore.write(root, first) + ModOwnershipStore.write(root, second) val restored = ModOwnershipStore.reviewedPlan(root, "install") @@ -226,6 +223,37 @@ class ModOwnershipManifestTest { assertEquals(first, ModOwnershipStore.readPrevious(root, "install")) } + @Test + fun reviewedPlan_matchesRepeatedSourceByLogicalDestination() { + val manifest = ModOwnershipManifest( + installId = "install", + appId = "game", + planDigest = "digest", + files = listOf( + owned("Shared.bin", "Data/First.bin").copy(installedSize = 11), + owned("Shared.bin", "Data/Second.bin").copy(installedSize = 22), + ), + decisions = listOf("Data/Second.bin", "Data/First.bin").map { target -> + ModInstallDecision( + sourceRelativePath = "Shared.bin", + targetRoot = "GAME_DIR", + targetRelativePath = target, + normalizedTargetKey = WindowsPathIdentity.targetKey("GAME_DIR", target).orEmpty(), + status = PlannedFileStatus.PLACED.name, + origin = PlacementOrigin.FOMOD_REQUIRED.name, + mode = ModPlacementMode.OVERWRITE_COPY.name, + priority = 0, + reason = "fixture", + outcome = "CREATED", + ) + }, + ) + + val restored = manifest.reviewedPlanOrNull()!! + + assertEquals(listOf(22L, 11L), restored.files.map { it.sizeBytes }) + } + private fun owned(source: String, target: String): ModOwnedFile = ModOwnedFile( sourceRelativePath = source, targetRoot = "GAME_DIR", From e651b15aa28efb1593f8cd97d3c2fb1a9e76da20 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 12 Sep 2026 19:14:51 -0500 Subject: [PATCH 55/60] Protect placement sidecars and destination checks --- .../gamenative/mods/DurableFileReplacement.kt | 23 +++++++++++++++++++ .../gamenative/mods/ModConfigurationDraft.kt | 9 +------- .../gamenative/mods/ModDeploymentJournal.kt | 9 +------- .../gamenative/mods/ModOwnershipManifest.kt | 19 ++------------- .../app/gamenative/mods/NexusModManager.kt | 2 +- .../dialog/NexusModsPlacementSections.kt | 12 ++++++---- .../dialog/PlacementWorkspaceModels.kt | 6 +++++ .../mods/ModConfigurationDraftTest.kt | 9 ++++++++ .../gamenative/mods/ModMaterializerTest.kt | 16 +++++++++++++ .../dialog/PlacementWorkspaceModelsTest.kt | 11 +++++++++ 10 files changed, 77 insertions(+), 39 deletions(-) create mode 100644 app/src/main/java/app/gamenative/mods/DurableFileReplacement.kt diff --git a/app/src/main/java/app/gamenative/mods/DurableFileReplacement.kt b/app/src/main/java/app/gamenative/mods/DurableFileReplacement.kt new file mode 100644 index 0000000000..4ea67bd3fa --- /dev/null +++ b/app/src/main/java/app/gamenative/mods/DurableFileReplacement.kt @@ -0,0 +1,23 @@ +package app.gamenative.mods + +import java.io.File +import java.nio.file.Files +import java.nio.file.StandardCopyOption + +internal fun replaceWithPreparedFile(source: File, target: File) { + runCatching { + Files.move( + source.toPath(), + target.toPath(), + StandardCopyOption.ATOMIC_MOVE, + StandardCopyOption.REPLACE_EXISTING, + ) + }.getOrElse { atomicFailure -> + runCatching { + Files.move(source.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING) + }.getOrElse { replacementFailure -> + replacementFailure.addSuppressed(atomicFailure) + throw replacementFailure + } + } +} diff --git a/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt b/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt index 0307714e84..b166adb146 100644 --- a/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt +++ b/app/src/main/java/app/gamenative/mods/ModConfigurationDraft.kt @@ -6,8 +6,6 @@ import app.gamenative.data.ModPlacementRecipe import app.gamenative.data.ModTargetRoot import java.io.File import java.io.FileOutputStream -import java.nio.file.Files -import java.nio.file.StandardCopyOption import java.util.Locale import kotlinx.serialization.Serializable import kotlinx.serialization.decodeFromString @@ -91,12 +89,7 @@ object ModConfigurationDraftStore { output.write(json.encodeToString(draft.copy(updatedAt = System.currentTimeMillis())).toByteArray(Charsets.UTF_8)) output.fd.sync() } - runCatching { - Files.move(temp.toPath(), target.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING) - }.getOrElse { - temp.copyTo(target, overwrite = true) - temp.delete() - } + replaceWithPreparedFile(temp, target) }.fold( onSuccess = { true }, onFailure = { diff --git a/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt index 46c4a57ea7..8a0d485f1f 100644 --- a/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt +++ b/app/src/main/java/app/gamenative/mods/ModDeploymentJournal.kt @@ -2,8 +2,6 @@ package app.gamenative.mods import java.io.File import java.io.FileOutputStream -import java.nio.file.Files -import java.nio.file.StandardCopyOption import java.util.UUID import kotlinx.serialization.Serializable import kotlinx.serialization.decodeFromString @@ -116,12 +114,7 @@ object ModDeploymentJournalStore { output.write(json.encodeToString(journal).toByteArray(Charsets.UTF_8)) output.fd.sync() } - runCatching { - Files.move(temp.toPath(), current.toPath(), StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING) - }.getOrElse { - temp.copyTo(current, overwrite = true) - temp.delete() - } + replaceWithPreparedFile(temp, current) } private fun readFile(file: File): ModDeploymentJournal? = diff --git a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt index 919487b939..08c7261048 100644 --- a/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt +++ b/app/src/main/java/app/gamenative/mods/ModOwnershipManifest.kt @@ -351,10 +351,9 @@ object ModOwnershipStore { output.fd.sync() } if (current.isFile) { - previous.delete() - moveReplacing(current, previous) + replaceWithPreparedFile(current, previous) } - moveReplacing(temp, current) + replaceWithPreparedFile(temp, current) } fun delete(root: File, installId: String) { @@ -470,20 +469,6 @@ object ModOwnershipStore { }.getOrNull() } - private fun moveReplacing(source: File, target: File) { - runCatching { - Files.move( - source.toPath(), - target.toPath(), - java.nio.file.StandardCopyOption.ATOMIC_MOVE, - java.nio.file.StandardCopyOption.REPLACE_EXISTING, - ) - }.getOrElse { - source.copyTo(target, overwrite = true) - source.delete() - } - } - internal fun sha256(file: File): String { if (!file.isFile) return "" val digest = MessageDigest.getInstance("SHA-256") diff --git a/app/src/main/java/app/gamenative/mods/NexusModManager.kt b/app/src/main/java/app/gamenative/mods/NexusModManager.kt index 4b0104d4d4..0b16fa5451 100644 --- a/app/src/main/java/app/gamenative/mods/NexusModManager.kt +++ b/app/src/main/java/app/gamenative/mods/NexusModManager.kt @@ -1584,7 +1584,7 @@ object NexusModManager { ) missing += plan.errors.values plan.operations.filter { it.mode == ModPlacementMode.SYMLINK }.forEach { entry -> - if (!Files.isSymbolicLink(entry.target.toPath()) && !entry.target.exists()) { + if (!Files.isSymbolicLink(entry.target.toPath())) { missing += entry.target.absolutePath } if (missing.size >= 3) return missing.take(3) diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt index 08167a62b2..dba3a2f3ee 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsPlacementSections.kt @@ -1926,7 +1926,7 @@ private fun ContainerDestinationPickerDialog( } if (showNewFolderDialog && !readOnly) { - val validName = validVirtualDestinationFolderName(newFolderName) + val validDestination = validVirtualDestinationFolder(currentDir, newFolderName) AlertDialog( onDismissRequest = { showNewFolderDialog = false }, title = { Text(stringResource(R.string.nexus_new_destination_folder)) }, @@ -1938,7 +1938,7 @@ private fun ContainerDestinationPickerDialog( onValueChange = { newFolderName = it }, modifier = Modifier.fillMaxWidth(), label = { Text(stringResource(R.string.nexus_folder_name)) }, - isError = newFolderName.isNotBlank() && !validName, + isError = newFolderName.isNotBlank() && !validDestination, singleLine = true, ) Text( @@ -1952,11 +1952,13 @@ private fun ContainerDestinationPickerDialog( Button( onClick = { currentDir?.let { parent -> - selectedDestination = File(parent, newFolderName.trim()) - showNewFolderDialog = false + File(parent, newFolderName.trim()).takeIf { !it.exists() || it.isDirectory }?.let { + selectedDestination = it + showNewFolderDialog = false + } } }, - enabled = validName && currentDir != null, + enabled = validDestination, ) { Text(stringResource(R.string.nexus_use_folder)) } }, dismissButton = { diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt index baf83a36e2..d53b528ecd 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModels.kt @@ -212,6 +212,12 @@ internal fun validVirtualDestinationFolderName(value: String): Boolean { WindowsPathIdentity.normalizedRelativeKey(name) != null } +internal fun validVirtualDestinationFolder(parent: File?, value: String): Boolean { + if (parent == null || !validVirtualDestinationFolderName(value)) return false + val candidate = File(parent, value.trim()) + return !candidate.exists() || candidate.isDirectory +} + internal enum class PlacementReviewCategory { ADDED, REPLACED, diff --git a/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt b/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt index 9a4fe01a1e..b875bb8350 100644 --- a/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModConfigurationDraftTest.kt @@ -5,6 +5,7 @@ import java.io.File import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue import org.junit.Rule import org.junit.Test import org.junit.rules.TemporaryFolder @@ -47,6 +48,14 @@ class ModConfigurationDraftTest { assertFalse(File(invalidRoot, "configuration/install.json.tmp").exists()) } + @Test + fun preparedFileReplacementFailure_preservesExistingTarget() { + val target = temporaryFolder.newFile("current.json").apply { writeText("valid") } + + assertTrue(runCatching { replaceWithPreparedFile(File(target.parentFile, "missing.tmp"), target) }.isFailure) + assertEquals("valid", target.readText()) + } + private fun install(hash: String) = ModInstall( installId = "install", appId = "game", diff --git a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt index 75190fdf0e..63bea8a67c 100644 --- a/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModMaterializerTest.kt @@ -874,6 +874,22 @@ class ModMaterializerTest { assertFalse(File(gameDir, "Mods/CharacterEditor/v1.6").exists()) } + @Test + fun missingTargetCheck_rejectsARegularFileInPlaceOfASymlink() { + File(extracted, "payload.txt").writeText("source") + File(gameDir, "linked.txt").writeText("replacement") + val appliedInstall = install().copy(status = ModInstallStatus.APPLIED.name) + + assertTrue( + NexusModManager.hasMissingAppliedTargets( + appliedInstall, + listOf(recipe(ModPlacementMode.SYMLINK, "payload.txt", "linked.txt")), + gameDir, + "", + ), + ) + } + @Test fun apply_refusesToMaterializeAnyPartOfAnIncompleteReviewedPlan() = runBlocking { File(extracted, "ready.txt").writeText("ready") diff --git a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt index ee99254f68..b2c2c63f25 100644 --- a/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt +++ b/app/src/test/java/app/gamenative/ui/component/dialog/PlacementWorkspaceModelsTest.kt @@ -81,6 +81,17 @@ class PlacementWorkspaceModelsTest { assertFalse(validVirtualDestinationFolderName("CON")) } + @Test + fun virtualDestinationFolder_rejectsAnExistingFile() { + val parent = temporaryFolder.newFolder("destination-parent") + File(parent, "existing").writeText("file") + File(parent, "directory").mkdir() + + assertFalse(validVirtualDestinationFolder(parent, "existing")) + assertTrue(validVirtualDestinationFolder(parent, "new folder")) + assertTrue(validVirtualDestinationFolder(parent, "directory")) + } + @Test fun destinationBrowser_showsFilesAndClassifiesPlanAndOwnership() { val rootDir = temporaryFolder.newFolder("game") From 8a559c72911d8468864d455c3b56ae5b91d9e1b7 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Sat, 12 Sep 2026 19:38:47 -0500 Subject: [PATCH 56/60] Accelerate large archive variant detection --- .../app/gamenative/mods/GenericOptionSetDetector.kt | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt index 96e800f1fd..3c3b907c54 100644 --- a/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt +++ b/app/src/main/java/app/gamenative/mods/GenericOptionSetDetector.kt @@ -82,16 +82,19 @@ object GenericOptionSetDetector { val related = siblings.associateWith { root -> siblings.filter { other -> if (root == other) return@filter false - val overlap = signatures.getValue(root).intersect(signatures.getValue(other)).size - val smaller = minOf(signatures.getValue(root).size, signatures.getValue(other).size).coerceAtLeast(1) val versionAlternatives = versionFamilyHasEvidence && root.normalizedKey in versionChoices && other.normalizedKey in versionChoices val wrapperEvidence = root.optionStyleWrapper || other.optionStyleWrapper || parentLooksLikeOptionContainer || installBoundaries.getValue(root).intersect(installBoundaries.getValue(other)).isNotEmpty() - versionAlternatives || - (wrapperEvidence && overlap > 0 && overlap.toDouble() / smaller >= 0.6) + if (versionAlternatives) return@filter true + if (!wrapperEvidence) return@filter false + val rootSignature = signatures.getValue(root) + val otherSignature = signatures.getValue(other) + val overlap = rootSignature.intersect(otherSignature).size + val smaller = minOf(rootSignature.size, otherSignature.size).coerceAtLeast(1) + overlap > 0 && overlap.toDouble() / smaller >= 0.6 } } val visited = mutableSetOf() From b391498343db0583e8ff41e8a8b84638b5ce84b3 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Fri, 18 Sep 2026 20:41:10 -0500 Subject: [PATCH 57/60] Resolve GOG Skyrim plugin metadata paths --- .../gamenative/mods/BethesdaPluginManager.kt | 37 +++++- .../ui/component/dialog/NexusModsDialog.kt | 34 ++++-- .../mods/BethesdaPluginManagerTest.kt | 106 ++++++++++++++++++ 3 files changed, 163 insertions(+), 14 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt index 645330038b..556568be29 100644 --- a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt +++ b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt @@ -1,5 +1,6 @@ package app.gamenative.mods +import app.gamenative.data.GameSource import app.gamenative.data.ModInstall import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementRecipe @@ -25,6 +26,11 @@ enum class BethesdaGame( STARFIELD("Starfield", "Starfield"), } +data class BethesdaPluginFiles( + val targetFile: File, + val stateFile: File, +) + data class BethesdaPlugin( val fileName: String, val installId: String?, @@ -238,10 +244,30 @@ object BethesdaPluginManager { }.getOrDefault(emptyList()) } - fun pluginsFile(winePrefix: String, game: BethesdaGame): File? { + fun pluginFiles( + winePrefix: String, + game: BethesdaGame, + gameSource: GameSource, + ): BethesdaPluginFiles? { if (winePrefix.isBlank()) return null val userHome = ModContainerResolver.getWineUserHome(winePrefix) - return File(userHome, "AppData/Local/${game.localAppDataDir}/plugins.txt") + val isGogSkyrimSpecialEdition = + game == BethesdaGame.SKYRIM_SPECIAL_EDITION && gameSource == GameSource.GOG + val localAppDataDir = if (isGogSkyrimSpecialEdition) { + "Skyrim Special Edition GOG" + } else { + game.localAppDataDir + } + val targetFile = File(userHome, "AppData/Local/$localAppDataDir/plugins.txt") + val legacyFile = if (isGogSkyrimSpecialEdition) { + File(userHome, "AppData/Local/${game.localAppDataDir}/plugins.txt") + } else { + null + } + val stateFile = legacyFile + ?.takeIf { shouldUseLegacyPluginState(targetFile, it) } + ?: targetFile + return BethesdaPluginFiles(targetFile = targetFile, stateFile = stateFile) } fun updateManagedPluginsTxt( @@ -298,6 +324,13 @@ object BethesdaPluginManager { .mapNotNull { parsePluginLine(it, game) } .distinctBy { it.fileName.lowercase() } + private fun shouldUseLegacyPluginState(targetFile: File, legacyFile: File): Boolean { + if (!legacyFile.isFile) return false + val targetLoadOrder = File(targetFile.parentFile, "loadorder.txt") + val legacyLoadOrder = File(legacyFile.parentFile, "loadorder.txt") + return !targetLoadOrder.isFile && legacyLoadOrder.isFile + } + private fun parsePluginLine(line: String, game: BethesdaGame?): PluginEntry? { val trimmed = line.trim() if (trimmed.isBlank() || trimmed.startsWith("#")) return null diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index d52d2f1d55..010a037219 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -1387,6 +1387,9 @@ fun NexusModsDialog( ownershipByInstallId = ownershipByInstallId, ) val game = BethesdaPluginManager.detectGame(libraryItem.name) + val pluginFiles = game?.let { + BethesdaPluginManager.pluginFiles(winePrefix, it, libraryItem.gameSource) + } val detectedPlugins = game?.let { BethesdaPluginManager.detectPlugins( installs = usableInstalls, @@ -1394,7 +1397,7 @@ fun NexusModsDialog( prioritiesByInstallId = priorities, gameRootDir = gameRootDir, winePrefix = winePrefix, - pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, it), + pluginsFile = pluginFiles?.stateFile, ownershipByInstallId = ownershipByInstallId, ) }.orEmpty() @@ -1410,7 +1413,7 @@ fun NexusModsDialog( managedPlugins = detectedPlugins, game = it, gameRootDir = gameRootDir, - pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, it), + pluginsFile = pluginFiles?.stateFile, ) }.orEmpty(), pluginAssetIssues = if (game != null) BethesdaPluginManager.diagnosePluginAssets(detectedPlugins) else emptyList(), @@ -1584,7 +1587,7 @@ fun NexusModsDialog( fun writePluginState(updated: List) { val game = bethesdaGame ?: return - val pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game) ?: return + val pluginsFile = BethesdaPluginManager.pluginFiles(winePrefix, game, libraryItem.gameSource)?.targetFile ?: return scope.launch { val issues = withContext(Dispatchers.IO) { BethesdaPluginManager.updateManagedPluginsTxt( @@ -1702,6 +1705,9 @@ fun NexusModsDialog( transition = overlayTransition, ) val game = BethesdaPluginManager.detectGame(libraryItem.name) + val pluginFiles = game?.let { + BethesdaPluginManager.pluginFiles(winePrefix, it, libraryItem.gameSource) + } val plugins = game?.let { BethesdaPluginManager.detectPlugins( installs = configuredInstalls, @@ -1709,7 +1715,7 @@ fun NexusModsDialog( prioritiesByInstallId = stateByInstallId.mapValues { state -> state.value.priority }, gameRootDir = gameRootDir, winePrefix = winePrefix, - pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, it), + pluginsFile = pluginFiles?.stateFile, ownershipByInstallId = ownershipByInstallId, defaultEnabled = true, ) @@ -1720,7 +1726,7 @@ fun NexusModsDialog( managedPlugins = plugins, game = it, gameRootDir = gameRootDir, - pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, it), + pluginsFile = pluginFiles?.stateFile, ) }.orEmpty() val pluginAssetIssues = if (game != null) BethesdaPluginManager.diagnosePluginAssets(plugins) else emptyList() @@ -1918,8 +1924,8 @@ fun NexusModsDialog( } val game = BethesdaPluginManager.detectGame(libraryItem.name) if (errors == 0 && game != null) { - val pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game) - if (pluginsFile != null) { + val pluginFiles = BethesdaPluginManager.pluginFiles(winePrefix, game, libraryItem.gameSource) + if (pluginFiles != null) { val appliedInstalls = plan.configuredInstalls.map { it.copy(status = ModInstallStatus.APPLIED.name) } val appliedOwnership = plan.ownershipByInstallId.toMutableMap().apply { plan.installsToApply.forEach { install -> @@ -1936,14 +1942,14 @@ fun NexusModsDialog( prioritiesByInstallId = plan.stateByInstallId.mapValues { it.value.priority }, gameRootDir = gameRootDir, winePrefix = winePrefix, - pluginsFile = pluginsFile, + pluginsFile = pluginFiles.stateFile, ownershipByInstallId = appliedOwnership, defaultEnabled = true, ), collectionPluginOrder, ) BethesdaPluginManager.updateManagedPluginsTxt( - file = pluginsFile, + file = pluginFiles.targetFile, managedPlugins = detectedPlugins, game = game, gameRootDir = gameRootDir, @@ -1952,7 +1958,7 @@ fun NexusModsDialog( managedPlugins = detectedPlugins, game = game, gameRootDir = gameRootDir, - pluginsFile = pluginsFile, + pluginsFile = pluginFiles.targetFile, ) ProfileOrderApplyResult( errors = errors, @@ -2045,7 +2051,9 @@ fun NexusModsDialog( installer = installer, gameName = libraryItem.name, gameRootDir = gameRootDir, - pluginsFile = game?.let { BethesdaPluginManager.pluginsFile(winePrefix, it) }, + pluginsFile = game?.let { + BethesdaPluginManager.pluginFiles(winePrefix, it, libraryItem.gameSource)?.stateFile + }, ) } ?: FomodEnvironmentSnapshot(), ) @@ -2803,7 +2811,9 @@ fun NexusModsDialog( installer = installer, gameName = libraryItem.name, gameRootDir = gameRootDir, - pluginsFile = BethesdaPluginManager.pluginsFile(winePrefix, game), + pluginsFile = BethesdaPluginManager + .pluginFiles(winePrefix, game, libraryItem.gameSource) + ?.stateFile, ) } withContext(Dispatchers.Default) { diff --git a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt index 47b2667ded..d0e867857c 100644 --- a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt +++ b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt @@ -1,5 +1,6 @@ package app.gamenative.mods +import app.gamenative.data.GameSource import app.gamenative.data.ModInstall import app.gamenative.data.ModInstallStatus import app.gamenative.data.ModPlacementMode @@ -37,6 +38,92 @@ class BethesdaPluginManagerTest { assertEquals(BethesdaGame.STARFIELD, BethesdaPluginManager.detectGame("Starfield")) } + @Test + fun pluginFiles_resolvesOnlyGogSkyrimSpecialEditionToStoreSpecificPath() { + assertPluginPath( + game = BethesdaGame.SKYRIM_SPECIAL_EDITION, + gameSource = GameSource.STEAM, + expectedDirectory = "Skyrim Special Edition", + ) + assertPluginPath( + game = BethesdaGame.SKYRIM_SPECIAL_EDITION, + gameSource = GameSource.GOG, + expectedDirectory = "Skyrim Special Edition GOG", + ) + assertPluginPath( + game = BethesdaGame.FALLOUT4, + gameSource = GameSource.GOG, + expectedDirectory = "Fallout4", + ) + } + + @Test + fun pluginFiles_readsLegacyGogStateUntilCorrectPathIsWritten() { + val winePrefix = winePrefix() + val localAppData = File(winePrefix, "drive_c/users/steamuser/AppData/Local") + val legacyFile = File(localAppData, "Skyrim Special Edition/plugins.txt").apply { + parentFile?.mkdirs() + writeText("*SkyUI_SE.esp\n") + } + File(legacyFile.parentFile, "loadorder.txt").writeText("SkyUI_SE.esp\n") + val targetFile = File(localAppData, "Skyrim Special Edition GOG/plugins.txt").apply { + parentFile?.mkdirs() + writeText("SkyUI_SE.esp\n*External.esp\n") + } + val legacyText = legacyFile.readText() + + val pending = BethesdaPluginManager.pluginFiles( + winePrefix = winePrefix.absolutePath, + game = BethesdaGame.SKYRIM_SPECIAL_EDITION, + gameSource = GameSource.GOG, + )!! + + assertEquals(targetFile.absolutePath, pending.targetFile.absolutePath) + assertEquals(legacyFile.absolutePath, pending.stateFile.absolutePath) + + BethesdaPluginManager.updateManagedPluginsTxt( + file = pending.targetFile, + managedPlugins = listOf( + BethesdaPlugin("SkyUI_SE.esp", "skyui", "SkyUI", "", enabled = true, priority = 0), + ), + game = BethesdaGame.SKYRIM_SPECIAL_EDITION, + ) + + val migrated = BethesdaPluginManager.pluginFiles( + winePrefix = winePrefix.absolutePath, + game = BethesdaGame.SKYRIM_SPECIAL_EDITION, + gameSource = GameSource.GOG, + )!! + assertEquals(targetFile.absolutePath, migrated.stateFile.absolutePath) + assertEquals("*External.esp\n*SkyUI_SE.esp\n", targetFile.readText()) + assertEquals(legacyText, legacyFile.readText()) + } + + @Test + fun pluginFiles_prefersExistingGogManagedState() { + val winePrefix = winePrefix() + val localAppData = File(winePrefix, "drive_c/users/steamuser/AppData/Local") + val legacyFile = File(localAppData, "Skyrim Special Edition/plugins.txt").apply { + parentFile?.mkdirs() + writeText("*Legacy.esp\n") + } + File(legacyFile.parentFile, "loadorder.txt").writeText("Legacy.esp\n") + val targetFile = File(localAppData, "Skyrim Special Edition GOG/plugins.txt").apply { + parentFile?.mkdirs() + writeText("*Gog.esp\n") + } + File(targetFile.parentFile, "loadorder.txt").writeText("Gog.esp\n") + + val files = BethesdaPluginManager.pluginFiles( + winePrefix = winePrefix.absolutePath, + game = BethesdaGame.SKYRIM_SPECIAL_EDITION, + gameSource = GameSource.GOG, + )!! + + assertEquals(targetFile.absolutePath, files.targetFile.absolutePath) + assertEquals(targetFile.absolutePath, files.stateFile.absolutePath) + } + @Test fun detectPlugins_readsPlannedPluginFilesAndEnabledState() = runBlocking { val install = install() @@ -567,6 +654,25 @@ class BethesdaPluginManagerTest { ) } + private fun winePrefix(): File = File(tempDir, "prefix").apply { + File(this, "drive_c/users/steamuser").mkdirs() + } + + private fun assertPluginPath( + game: BethesdaGame, + gameSource: GameSource, + expectedDirectory: String, + ) { + val winePrefix = winePrefix() + val files = BethesdaPluginManager.pluginFiles(winePrefix.absolutePath, game, gameSource)!! + val expected = File( + winePrefix, + "drive_c/users/steamuser/AppData/Local/$expectedDirectory/plugins.txt", + ) + assertEquals(expected.absolutePath, files.targetFile.absolutePath) + assertEquals(expected.absolutePath, files.stateFile.absolutePath) + } + private fun recipe(installId: String): ModPlacementRecipe = ModPlacementRecipe( installId = installId, From 865e2db728f4d0cf5e9dc62697e7bac6d135e9ee Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Fri, 18 Sep 2026 21:24:13 -0500 Subject: [PATCH 58/60] Preserve legacy GOG plugin entries during migration --- .../gamenative/mods/BethesdaPluginManager.kt | 18 +++++++++++++++++- .../ui/component/dialog/NexusModsDialog.kt | 8 +++++--- .../mods/BethesdaPluginManagerTest.kt | 16 ++++++++++++---- 3 files changed, 34 insertions(+), 8 deletions(-) diff --git a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt index 556568be29..13490bad36 100644 --- a/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt +++ b/app/src/main/java/app/gamenative/mods/BethesdaPluginManager.kt @@ -275,13 +275,14 @@ object BethesdaPluginManager { managedPlugins: List, game: BethesdaGame? = null, gameRootDir: File? = null, + migrationSourceFile: File? = null, ) { file.parentFile?.mkdirs() val managedByName = managedPlugins.associateBy { it.fileName.lowercase() } val usesMarkers = usesAsteriskEnabledMarkers(game) val basePlugins = gameRootDir?.let { root -> baseGamePlugins(game, root, managedByName.keys) }.orEmpty() val baseByName = basePlugins.map { it.lowercase() }.toSet() - val retainedLines = pluginFileVariants(file) + val targetRetainedLines = pluginFileVariants(file) .flatMap { existingFile -> if (existingFile.isFile) existingFile.readLines() else emptyList() } .filter { line -> val entry = parsePluginLine(line, game) ?: return@filter true @@ -289,6 +290,21 @@ object BethesdaPluginManager { } .map { if (usesMarkers) it else normalizePluginLineForNoMarkerGame(it) } .distinctPluginLines(game) + val targetRetainedNames = targetRetainedLines + .mapNotNull { parsePluginLine(it, game)?.fileName?.lowercase() } + .toSet() + val migratedRetainedLines = migrationSourceFile + ?.takeUnless { it.absolutePath.equals(file.absolutePath, ignoreCase = true) } + ?.let { source -> readPluginEntries(source, game) } + .orEmpty() + .filter { entry -> + val key = entry.fileName.lowercase() + key !in targetRetainedNames && key !in managedByName && key !in baseByName + } + .map { entry -> + if (entry.enabled) enabledPluginLine(entry.fileName, usesMarkers) else entry.fileName + } + val retainedLines = (targetRetainedLines + migratedRetainedLines).distinctPluginLines(game) val baseLines = basePlugins.map { enabledPluginLine(it, usesMarkers) } val managedLines = managedPlugins .distinctBy { it.fileName.lowercase() } diff --git a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt index 010a037219..de092c2946 100644 --- a/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt +++ b/app/src/main/java/app/gamenative/ui/component/dialog/NexusModsDialog.kt @@ -1587,20 +1587,21 @@ fun NexusModsDialog( fun writePluginState(updated: List) { val game = bethesdaGame ?: return - val pluginsFile = BethesdaPluginManager.pluginFiles(winePrefix, game, libraryItem.gameSource)?.targetFile ?: return + val pluginFiles = BethesdaPluginManager.pluginFiles(winePrefix, game, libraryItem.gameSource) ?: return scope.launch { val issues = withContext(Dispatchers.IO) { BethesdaPluginManager.updateManagedPluginsTxt( - file = pluginsFile, + file = pluginFiles.targetFile, managedPlugins = updated, game = game, gameRootDir = gameRootDir, + migrationSourceFile = pluginFiles.stateFile, ) BethesdaPluginManager.diagnosePluginMasters( managedPlugins = updated, game = game, gameRootDir = gameRootDir, - pluginsFile = pluginsFile, + pluginsFile = pluginFiles.targetFile, ) } bethesdaPlugins = updated @@ -1953,6 +1954,7 @@ fun NexusModsDialog( managedPlugins = detectedPlugins, game = game, gameRootDir = gameRootDir, + migrationSourceFile = pluginFiles.stateFile, ) val issues = BethesdaPluginManager.diagnosePluginMasters( managedPlugins = detectedPlugins, diff --git a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt index d0e867857c..48bc604205 100644 --- a/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt +++ b/app/src/test/java/app/gamenative/mods/BethesdaPluginManagerTest.kt @@ -63,12 +63,12 @@ class BethesdaPluginManagerTest { val localAppData = File(winePrefix, "drive_c/users/steamuser/AppData/Local") val legacyFile = File(localAppData, "Skyrim Special Edition/plugins.txt").apply { parentFile?.mkdirs() - writeText("*SkyUI_SE.esp\n") + writeText("# legacy comment\n*SkyUI_SE.esp\n*LegacyOnly.esp\n*External.esp\n") } - File(legacyFile.parentFile, "loadorder.txt").writeText("SkyUI_SE.esp\n") + File(legacyFile.parentFile, "loadorder.txt").writeText("SkyUI_SE.esp\nLegacyOnly.esp\nExternal.esp\n") val targetFile = File(localAppData, "Skyrim Special Edition GOG/plugins.txt").apply { parentFile?.mkdirs() - writeText("SkyUI_SE.esp\n*External.esp\n") + writeText("SkyUI_SE.esp\nExternal.esp\n*TargetOnly.esp\n# target comment\n") } val legacyText = legacyFile.readText() @@ -87,6 +87,7 @@ class BethesdaPluginManagerTest { BethesdaPlugin("SkyUI_SE.esp", "skyui", "SkyUI", "", enabled = true, priority = 0), ), game = BethesdaGame.SKYRIM_SPECIAL_EDITION, + migrationSourceFile = pending.stateFile, ) val migrated = BethesdaPluginManager.pluginFiles( @@ -95,7 +96,14 @@ class BethesdaPluginManagerTest { gameSource = GameSource.GOG, )!! assertEquals(targetFile.absolutePath, migrated.stateFile.absolutePath) - assertEquals("*External.esp\n*SkyUI_SE.esp\n", targetFile.readText()) + assertEquals( + "External.esp\n*TargetOnly.esp\n# target comment\n*LegacyOnly.esp\n*SkyUI_SE.esp\n", + targetFile.readText(), + ) + assertEquals( + "External.esp\nTargetOnly.esp\nLegacyOnly.esp\nSkyUI_SE.esp\n", + File(targetFile.parentFile, "loadorder.txt").readText(), + ) assertEquals(legacyText, legacyFile.readText()) } From f0e407ce61b97fec1a2c63b65828110ad63b8c9b Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Fri, 18 Sep 2026 21:45:01 -0500 Subject: [PATCH 59/60] Stabilize archive planning performance gate --- .../java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt index 309e059ac4..8cd9ce8ba8 100644 --- a/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt +++ b/app/src/test/java/app/gamenative/mods/ModArchiveIndexPerformanceTest.kt @@ -47,7 +47,8 @@ class ModArchiveIndexPerformanceTest { assertTrue(plan.blockingIssues.toString(), plan.isComplete) assertEquals(50_000, plan.placedCount) - assertTrue("Planning took ${elapsed}ms", elapsed < 5_000) + val budgetMs = if (System.getenv("CI").equals("true", ignoreCase = true)) 15_000 else 5_000 + assertTrue("Planning took ${elapsed}ms (budget ${budgetMs}ms)", elapsed < budgetMs) } @Test From f386b231c0ca4d6f0343e7e6eeeea9ae0e4367a2 Mon Sep 17 00:00:00 2001 From: Nightwalker743 Date: Tue, 22 Sep 2026 11:19:47 -0500 Subject: [PATCH 60/60] Complete Nexus translations and require explicit database migrations --- .../java/app/gamenative/db/PluviaDatabase.kt | 2 +- .../java/app/gamenative/di/DatabaseModule.kt | 6 ------ app/src/main/res/values-da/strings.xml | 8 +++++++- app/src/main/res/values-de/strings.xml | 8 +++++++- app/src/main/res/values-es/strings.xml | 8 +++++++- app/src/main/res/values-fr/strings.xml | 8 +++++++- app/src/main/res/values-it/strings.xml | 8 +++++++- app/src/main/res/values-ja/strings.xml | 8 +++++++- app/src/main/res/values-ko/strings.xml | 8 +++++++- app/src/main/res/values-pl/strings.xml | 8 +++++++- app/src/main/res/values-pt-rBR/strings.xml | 8 +++++++- app/src/main/res/values-ro/strings.xml | 8 +++++++- app/src/main/res/values-ru/strings.xml | 8 +++++++- app/src/main/res/values-uk/strings.xml | 8 +++++++- app/src/main/res/values-zh-rCN/strings.xml | 8 +++++++- app/src/main/res/values-zh-rTW/strings.xml | 8 +++++++- app/src/main/res/values/strings.xml | 16 ++++++++-------- 17 files changed, 107 insertions(+), 29 deletions(-) diff --git a/app/src/main/java/app/gamenative/db/PluviaDatabase.kt b/app/src/main/java/app/gamenative/db/PluviaDatabase.kt index f77690a563..4f84821a6a 100644 --- a/app/src/main/java/app/gamenative/db/PluviaDatabase.kt +++ b/app/src/main/java/app/gamenative/db/PluviaDatabase.kt @@ -85,7 +85,7 @@ const val DATABASE_NAME = "pluvia.db" // AutoMigration(from = 16, to = 17), // Disabled auto-migration due to duplicated column in previous version (upstream PR #1048) // duplicate column name: ufs_parse_version (code 1 SQLITE_ERROR) - // v16 users will fallback to destructive migration (only cached Steam data, re-fetched on login) + // Version 16 cannot upgrade automatically; no destructive fallback is configured. AutoMigration(from = 17, to = 18), // Added workshop_mods, enabled_workshop_item_ids, workshop_download_pending to steam_app AutoMigration(from = 18, to = 19), // Added recovered_install_size_bytes to app_info AutoMigration(from = 19, to = 20), // Added custom_install_path to app_info diff --git a/app/src/main/java/app/gamenative/di/DatabaseModule.kt b/app/src/main/java/app/gamenative/di/DatabaseModule.kt index ad98f37045..402f66fb4d 100644 --- a/app/src/main/java/app/gamenative/di/DatabaseModule.kt +++ b/app/src/main/java/app/gamenative/di/DatabaseModule.kt @@ -30,8 +30,6 @@ class DatabaseModule { @Provides @Singleton fun provideDatabase(@ApplicationContext context: Context): PluviaDatabase { - // The db will be considered unstable during development. - // Once stable we should add a (room) db migration return Room.databaseBuilder(context, PluviaDatabase::class.java, DATABASE_NAME) .addMigrations( ROOM_MIGRATION_V7_to_V8, @@ -39,10 +37,6 @@ class DatabaseModule { ROOM_MIGRATION_V24_to_V25, ROOM_MIGRATION_V26_to_V27, ) - // Versions 1-6 predate the first retained migration. Version 16 has no - // 16 -> 17 migration because that historical schema could contain a - // duplicated column. Every newer supported schema migrates in place. - .fallbackToDestructiveMigrationFrom(true, 1, 2, 3, 4, 5, 6, 16) .build() } diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 113be3a25f..28421e3a98 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2362,7 +2362,7 @@ Modtager filer Avanceret placering Skjul avanceret placering - Automatisk placering anbefales. Åbn kun avanceret placering for at vælge forudindstillinger, genbruge et layout eller tilknytte filer manuelt. + Automatisk placering er et bedste skøn. Kontrollér, at de planlagte filer og destinationer følger moddens installationsvejledning. Hvis ikke, skal du åbne Avanceret placering og vælge Brugerdefineret for selv at placere dem. Installer på destinationen Indholdet af %1$s Mappen %1$s og dens indhold @@ -2467,4 +2467,10 @@ Gennemgå placering Mapper på øverste niveau beholder deres navne; filer i roden placeres direkte i destinationen %1$d standardfil(er) erstattet af dine FOMOD-valg + Modrækkefølgen blev ikke ændret. Manglende eller ændrede administrerede filer: %1$d. Kør kontrol af installationen, og løs problemerne først. + Placering fuldført. I alt: %1$d; opdateret: %2$d; allerede ajour: %3$d; sikkerhedskopieret: %4$d%5$s + Installationen mislykkedes; sikker tilbagerulning blev forsøgt. Fejl: %1$d + Sidste modinstallation mislykkedes + Moddet blev ikke markeret som installeret. Ændringer blev rullet tilbage, hvor det kunne bekræftes sikkert. Gennemgå filfejlene nedenfor, og gå tilbage til Placering for at rette eller prøve installationen igen. + Filfejl: %1$d diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 7d9150b6b1..7bbb3f0888 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2432,7 +2432,7 @@ Erhält Dateien Erweiterte Platzierung Erweiterte Platzierung ausblenden - Die automatische Platzierung wird empfohlen. Öffne die erweiterte Platzierung nur für Vorlagen, frühere Layouts oder manuelle Zuordnungen. + Die automatische Platzierung ist eine Schätzung. Prüfe, ob die geplanten Dateien und Zielordner der Installationsanleitung des Mods entsprechen. Falls nicht, öffne Erweiterte Platzierung und wähle Benutzerdefiniert, um sie selbst zuzuordnen. Am Ziel installieren Inhalt von %1$s Ordner %1$s und sein Inhalt @@ -2537,4 +2537,10 @@ Platzierung prüfen Ordner der obersten Ebene behalten ihre Namen; Dateien im Stammverzeichnis werden direkt am Ziel abgelegt %1$d Standarddatei(en) durch deine FOMOD-Auswahl ersetzt + Die Mod-Reihenfolge wurde nicht geändert. Fehlende oder veränderte verwaltete Dateien: %1$d. Prüfe zuerst den Installationszustand und behebe die Probleme. + Platzierung abgeschlossen. Insgesamt: %1$d; aktualisiert: %2$d; bereits aktuell: %3$d; gesichert: %4$d%5$s + Installation fehlgeschlagen; eine sichere Rücksetzung wurde versucht. Fehler: %1$d + Letzte Mod-Installation fehlgeschlagen + Der Mod wurde nicht als installiert markiert. Änderungen wurden zurückgesetzt, soweit dies sicher überprüft werden konnte. Prüfe die Dateifehler unten und kehre zu Platzierung zurück, um den Mod zu korrigieren oder erneut zu versuchen. + Dateifehler: %1$d diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index a069b45028..1c33e36d27 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2490,7 +2490,7 @@ Recibirá archivos Colocación avanzada Ocultar colocación avanzada - Se recomienda la colocación automática. Abre las opciones avanzadas solo para elegir ajustes, reutilizar un diseño o asignar archivos manualmente. + La colocación automática es una estimación. Comprueba que los archivos y destinos previstos coincidan con las instrucciones del mod. Si no es así, abre Colocación avanzada y elige Personalizada para asignarlos tú mismo. En el destino, instalar Contenido de %1$s Carpeta %1$s y su contenido @@ -2595,4 +2595,10 @@ Revisar colocación Las carpetas de nivel superior conservan sus nombres; los archivos raíz se colocan directamente en el destino %1$d archivo(s) predeterminado(s) reemplazado(s) por tus opciones de FOMOD + No se cambió el orden de los mods. Archivos gestionados ausentes o modificados: %1$d. Comprueba primero el estado de la instalación y resuelve esos problemas. + Colocación completada. Total: %1$d; actualizados: %2$d; ya al día: %3$d; con copia de seguridad: %4$d%5$s + La instalación falló; se intentó una reversión segura. Errores: %1$d + Falló la última instalación del mod + El mod no se marcó como instalado. Los cambios se revirtieron cuando pudieron verificarse de forma segura. Revisa los errores de archivo de abajo y vuelve a Colocación para corregir o reintentar este mod. + Errores de archivo: %1$d diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index e2b512e1e6..cd969bad78 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2492,7 +2492,7 @@ Recevra des fichiers Placement avancé Masquer le placement avancé - Le placement automatique est recommandé. Ouvrez les options avancées uniquement pour choisir un préréglage, réutiliser une disposition ou associer des fichiers manuellement. + Le placement automatique est une estimation. Vérifiez que les fichiers et leurs destinations correspondent aux instructions du mod. Sinon, ouvrez Placement avancé et choisissez Personnalisé pour les associer vous-même. À la destination, installer Contenu de %1$s Dossier %1$s et son contenu @@ -2597,4 +2597,10 @@ Vérifier le placement Les dossiers de premier niveau conservent leur nom ; les fichiers racine sont placés directement dans la destination %1$d fichier(s) par défaut remplacé(s) par vos choix FOMOD + L’ordre des mods n’a pas été modifié. Fichiers gérés manquants ou modifiés : %1$d. Vérifiez d’abord l’état de l’installation et résolvez ces problèmes. + Placement terminé. Total : %1$d ; mis à jour : %2$d ; déjà à jour : %3$d ; sauvegardés : %4$d%5$s + Échec de l’installation ; un retour arrière sûr a été tenté. Erreurs : %1$d + Échec de la dernière installation de mod + Le mod n’a pas été marqué comme installé. Les modifications ont été annulées lorsque cela pouvait être vérifié sans risque. Consultez les erreurs de fichiers ci-dessous, puis revenez à Placement pour corriger ou réessayer ce mod. + Erreurs de fichiers : %1$d diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index 453ab70d8f..1a80870103 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2483,7 +2483,7 @@ Riceverà file Posizionamento avanzato Nascondi posizionamento avanzato - È consigliato il posizionamento automatico. Apri le opzioni avanzate solo per scegliere preset, riutilizzare un layout o mappare manualmente i file. + Il posizionamento automatico è una stima. Verifica che i file e le destinazioni previsti corrispondano alle istruzioni del mod. In caso contrario, apri Posizionamento avanzato e scegli Personalizzato per assegnarli manualmente. Nella destinazione, installa Contenuto di %1$s Cartella %1$s e relativo contenuto @@ -2588,4 +2588,10 @@ Controlla posizionamento Le cartelle di primo livello mantengono i loro nomi; i file nella radice vengono inseriti direttamente nella destinazione %1$d file predefinito/i sostituito/i dalle tue scelte FOMOD + L’ordine dei mod non è stato modificato. File gestiti mancanti o modificati: %1$d. Controlla prima lo stato di installazione e risolvi i problemi. + Posizionamento completato. Totale: %1$d; aggiornati: %2$d; già aggiornati: %3$d; salvati in backup: %4$d%5$s + Installazione non riuscita; è stato tentato un ripristino sicuro. Errori: %1$d + Ultima installazione del mod non riuscita + Il mod non è stato contrassegnato come installato. Le modifiche sono state annullate dove era possibile verificarle in sicurezza. Controlla gli errori dei file qui sotto, poi torna a Posizionamento per correggere o riprovare questo mod. + Errori dei file: %1$d diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index b74348e1f3..b7ef8a4147 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2445,7 +2445,7 @@ ファイルの配置先 詳細な配置 詳細な配置を隠す - 自動配置を推奨します。プリセット、以前のレイアウト、手動マッピングが必要な場合のみ詳細設定を開いてください。 + 自動配置は推定結果です。予定されたファイルと配置先が MOD の導入手順に合っているか確認してください。合わない場合は詳細な配置を開き、カスタムを選んで手動で指定してください。 インストール先での配置 %1$s の内容 %1$s フォルダーとその内容 @@ -2550,4 +2550,10 @@ 配置を確認 最上位フォルダーは名前を保持し、ルートファイルは移動先に直接配置されます FOMOD の選択により %1$d 個の既定ファイルを置き換えました + MOD の順序は変更されませんでした。不足または変更された管理対象ファイル: %1$d。先にインストール状態を確認し、問題を解決してください。 + 配置完了。合計: %1$d、更新: %2$d、変更不要: %3$d、バックアップ: %4$d%5$s + インストールに失敗しました。安全なロールバックを試行しました。エラー: %1$d + 直前の MOD のインストールに失敗しました + MOD は適用済みとして記録されませんでした。安全に確認できた変更は元に戻しました。以下のファイルエラーを確認し、配置画面に戻って修正または再試行してください。 + ファイルエラー: %1$d diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index b84beb8cfd..17e93d0d9c 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2486,7 +2486,7 @@ 파일을 받을 폴더 고급 배치 고급 배치 숨기기 - 자동 배치를 권장합니다. 프리셋, 이전 레이아웃 또는 수동 매핑이 필요할 때만 고급 배치를 여세요. + 자동 배치는 추정 결과입니다. 배치할 파일과 대상 폴더가 모드 설치 안내와 일치하는지 확인하세요. 일치하지 않으면 고급 배치에서 사용자 지정을 선택해 직접 지정하세요. 대상에 설치할 항목 %1$s의 내용 %1$s 폴더와 그 내용 @@ -2591,4 +2591,10 @@ 배치 검토 최상위 폴더는 이름을 유지하고 루트 파일은 대상에 직접 배치됩니다 FOMOD 선택으로 기본 파일 %1$d개 교체됨 + 모드 순서를 변경하지 않았습니다. 누락되었거나 수정된 관리 파일: %1$d. 먼저 설치 상태를 확인하고 문제를 해결하세요. + 배치 완료. 전체: %1$d; 업데이트: %2$d; 이미 최신 상태: %3$d; 백업: %4$d%5$s + 설치에 실패했습니다. 안전한 롤백을 시도했습니다. 오류: %1$d + 마지막 모드 설치 실패 + 모드가 설치 완료로 표시되지 않았습니다. 안전하게 확인할 수 있는 변경 사항은 되돌렸습니다. 아래 파일 오류를 확인한 뒤 배치 화면으로 돌아가 수정하거나 다시 시도하세요. + 파일 오류: %1$d diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index ae431bcc9f..aec000c8c3 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2498,7 +2498,7 @@ Otrzyma pliki Zaawansowane rozmieszczenie Ukryj zaawansowane rozmieszczenie - Zalecane jest rozmieszczenie automatyczne. Opcje zaawansowane otwieraj tylko dla ustawień wstępnych, wcześniejszego układu lub ręcznego mapowania. + Automatyczne rozmieszczenie jest jedynie oszacowaniem. Sprawdź, czy planowane pliki i miejsca docelowe są zgodne z instrukcją instalacji moda. Jeśli nie, otwórz Zaawansowane rozmieszczenie i wybierz Własne, aby przypisać je ręcznie. W miejscu docelowym zainstaluj Zawartość %1$s Folder %1$s i jego zawartość @@ -2603,4 +2603,10 @@ Sprawdź rozmieszczenie Foldery najwyższego poziomu zachowują nazwy; pliki główne trafiają bezpośrednio do miejsca docelowego Liczba plików domyślnych zastąpionych przez wybory FOMOD: %1$d + Kolejność modów nie została zmieniona. Brakujące lub zmodyfikowane pliki zarządzane: %1$d. Najpierw sprawdź stan instalacji i rozwiąż problemy. + Rozmieszczenie zakończone. Łącznie: %1$d; zaktualizowano: %2$d; już aktualne: %3$d; utworzono kopie zapasowe: %4$d%5$s + Instalacja nie powiodła się; podjęto próbę bezpiecznego wycofania zmian. Błędy: %1$d + Ostatnia instalacja moda nie powiodła się + Mod nie został oznaczony jako zainstalowany. Zmiany cofnięto tam, gdzie można było to bezpiecznie zweryfikować. Sprawdź poniższe błędy plików, a następnie wróć do Rozmieszczenia, aby poprawić lub ponowić instalację moda. + Błędy plików: %1$d diff --git a/app/src/main/res/values-pt-rBR/strings.xml b/app/src/main/res/values-pt-rBR/strings.xml index a4ea4f4c44..55ca2f622f 100644 --- a/app/src/main/res/values-pt-rBR/strings.xml +++ b/app/src/main/res/values-pt-rBR/strings.xml @@ -2362,7 +2362,7 @@ Receberá arquivos Posicionamento avançado Ocultar posicionamento avançado - O posicionamento automático é recomendado. Abra as opções avançadas apenas para predefinições, layouts anteriores ou mapeamento manual. + O posicionamento automático é uma estimativa. Confira se os arquivos e destinos planejados seguem as instruções de instalação do mod. Caso contrário, abra Posicionamento avançado e escolha Personalizado para defini-los manualmente. No destino, instalar Conteúdo de %1$s Pasta %1$s e seu conteúdo @@ -2467,4 +2467,10 @@ Revisar posicionamento As pastas de nível superior mantêm seus nomes; os arquivos da raiz vão diretamente para o destino %1$d arquivo(s) padrão substituído(s) pelas suas escolhas no FOMOD + A ordem dos mods não foi alterada. Arquivos gerenciados ausentes ou modificados: %1$d. Verifique a integridade da instalação e resolva esses problemas primeiro. + Posicionamento concluído. Total: %1$d; atualizados: %2$d; já atualizados: %3$d; com backup: %4$d%5$s + A instalação falhou; foi tentada uma reversão segura. Erros: %1$d + A última instalação do mod falhou + O mod não foi marcado como instalado. As alterações foram revertidas onde isso pôde ser verificado com segurança. Confira os erros de arquivo abaixo e volte para Posicionamento para corrigir ou tentar instalar este mod novamente. + Erros de arquivo: %1$d diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 779a583295..796d130470 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2486,7 +2486,7 @@ Va primi fișiere Plasare avansată Ascunde plasarea avansată - Se recomandă plasarea automată. Deschide opțiunile avansate doar pentru presetări, reutilizarea unui aspect sau mapare manuală. + Plasarea automată este doar o estimare. Verifică dacă fișierele și destinațiile planificate respectă instrucțiunile de instalare ale modului. Dacă nu, deschide Plasare avansată și alege Personalizat pentru a le atribui manual. La destinație, instalează Conținutul din %1$s Folderul %1$s și conținutul său @@ -2602,4 +2602,10 @@ Se pregătește suportul pentru launcherul Rockstar Se instalează runtime-ul Social Club Programul de instalare Social Club lipsește din fișierele jocului. Verifică fișierele jocului în Steam și încearcă din nou. + Ordinea modurilor nu a fost schimbată. Fișiere gestionate lipsă sau modificate: %1$d. Verifică mai întâi starea instalării și rezolvă problemele. + Plasare finalizată. Total: %1$d; actualizate: %2$d; deja la zi: %3$d; cu copii de rezervă: %4$d%5$s + Instalarea a eșuat; s-a încercat revenirea în siguranță. Erori: %1$d + Ultima instalare a modului a eșuat + Modul nu a fost marcat ca instalat. Modificările au fost anulate acolo unde acest lucru a putut fi verificat în siguranță. Verifică erorile de fișier de mai jos, apoi revino la Plasare pentru a corecta sau reîncerca instalarea. + Erori de fișier: %1$d diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index dca006bf24..49779d33f6 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2424,7 +2424,7 @@ https://gamenative.app Получит файлы Расширенное размещение Скрыть расширенное размещение - Рекомендуется автоматическое размещение. Открывайте расширенные настройки только для шаблонов, прежней схемы или ручного сопоставления. + Автоматическое размещение — лишь предварительная оценка. Проверьте, соответствуют ли файлы и папки назначения инструкции по установке мода. Если нет, откройте расширенное размещение и выберите ручную настройку. В месте назначения установить Содержимое %1$s Папку %1$s и её содержимое @@ -2529,4 +2529,10 @@ https://gamenative.app Проверить размещение Папки верхнего уровня сохраняют свои имена; файлы из корня помещаются непосредственно в папку назначения Файлов по умолчанию заменено выбранными параметрами FOMOD: %1$d + Порядок модов не изменён. Отсутствующие или изменённые управляемые файлы: %1$d. Сначала проверьте состояние установки и устраните проблемы. + Размещение завершено. Всего: %1$d; обновлено: %2$d; уже актуальны: %3$d; созданы резервные копии: %4$d%5$s + Установка не удалась; предпринята попытка безопасного отката. Ошибки: %1$d + Последняя установка мода не удалась + Мод не отмечен как установленный. Изменения отменены там, где это удалось безопасно проверить. Просмотрите ошибки файлов ниже, затем вернитесь к размещению, чтобы исправить или повторить установку. + Ошибки файлов: %1$d diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 952b642a1b..6b4fe48862 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2494,7 +2494,7 @@ Отримає файли Розширене розміщення Сховати розширене розміщення - Рекомендується автоматичне розміщення. Відкривайте розширені параметри лише для шаблонів, попередньої схеми або ручного зіставлення. + Автоматичне розміщення — лише попередня оцінка. Перевірте, чи відповідають заплановані файли та папки призначення інструкції зі встановлення мода. Якщо ні, відкрийте розширене розміщення та виберіть ручне налаштування. У місці призначення встановити Вміст %1$s Папку %1$s та її вміст @@ -2599,4 +2599,10 @@ Перевірити розміщення Папки верхнього рівня зберігають свої назви; файли з кореня розміщуються безпосередньо в папці призначення Файлів за замовчуванням замінено вибраними параметрами FOMOD: %1$d + Порядок модів не змінено. Відсутні або змінені керовані файли: %1$d. Спочатку перевірте стан встановлення та усуньте проблеми. + Розміщення завершено. Усього: %1$d; оновлено: %2$d; уже актуальні: %3$d; створено резервні копії: %4$d%5$s + Не вдалося встановити мод; виконано спробу безпечного відкату. Помилки: %1$d + Останнє встановлення мода не вдалося + Мод не позначено як встановлений. Зміни скасовано там, де це вдалося безпечно перевірити. Перегляньте помилки файлів нижче, а потім поверніться до розміщення, щоб виправити або повторити встановлення. + Помилки файлів: %1$d diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 35fe4c5c88..87bb5c2211 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2506,7 +2506,7 @@ 将接收文件 高级放置 隐藏高级放置 - 建议使用自动放置。仅在选择预设、复用旧布局或手动映射文件时打开高级选项。 + 自动放置只是估计结果。请核对计划安装的文件和目标位置是否符合模组的安装说明。如果不符，请打开高级放置并选择自定义，手动指定位置。 在目标位置安装 %1$s 的内容 %1$s 文件夹及其内容 @@ -2611,4 +2611,10 @@ 检查放置方式 顶层文件夹保留其名称；根目录文件直接放入目标位置 FOMOD 选择替换了 %1$d 个默认文件 + 模组顺序未更改。缺失或被修改的受管理文件：%1$d。请先检查安装状态并解决这些问题。 + 放置完成。总计：%1$d；已更新：%2$d；已是最新：%3$d；已备份：%4$d%5$s + 安装失败；已尝试安全回滚。错误：%1$d + 上次模组安装失败 + 该模组未被标记为已安装。对于能够安全核实的更改，已尝试回滚。请查看下方的文件错误，然后返回放置页面进行修正或重试。 + 文件错误：%1$d diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index a57ce32d53..22b69a8def 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2497,7 +2497,7 @@ 將接收檔案 進階放置 隱藏進階放置 - 建議使用自動放置。只有選擇預設、重用舊配置或手動對應檔案時才開啟進階選項。 + 自動放置只是估計結果。請核對預計安裝的檔案與目標位置是否符合模組的安裝說明。若不符合，請開啟進階放置並選擇自訂，手動指定位置。 在目標位置安裝 %1$s 的內容 %1$s 資料夾及其內容 @@ -2602,4 +2602,10 @@ 檢查放置方式 頂層資料夾保留其名稱；根目錄檔案直接放入目標位置 FOMOD 選項取代了 %1$d 個預設檔案 + 模組順序未變更。遺失或遭修改的受管理檔案：%1$d。請先檢查安裝狀態並解決這些問題。 + 放置完成。總計：%1$d；已更新：%2$d；已是最新：%3$d；已備份：%4$d%5$s + 安裝失敗；已嘗試安全回復。錯誤：%1$d + 上次模組安裝失敗 + 此模組未標記為已安裝。對於能安全確認的變更，已嘗試回復。請查看下方的檔案錯誤，然後返回放置頁面修正或重試。 + 檔案錯誤：%1$d diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 375dbb6f1f..4a70663dee 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1,4 +1,4 @@ - + GameNative User Login Two Factor @@ -2190,7 +2190,7 @@ Mod order is already applying. Applying mod order. Large mod lists may take a while. Checking mod order - Mod order was not changed because %1$d managed file(s) are missing or modified. Run Install health and resolve those files first. + Mod order was not changed. Missing or modified managed files: %1$d. Run Install health and resolve them first. Fix plugin master warnings before applying order. Checking file conflicts Profile order has existing target files. Use Overwrite files and create backups for mods that should win conflicts. @@ -2200,7 +2200,7 @@ Placement review %1$d of %2$d files planned • %3$d ignored • %4$d need review %1$d default file(s) replaced by your FOMOD choices - %1$s ← %2$s + %1$s ← %2$s Ranked suggestions %1$d. %2$s — %3$d%% coverage Case merge: %1$s @@ -2271,12 +2271,12 @@ Failed to resolve Nexus URL Applying mod files Applied %1$d item(s), backed up %2$d%3$s - Placement complete for %1$d item(s): %2$d updated, %3$d already current, %4$d backed up%5$s + Placement complete. Total: %1$d; updated: %2$d; already current: %3$d; backed up: %4$d%5$s ; %1$d old file(s) left in place - Install failed; safe rollback attempted (%1$d error(s)) - Last mod install failed - The mod was not marked as applied. Changes were rolled back where they could be verified safely. Review the file errors below, then return to Placement to correct or retry this mod. - %1$d file error(s) + Install failed; safe rollback attempted. Errors: %1$d + Last mod install failed + The mod was not marked as applied. Changes were rolled back where they could be verified safely. Review the file errors below, then return to Placement to correct or retry this mod. + File errors: %1$d Mod files are already being applied. Failed to apply mod Configure the FOMOD installer or choose Custom placement before applying.