domain: add AppLanguage model and AppLanguages registry

CLAUDE.md

@@ -104,7 +104,7 @@ Routes defined in `composeApp/.../app/navigation/GithubStoreGraph.kt`, wired in
 |--------|---------|--------------|
 | `core/domain` | Shared contracts | Repository interfaces (`FavouritesRepository`, `StarredRepository`, `InstalledAppsRepository`, `ThemesRepository`, `ProxyRepository`, `RateLimitRepository`), models (`GithubRepoSummary`, `GithubRelease`, `InstalledApp`, `ProxyConfig`, `InstallerType`, `ShizukuAvailability`), system interfaces (`Installer`, `InstallerInfoExtractor`, `InstallerStatusProvider`, `PackageMonitor`) |
 | `core/data` | Shared implementations | `HttpClientFactory` (Ktor + interceptors), `AppDatabase` (Room), `ProxyManager`, `TokenStore`, `LocalizationManager`, platform-specific clients (OkHttp for Android, CIO for Desktop), Shizuku integration (Android: `ShizukuServiceManager`, `ShizukuInstallerWrapper`, `ShizukuInstallerServiceImpl`, `AndroidInstallerStatusProvider`; Desktop: `DesktopInstallerStatusProvider`) |
-| `core/presentation` | Shared UI | `GithubStoreTheme` (Material 3), reusable components (`RepositoryCard`, `GithubStoreButton`), formatting utils, localized strings (11 languages) |
+| `core/presentation` | Shared UI | `GithubStoreTheme` (Material 3), reusable components (`RepositoryCard`, `GithubStoreButton`), formatting utils, localized strings (13 languages) |
 
 ## Tech Stack
 

composeApp/src/androidMain/kotlin/zed/rainxch/githubstore/MainActivity.kt

@@ -13,14 +13,28 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen
 import androidx.core.util.Consumer
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
 import org.koin.android.ext.android.inject
+import zed.rainxch.core.data.services.LocalizationManager
 import zed.rainxch.core.data.utils.AndroidShareManager
+import zed.rainxch.core.domain.repository.TweaksRepository
 import zed.rainxch.core.domain.utils.ShareManager
 import zed.rainxch.githubstore.app.deeplink.DeepLinkParser
 
+private const val LANGUAGE_PREF_READ_TIMEOUT_MS = 2000L
+
 class MainActivity : ComponentActivity() {
     private var deepLinkUri by mutableStateOf<String?>(null)
     private val shareManager: ShareManager by inject()
+    private val tweaksRepository: TweaksRepository by inject()
+    private val localizationManager: LocalizationManager by inject()
 
     override fun onCreate(savedInstanceState: Bundle?) {
         installSplashScreen()
@@ -29,10 +43,54 @@ class MainActivity : ComponentActivity() {
         // Register activity result launcher for file picker (must be before STARTED)
         (shareManager as? AndroidShareManager)?.registerActivityResultLauncher(this)
 
+        // Apply the persisted language override BEFORE Compose kicks off
+        // so the very first frame resolves strings against the user's
+        // choice. `runBlocking` is acceptable here — DataStore reads are
+        // cheap and we only block once per Activity creation (including
+        // the post-language-swap recreate() path below). Without this,
+        // recreate() would briefly flash the old locale before settling.
+        //
+        // The 2s timeout + catch-all is defence against a stalled or
+        // corrupted DataStore: we'd rather boot in system language than
+        // leave the Activity stuck before super.onCreate(), which would
+        // hang the whole app with no visible error.
+        runBlocking {
+            val tag =
+                try {
+                    withTimeoutOrNull(LANGUAGE_PREF_READ_TIMEOUT_MS) {
+                        tweaksRepository.getAppLanguage().first()
+                    }
+                } catch (_: Exception) {
+                    null
+                }
+            localizationManager.setActiveLanguageTag(tag)
+        }
+
         super.onCreate(savedInstanceState)
 
         handleIncomingIntent(intent)
 
+        // Watch for runtime language changes from the Tweaks picker.
+        // Drop the initial emission (already applied above) and
+        // recreate() on any subsequent change — Android preserves
+        // `rememberSaveable` / ViewModel state through recreate, so
+        // scroll offsets, nav stack, and form fields all survive while
+        // every string re-resolves against the new locale. `key()` in
+        // the composition can't pull off the same trick: it changes
+        // the composite-key hash under it, which breaks
+        // `rememberSaveable` lookups and snaps LazyColumns back to 0.
+        lifecycleScope.launch {
+            repeatOnLifecycle(Lifecycle.State.STARTED) {
+                tweaksRepository
+                    .getAppLanguage()
+                    .drop(1)
+                    .collect { newTag ->
+                        localizationManager.setActiveLanguageTag(newTag)
+                        recreate()
+                    }
+            }
+        }
+
         setContent {
             DisposableEffect(Unit) {
                 val listener =

composeApp/src/jvmMain/kotlin/zed/rainxch/githubstore/CrashReporter.kt

@@ -0,0 +1,125 @@
+package zed.rainxch.githubstore
+
+import java.io.File
+import java.io.FileOutputStream
+import java.io.PrintStream
+import java.io.PrintWriter
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+
+object CrashReporter {
+    private const val MAX_SESSION_LOG_BYTES = 5L * 1024 * 1024
+
+    private val logDir: File by lazy { resolveLogDir().also { it.mkdirs() } }
+
+    fun install() {
+        val teed =
+            runCatching {
+                val file = File(logDir, "session.log")
+                rotateIfLarge(file)
+                PrintStream(FileOutputStream(file, true), true, Charsets.UTF_8)
+                    .also { stream ->
+                        System.setOut(TeePrintStream(System.out, stream))
+                        System.setErr(TeePrintStream(System.err, stream))
+                    }
+            }.getOrNull()
+
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            runCatching { writeCrashDump(thread, throwable) }
+            runCatching { throwable.printStackTrace(System.err) }
+        }
+
+        if (teed != null) {
+            println("=== GitHub Store session ${Instant.now()} ===")
+            println(
+                "OS=${System.getProperty("os.name")} ${System.getProperty("os.version")} " +
+                    "(${System.getProperty("os.arch")})",
+            )
+            println(
+                "Java=${System.getProperty("java.version")} (${System.getProperty("java.vendor")})",
+            )
+            println("LogDir=${logDir.absolutePath}")
+        }
+    }
+
+    private fun writeCrashDump(
+        thread: Thread,
+        throwable: Throwable,
+    ) {
+        val file = File(logDir, "crash-${timestamp()}.log")
+        PrintWriter(file, Charsets.UTF_8).use { writer ->
+            writer.println("=== GitHub Store crash ===")
+            writer.println("Time: ${Instant.now()}")
+            writer.println("Thread: ${thread.name}")
+            writer.println(
+                "OS: ${System.getProperty("os.name")} ${System.getProperty("os.version")} " +
+                    "(${System.getProperty("os.arch")})",
+            )
+            writer.println(
+                "Java: ${System.getProperty("java.version")} (${System.getProperty("java.vendor")})",
+            )
+            writer.println()
+            throwable.printStackTrace(writer)
+        }
+    }
+
+    private fun rotateIfLarge(file: File) {
+        if (!file.exists() || file.length() <= MAX_SESSION_LOG_BYTES) return
+        val rotated = File(file.parentFile, "session.1.log")
+        if (rotated.exists()) rotated.delete()
+        file.renameTo(rotated)
+    }
+
+    private fun resolveLogDir(): File {
+        val home = File(System.getProperty("user.home"))
+        val osName = System.getProperty("os.name").orEmpty().lowercase()
+        return when {
+            "mac" in osName -> {
+                File(home, "Library/Logs/GitHub-Store")
+            }
+
+            "win" in osName -> {
+                val localAppData = System.getenv("LOCALAPPDATA")?.let(::File) ?: home
+                File(localAppData, "GitHub-Store/logs")
+            }
+
+            else -> {
+                val stateHome =
+                    System.getenv("XDG_STATE_HOME")?.let(::File)
+                        ?: File(home, ".local/state")
+                File(stateHome, "GitHub-Store/logs")
+            }
+        }
+    }
+
+    private fun timestamp(): String =
+        DateTimeFormatter
+            .ofPattern("yyyyMMdd-HHmmss-SSS")
+            .withZone(ZoneId.systemDefault())
+            .format(Instant.now())
+}
+
+private class TeePrintStream(
+    private val primary: PrintStream,
+    private val secondary: PrintStream,
+) : PrintStream(primary) {
+    override fun write(b: Int) {
+        primary.write(b)
+        runCatching { secondary.write(b) }
+    }
+
+    override fun write(
+        buf: ByteArray,
+        off: Int,
+        len: Int,
+    ) {
+        primary.write(buf, off, len)
+        runCatching { secondary.write(buf, off, len) }
+    }
+
+    override fun flush() {
+        primary.flush()
+        runCatching { secondary.flush() }
+    }
+}

composeApp/src/jvmMain/kotlin/zed/rainxch/githubstore/DesktopApp.kt

@@ -12,8 +12,14 @@ import androidx.compose.ui.input.key.key
 import androidx.compose.ui.input.key.type
 import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
 import org.jetbrains.compose.resources.painterResource
 import org.jetbrains.compose.resources.stringResource
+import org.koin.core.context.GlobalContext
+import zed.rainxch.core.data.services.LocalizationManager
+import zed.rainxch.core.domain.repository.TweaksRepository
 import zed.rainxch.githubstore.app.desktop.KeyboardNavigation
 import zed.rainxch.githubstore.app.desktop.KeyboardNavigationEvent
 import zed.rainxch.githubstore.app.di.initKoin
@@ -23,7 +29,14 @@ import zed.rainxch.githubstore.core.presentation.res.app_name
 import java.awt.Desktop
 import kotlin.system.exitProcess
 
+private const val LANGUAGE_PREF_READ_TIMEOUT_MS = 2000L
+
 fun main(args: Array<String>) {
+    // Install first so anything that blows up during Koin init or
+    // resource loading leaves a diagnosable trail on disk (see
+    // `CrashReporter.resolveLogDir` for the per-OS path).
+    CrashReporter.install()
+
     // Reduce JVM DNS cache TTL so network changes (VPN on/off) are picked up quickly.
     // Default JVM caches positive lookups for 30s and negative lookups forever,
     // which breaks connectivity when a VPN changes DNS/routing mid-session.
@@ -32,6 +45,31 @@ fun main(args: Array<String>) {
 
     initKoin()
 
+    // Apply persisted UI language before any Compose code runs — same
+    // reasoning as on Android (see `MainActivity.onCreate`). Desktop
+    // Compose has no runtime `recreate()` equivalent, so mid-session
+    // language swaps surface as a "restart required" snackbar from the
+    // Tweaks screen; this block just covers the cold-start path so
+    // users see their chosen language immediately on next launch.
+    //
+    // Timeout guards against a stalled DataStore read blocking window
+    // creation and deep-link dispatch — we fall back to system language
+    // rather than hang the launch.
+    runBlocking {
+        val koin = GlobalContext.get()
+        val tweaksRepo = koin.get<TweaksRepository>()
+        val localization = koin.get<LocalizationManager>()
+        val tag =
+            try {
+                withTimeoutOrNull(LANGUAGE_PREF_READ_TIMEOUT_MS) {
+                    tweaksRepo.getAppLanguage().first()
+                }
+            } catch (_: Exception) {
+                null
+            }
+        localization.setActiveLanguageTag(tag)
+    }
+
     val deepLinkArg = args.firstOrNull()
 
     if (deepLinkArg != null && DesktopDeepLink.tryForwardToRunningInstance(deepLinkArg)) {

core/data/src/androidMain/kotlin/zed/rainxch/core/data/services/AndroidLocalizationManager.kt

@@ -3,6 +3,13 @@ package zed.rainxch.core.data.services
 import java.util.Locale
 
 class AndroidLocalizationManager : zed.rainxch.core.data.services.LocalizationManager {
+    /**
+     * Snapshot of the original JVM locale at construction time, so
+     * [setActiveLanguageTag] with a null argument can restore it even
+     * after prior overrides have modified `Locale.getDefault()`.
+     */
+    private val systemDefault: Locale = Locale.getDefault()
+
     override fun getCurrentLanguageCode(): String {
         val locale = Locale.getDefault()
         val language = locale.language
@@ -15,4 +22,15 @@ class AndroidLocalizationManager : zed.rainxch.core.data.services.LocalizationMa
     }
 
     override fun getPrimaryLanguageCode(): String = Locale.getDefault().language
+
+    override fun setActiveLanguageTag(tag: String?) {
+        val normalized = tag?.trim().orEmpty()
+        val target =
+            if (normalized.isEmpty()) {
+                systemDefault
+            } else {
+                Locale.forLanguageTag(normalized)
+            }
+        Locale.setDefault(target)
+    }
 }

core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/TweaksRepositoryImpl.kt

@@ -8,6 +8,7 @@ import androidx.datastore.preferences.core.longPreferencesKey
 import androidx.datastore.preferences.core.stringPreferencesKey
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
+import zed.rainxch.core.domain.model.AppLanguages
 import zed.rainxch.core.domain.model.AppTheme
 import zed.rainxch.core.domain.model.DiscoveryPlatform
 import zed.rainxch.core.domain.model.FontTheme
@@ -211,6 +212,28 @@ class TweaksRepositoryImpl(
         }
     }
 
+    override fun getAppLanguage(): Flow<String?> =
+        preferences.data.map { prefs ->
+            // Treat blank *or* unknown tags as "unset" — guards against
+            // stale writes from older builds that shipped a language
+            // we no longer bundle resources for, which would otherwise
+            // pin the UI to an unresolvable locale.
+            prefs[APP_LANGUAGE_KEY]
+                ?.trim()
+                ?.takeIf { it.isNotEmpty() && AppLanguages.containsTag(it) }
+        }
+
+    override suspend fun setAppLanguage(tag: String?) {
+        preferences.edit { prefs ->
+            val normalized = tag?.trim().orEmpty()
+            if (normalized.isEmpty() || !AppLanguages.containsTag(normalized)) {
+                prefs.remove(APP_LANGUAGE_KEY)
+            } else {
+                prefs[APP_LANGUAGE_KEY] = normalized
+            }
+        }
+    }
+
     companion object {
         private const val DEFAULT_UPDATE_CHECK_INTERVAL_HOURS = 6L
 
@@ -231,5 +254,6 @@ class TweaksRepositoryImpl(
         private val TRANSLATION_PROVIDER_KEY = stringPreferencesKey("translation_provider")
         private val YOUDAO_APP_KEY = stringPreferencesKey("youdao_app_key")
         private val YOUDAO_APP_SECRET = stringPreferencesKey("youdao_app_secret")
+        private val APP_LANGUAGE_KEY = stringPreferencesKey("app_language")
     }
 }

core/data/src/commonMain/kotlin/zed/rainxch/core/data/services/LocalizationManager.kt

@@ -11,4 +11,17 @@ interface LocalizationManager {
      * Returns the primary language code without region (e.g., "zh" from "zh-CN")
      */
     fun getPrimaryLanguageCode(): String
+
+    /**
+     * Overrides the process-wide JVM `Locale.getDefault()` used by
+     * Compose Resources' `LocalComposeEnvironment` for string
+     * resolution. Passing `null` (or blank) restores the original
+     * system locale captured at instance construction.
+     *
+     * Must be called from the composition side (see `App()`) *before*
+     * the `key(appLanguage)`-wrapped content remounts, so the new
+     * locale is picked up when `stringResource` re-reads
+     * `Locale.current` on recomposition.
+     */
+    fun setActiveLanguageTag(tag: String?)
 }