feat(profile): Improve proxy settings and network handling

rainxchzed · rainxchzed · commit 782e8c0b9751 · 2026-02-26T05:47:23.000+05:00
This commit enhances the proxy configuration UI and ensures proxy settings are applied correctly during application startup and runtime.

- **feat(profile)**: Added a password visibility toggle for proxy authentication.
- **feat(profile)**: Improved proxy settings validation, including port range checking (1-65535) and UI feedback for invalid inputs.
- **feat(profile)**: Added descriptive text for "None" and "System" proxy types and updated the "Save" button to a `FilledTonalButton` with validation logic.
- **fix(network)**: Moved proxy initialization to a synchronous `runBlocking` block within `networkModule` to ensure settings are applied before the first network request.
- **fix(network)**: Refactored `GitHubClientProvider` to use a thread-safe volatile client that updates reactively when proxy configurations change.
- **fix(data)**: Hardened `ProxyRepositoryImpl` with better validation when loading saved configurations and ensured persistence occurs before in-memory application.
- **fix(android)**: Reset the default `java.net.Authenticator` in `HttpClientFactory` to prevent credential leakage across client instances.
- **refactor**: Cleaned up `MainViewModel` and `SharedModules` by removing redundant proxy initialization logic.
diff --git a/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainViewModel.kt b/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainViewModel.kt
@@ -7,12 +7,8 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.flow.first
-import zed.rainxch.core.data.network.ProxyManager
-import zed.rainxch.core.domain.model.ProxyConfig
 import zed.rainxch.core.domain.repository.AuthenticationState
 import zed.rainxch.core.domain.repository.InstalledAppsRepository
-import zed.rainxch.core.domain.repository.ProxyRepository
 import zed.rainxch.core.domain.repository.RateLimitRepository
 import zed.rainxch.core.domain.repository.ThemesRepository
 import zed.rainxch.core.domain.use_cases.SyncInstalledAppsUseCase
@@ -22,8 +18,7 @@ class MainViewModel(
     private val installedAppsRepository: InstalledAppsRepository,
     private val authenticationState: AuthenticationState,
     private val rateLimitRepository: RateLimitRepository,
-    private val syncUseCase: SyncInstalledAppsUseCase,
-    private val proxyRepository: ProxyRepository
+    private val syncUseCase: SyncInstalledAppsUseCase
 ) : ViewModel() {
 
     private val _state = MutableStateFlow(MainState())
@@ -99,26 +94,6 @@ class MainViewModel(
                 installedAppsRepository.checkAllForUpdates()
             }
         }
-
-        viewModelScope.launch(Dispatchers.IO) {
-            val savedConfig = proxyRepository.getProxyConfig().first()
-            when (savedConfig) {
-                is ProxyConfig.None -> ProxyManager.setNoProxy()
-                is ProxyConfig.System -> ProxyManager.setSystemProxy()
-                is ProxyConfig.Http -> ProxyManager.setHttpProxy(
-                    host = savedConfig.host,
-                    port = savedConfig.port,
-                    username = savedConfig.username,
-                    password = savedConfig.password
-                )
-                is ProxyConfig.Socks -> ProxyManager.setSocksProxy(
-                    host = savedConfig.host,
-                    port = savedConfig.port,
-                    username = savedConfig.username,
-                    password = savedConfig.password
-                )
-            }
-        }
     }
 
     fun onAction(action: MainAction) {
diff --git a/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/di/SharedModules.kt b/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/di/SharedModules.kt
@@ -15,8 +15,7 @@ val mainModule: Module = module {
             installedAppsRepository = get(),
             rateLimitRepository = get(),
             syncUseCase = get(),
-            authenticationState = get(),
-            proxyRepository = get()
+            authenticationState = get()
         )
     }
 }
diff --git a/core/data/src/androidMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.android.kt b/core/data/src/androidMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.android.kt
@@ -10,6 +10,8 @@ import java.net.PasswordAuthentication
 import java.net.ProxySelector
 
 actual fun createPlatformHttpClient(proxyConfig: ProxyConfig): HttpClient {
+    java.net.Authenticator.setDefault(null)
+
     return HttpClient(OkHttp) {
         engine {
             when (proxyConfig) {
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/di/SharedModule.kt
@@ -4,6 +4,8 @@ import io.ktor.client.HttpClient
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
 import org.koin.dsl.module
 import zed.rainxch.core.data.data_source.TokenStore
 import zed.rainxch.core.data.data_source.impl.DefaultTokenStore
@@ -26,6 +28,7 @@ import zed.rainxch.core.data.repository.ThemesRepositoryImpl
 import zed.rainxch.core.domain.getPlatform
 import zed.rainxch.core.domain.logging.GitHubStoreLogger
 import zed.rainxch.core.domain.model.Platform
+import zed.rainxch.core.domain.model.ProxyConfig
 import zed.rainxch.core.domain.repository.AuthenticationState
 import zed.rainxch.core.domain.repository.FavouritesRepository
 import zed.rainxch.core.domain.repository.InstalledAppsRepository
@@ -104,6 +107,29 @@ val coreModule = module {
 
 val networkModule = module {
     single<GitHubClientProvider> {
+        // Load saved proxy config SYNCHRONOUSLY before creating the client provider
+        // so the very first HTTP client uses the correct proxy. This is critical for
+        // users in regions where direct GitHub access is blocked (e.g. China).
+        runBlocking {
+            val config = get<ProxyRepository>().getProxyConfig().first()
+            when (config) {
+                is ProxyConfig.None -> ProxyManager.setNoProxy()
+                is ProxyConfig.System -> ProxyManager.setSystemProxy()
+                is ProxyConfig.Http -> ProxyManager.setHttpProxy(
+                    host = config.host,
+                    port = config.port,
+                    username = config.username,
+                    password = config.password
+                )
+                is ProxyConfig.Socks -> ProxyManager.setSocksProxy(
+                    host = config.host,
+                    port = config.port,
+                    username = config.username,
+                    password = config.password
+                )
+            }
+        }
+
         GitHubClientProvider(
             tokenStore = get(),
             rateLimitRepository = get(),
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/GitHubClientProvider.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/GitHubClientProvider.kt
@@ -5,13 +5,11 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.stateIn
+import kotlinx.coroutines.flow.drop
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import zed.rainxch.core.data.data_source.TokenStore
@@ -24,37 +22,36 @@ class GitHubClientProvider(
     proxyConfigFlow: StateFlow<ProxyConfig>
 ) {
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
-    private var currentClient: HttpClient? = null
     private val mutex = Mutex()
 
-    private val _client: StateFlow<HttpClient> = proxyConfigFlow
-        .map { proxyConfig ->
-            mutex.withLock {
-                currentClient?.close()
-                val newClient = createGitHubHttpClient(
-                    tokenStore = tokenStore,
-                    rateLimitRepository = rateLimitRepository,
-                    proxyConfig = proxyConfig
-                )
-                currentClient = newClient
-                newClient
+    @Volatile
+    private var currentClient: HttpClient = createGitHubHttpClient(
+        tokenStore = tokenStore,
+        rateLimitRepository = rateLimitRepository,
+        proxyConfig = proxyConfigFlow.value
+    )
+
+    init {
+        proxyConfigFlow
+            .drop(1)
+            .distinctUntilChanged()
+            .onEach { proxyConfig ->
+                mutex.withLock {
+                    currentClient.close()
+                    currentClient = createGitHubHttpClient(
+                        tokenStore = tokenStore,
+                        rateLimitRepository = rateLimitRepository,
+                        proxyConfig = proxyConfig
+                    )
+                }
             }
-        }
-        .stateIn(
-            scope = scope,
-            started = SharingStarted.Eagerly,
-            initialValue = createGitHubHttpClient(
-                tokenStore = tokenStore,
-                rateLimitRepository = rateLimitRepository,
-                proxyConfig = proxyConfigFlow.value
-            ).also { currentClient = it }
-        )
+            .launchIn(scope)
+    }
 
-    /** Get the current HttpClient (always up to date with proxy settings) */
-    val client: HttpClient get() = _client.value
+    val client: HttpClient get() = currentClient
 
     fun close() {
-        currentClient?.close()
+        currentClient.close()
         scope.cancel()
     }
 }
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/ProxyRepositoryImpl.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/ProxyRepositoryImpl.kt
@@ -25,25 +25,41 @@ class ProxyRepositoryImpl(
         return preferences.data.map { prefs ->
             when (prefs[proxyTypeKey]) {
                 "system" -> ProxyConfig.System
-                "http" -> ProxyConfig.Http(
-                    host = prefs[proxyHostKey] ?: "",
-                    port = prefs[proxyPortKey] ?: 8080,
-                    username = prefs[proxyUsernameKey],
-                    password = prefs[proxyPasswordKey]
-                )
-                "socks" -> ProxyConfig.Socks(
-                    host = prefs[proxyHostKey] ?: "",
-                    port = prefs[proxyPortKey] ?: 1080,
-                    username = prefs[proxyUsernameKey],
-                    password = prefs[proxyPasswordKey]
-                )
+                "http" -> {
+                    val host = prefs[proxyHostKey]?.takeIf { it.isNotBlank() }
+                    val port = prefs[proxyPortKey]?.takeIf { it in 1..65535 }
+                    if (host != null && port != null) {
+                        ProxyConfig.Http(
+                            host = host,
+                            port = port,
+                            username = prefs[proxyUsernameKey],
+                            password = prefs[proxyPasswordKey]
+                        )
+                    } else {
+                        ProxyConfig.None
+                    }
+                }
+                "socks" -> {
+                    val host = prefs[proxyHostKey]?.takeIf { it.isNotBlank() }
+                    val port = prefs[proxyPortKey]?.takeIf { it in 1..65535 }
+                    if (host != null && port != null) {
+                        ProxyConfig.Socks(
+                            host = host,
+                            port = port,
+                            username = prefs[proxyUsernameKey],
+                            password = prefs[proxyPasswordKey]
+                        )
+                    } else {
+                        ProxyConfig.None
+                    }
+                }
                 else -> ProxyConfig.None
             }
         }
     }
 
     override suspend fun setProxyConfig(config: ProxyConfig) {
-        applyToProxyManager(config)
+        // Persist first so config survives crashes, then apply in-memory
         preferences.edit { prefs ->
             when (config) {
                 is ProxyConfig.None -> {
@@ -92,6 +108,7 @@ class ProxyRepositoryImpl(
                 }
             }
         }
+        applyToProxyManager(config)
     }
 
     private fun applyToProxyManager(config: ProxyConfig) {
diff --git a/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileAction.kt b/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileAction.kt
@@ -18,5 +18,6 @@ sealed interface ProfileAction {
     data class OnProxyPortChanged(val port: String) : ProfileAction
     data class OnProxyUsernameChanged(val username: String) : ProfileAction
     data class OnProxyPasswordChanged(val password: String) : ProfileAction
+    data object OnProxyPasswordVisibilityToggle : ProfileAction
     data object OnProxySave : ProfileAction
 }
diff --git a/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileEvent.kt b/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileEvent.kt
@@ -4,4 +4,5 @@ sealed interface ProfileEvent {
     data object OnLogoutSuccessful : ProfileEvent
     data class OnLogoutError(val message: String) : ProfileEvent
     data object OnProxySaved : ProfileEvent
+    data class OnProxySaveError(val message: String) : ProfileEvent
 }
diff --git a/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileRoot.kt b/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileRoot.kt
@@ -74,6 +74,12 @@ fun ProfileRoot(
                     snackbarState.showSnackbar(getString(Res.string.proxy_saved))
                 }
             }
+
+            is ProfileEvent.OnProxySaveError -> {
+                coroutineScope.launch {
+                    snackbarState.showSnackbar(event.message)
+                }
+            }
         }
     }
 
diff --git a/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileState.kt b/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileState.kt
@@ -19,6 +19,7 @@ data class ProfileState(
     val proxyPort: String = "",
     val proxyUsername: String = "",
     val proxyPassword: String = "",
+    val isProxyPasswordVisible: Boolean = false,
 )
 
 enum class ProxyType {
diff --git a/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileViewModel.kt b/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/ProfileViewModel.kt
@@ -229,10 +229,16 @@ class ProfileViewModel(
                 _state.update { it.copy(proxyPassword = action.password) }
             }
 
+            ProfileAction.OnProxyPasswordVisibilityToggle -> {
+                _state.update { it.copy(isProxyPasswordVisible = !it.isProxyPasswordVisible) }
+            }
+
             ProfileAction.OnProxySave -> {
                 val currentState = _state.value
-                val port = currentState.proxyPort.toIntOrNull() ?: return
-                val host = currentState.proxyHost.takeIf { it.isNotBlank() } ?: return
+                val port = currentState.proxyPort.toIntOrNull()
+                    ?.takeIf { it in 1..65535 }
+                    ?: return
+                val host = currentState.proxyHost.trim().takeIf { it.isNotBlank() } ?: return
                 val username = currentState.proxyUsername.takeIf { it.isNotBlank() }
                 val password = currentState.proxyPassword.takeIf { it.isNotBlank() }
 
@@ -244,8 +250,17 @@ class ProfileViewModel(
                 }
 
                 viewModelScope.launch {
-                    proxyRepository.setProxyConfig(config)
-                    _events.send(ProfileEvent.OnProxySaved)
+                    runCatching {
+                        proxyRepository.setProxyConfig(config)
+                    }.onSuccess {
+                        _events.send(ProfileEvent.OnProxySaved)
+                    }.onFailure { error ->
+                        _events.send(
+                            ProfileEvent.OnProxySaveError(
+                                error.message ?: "Failed to save proxy settings"
+                            )
+                        )
+                    }
                 }
             }
         }
diff --git a/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/components/sections/Network.kt b/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/components/sections/Network.kt

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,7 @@ val mainModule: Module = module {`
`15`	`15`	`installedAppsRepository = get(),`
`16`	`16`	`rateLimitRepository = get(),`
`17`	`17`	`syncUseCase = get(),`
`18`		`- authenticationState = get(),`
`19`		`- proxyRepository = get()`
	`18`	`+ authenticationState = get()`
`20`	`19`	`)`
`21`	`20`	`}`
`22`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,5 +18,6 @@ sealed interface ProfileAction {`
`18`	`18`	`data class OnProxyPortChanged(val port: String) : ProfileAction`
`19`	`19`	`data class OnProxyUsernameChanged(val username: String) : ProfileAction`
`20`	`20`	`data class OnProxyPasswordChanged(val password: String) : ProfileAction`
	`21`	`+ data object OnProxyPasswordVisibilityToggle : ProfileAction`
`21`	`22`	`data object OnProxySave : ProfileAction`
`22`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,5 @@ sealed interface ProfileEvent {`
`4`	`4`	`data object OnLogoutSuccessful : ProfileEvent`
`5`	`5`	`data class OnLogoutError(val message: String) : ProfileEvent`
`6`	`6`	`data object OnProxySaved : ProfileEvent`
	`7`	`+ data class OnProxySaveError(val message: String) : ProfileEvent`
`7`	`8`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,12 @@ fun ProfileRoot(`
`74`	`74`	`snackbarState.showSnackbar(getString(Res.string.proxy_saved))`
`75`	`75`	`}`
`76`	`76`	`}`
	`77`	`+`
	`78`	`+ is ProfileEvent.OnProxySaveError -> {`
	`79`	`+ coroutineScope.launch {`
	`80`	`+ snackbarState.showSnackbar(event.message)`
	`81`	`+ }`
	`82`	`+ }`
`77`	`83`	`}`
`78`	`84`	`}`
`79`	`85`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ data class ProfileState(`
`19`	`19`	`val proxyPort: String = "",`
`20`	`20`	`val proxyUsername: String = "",`
`21`	`21`	`val proxyPassword: String = "",`
	`22`	`+ val isProxyPasswordVisible: Boolean = false,`
`22`	`23`	`)`
`23`	`24`
`24`	`25`	`enum class ProxyType {`