feat(auth): Implement session expiration handling and improved login flow

rainxchzed · rainxchzed · commit ece0f76d2c2a · 2026-02-28T05:57:27.000+05:00
This commit introduces a mechanism to detect and handle expired GitHub sessions and enhances the device authentication UI with countdown timers and better error categorization.

- **feat(auth)**: Added `SessionExpiredDialog` to notify users when their session is invalid or revoked.
- **feat(auth)**: Integrated `UnauthorizedInterceptor` (401 handler) into the Ktor `HttpClient` to automatically trigger session expiration events.
- **feat(auth)**: Added a countdown timer to the device login screen to show remaining time for code verification.
- **feat(auth)**: Introduced `SkipLogin` (Continue as Guest) option to the authentication flow.
- **feat(auth)**: Improved error handling in `AuthenticationViewModel` with specific recovery hints (e.g., connection issues, denied access).
- **refactor(core)**: Updated `AuthenticationState` and `TokenStore` to manage session expiration events and token lifecycle (including `saved_at` timestamp).
- **refactor(cache)**: Added `clearAll()` to `CacheManager` to ensure all local data is purged upon logout or session expiration.
- **i18n**: Added string resources for session expiration, auth hints, and logout notes.
- **chore**: Updated `LogoutDialog` to include a note about revoking access via GitHub settings.
diff --git a/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/Main.kt b/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/Main.kt
@@ -16,6 +16,7 @@ import zed.rainxch.githubstore.app.deeplink.DeepLinkParser
 import zed.rainxch.githubstore.app.navigation.AppNavigation
 import zed.rainxch.githubstore.app.navigation.GithubStoreGraph
 import zed.rainxch.githubstore.app.components.RateLimitDialog
+import zed.rainxch.githubstore.app.components.SessionExpiredDialog
 
 @OptIn(ExperimentalMaterial3ExpressiveApi::class)
 @Composable
@@ -70,6 +71,18 @@ fun App(deepLinkUri: String? = null) {
             }
         }
 
+        if (state.showSessionExpiredDialog) {
+            SessionExpiredDialog(
+                onDismiss = {
+                    viewModel.onAction(MainAction.DismissSessionExpiredDialog)
+                },
+                onSignIn = {
+                    viewModel.onAction(MainAction.DismissSessionExpiredDialog)
+                    navBackStack.navigate(GithubStoreGraph.AuthenticationScreen)
+                }
+            )
+        }
+
         AppNavigation(
             navController = navBackStack
         )
diff --git a/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainAction.kt b/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainAction.kt
@@ -2,4 +2,5 @@ package zed.rainxch.githubstore
 
 sealed interface MainAction {
     data object DismissRateLimitDialog : MainAction
+    data object DismissSessionExpiredDialog : MainAction
 }
diff --git a/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainState.kt b/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainState.kt
@@ -8,6 +8,7 @@ data class MainState(
     val isLoggedIn: Boolean = false,
     val rateLimitInfo: RateLimitInfo? = null,
     val showRateLimitDialog: Boolean = false,
+    val showSessionExpiredDialog: Boolean = false,
     val currentColorTheme: AppTheme = AppTheme.OCEAN,
     val isAmoledTheme: Boolean = false,
     val isDarkTheme: Boolean? = null,
diff --git a/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainViewModel.kt b/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/MainViewModel.kt
@@ -89,6 +89,12 @@ class MainViewModel(
             }
         }
 
+        viewModelScope.launch {
+            authenticationState.sessionExpiredEvent.collect {
+                _state.update { it.copy(showSessionExpiredDialog = true) }
+            }
+        }
+
         viewModelScope.launch(Dispatchers.IO) {
             syncUseCase().onSuccess {
                 installedAppsRepository.checkAllForUpdates()
@@ -101,6 +107,9 @@ class MainViewModel(
             MainAction.DismissRateLimitDialog -> {
                 _state.update { it.copy(showRateLimitDialog = false) }
             }
+            MainAction.DismissSessionExpiredDialog -> {
+                _state.update { it.copy(showSessionExpiredDialog = false) }
+            }
         }
     }
 }
diff --git a/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/components/SessionExpiredDialog.kt b/composeApp/src/commonMain/kotlin/zed/rainxch/githubstore/app/components/SessionExpiredDialog.kt
@@ -0,0 +1,77 @@
+package zed.rainxch.githubstore.app.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.LockOpen
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import org.jetbrains.compose.resources.stringResource
+import zed.rainxch.githubstore.core.presentation.res.*
+
+@Composable
+fun SessionExpiredDialog(
+    onDismiss: () -> Unit,
+    onSignIn: () -> Unit
+) {
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        icon = {
+            Icon(
+                imageVector = Icons.Default.LockOpen,
+                contentDescription = null,
+                tint = MaterialTheme.colorScheme.error
+            )
+        },
+        title = {
+            Text(
+                text = stringResource(Res.string.session_expired_title),
+                style = MaterialTheme.typography.headlineSmall,
+                fontWeight = FontWeight.Black,
+                color = MaterialTheme.colorScheme.onSurface
+            )
+        },
+        text = {
+            Column(
+                verticalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                Text(
+                    text = stringResource(Res.string.session_expired_message),
+                    style = MaterialTheme.typography.bodyMedium,
+                    color = MaterialTheme.colorScheme.outline
+                )
+
+                Text(
+                    text = stringResource(Res.string.session_expired_hint),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.primary
+                )
+            }
+        },
+        confirmButton = {
+            Button(onClick = onSignIn) {
+                Text(
+                    text = stringResource(Res.string.sign_in_again),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onPrimary
+                )
+            }
+        },
+        dismissButton = {
+            TextButton(onClick = onDismiss) {
+                Text(
+                    text = stringResource(Res.string.continue_as_guest),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurface
+                )
+            }
+        }
+    )
+}
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/cache/CacheManager.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/cache/CacheManager.kt
@@ -85,6 +85,11 @@ class CacheManager(
         cacheDao.deleteByPrefix(prefix)
     }
 
+    suspend fun clearAll() {
+        memoryCache.clear()
+        cacheDao.deleteAll()
+    }
+
     suspend fun cleanupExpired() {
         val currentTime = now()
         val expiredKeys = memoryCache.entries
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/data_source/TokenStore.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/data_source/TokenStore.kt
@@ -9,4 +9,5 @@ interface TokenStore {
     fun blockingCurrentToken() : GithubDeviceTokenSuccessDto?
     suspend fun save(token: GithubDeviceTokenSuccessDto)
     suspend fun clear()
+    suspend fun isTokenExpired(): Boolean
 }
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/data_source/impl/DefaultTokenStore.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/data_source/impl/DefaultTokenStore.kt
@@ -19,7 +19,10 @@ class DefaultTokenStore(
     private val json = Json { ignoreUnknownKeys = true }
 
     override suspend fun save(token: GithubDeviceTokenSuccessDto) {
-        val jsonString = json.encodeToString(GithubDeviceTokenSuccessDto.serializer(), token)
+        val stamped = token.copy(
+            savedAtEpochMillis = token.savedAtEpochMillis ?: System.currentTimeMillis()
+        )
+        val jsonString = json.encodeToString(GithubDeviceTokenSuccessDto.serializer(), stamped)
         dataStore.edit { preferences ->
             preferences[TOKEN_KEY] = jsonString
         }
@@ -50,8 +53,15 @@ class DefaultTokenStore(
         }.getOrNull()
     }
 
-
     override suspend fun clear() {
         dataStore.edit { it.remove(TOKEN_KEY) }
     }
+
+    override suspend fun isTokenExpired(): Boolean {
+        val token = currentToken() ?: return true
+        val savedAt = token.savedAtEpochMillis ?: return false
+        val expiresIn = token.expiresIn ?: return false
+        val expiresAtMillis = savedAt + (expiresIn * 1000L)
+        return System.currentTimeMillis() > expiresAtMillis
+    }
 }
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
@@ -143,14 +143,17 @@ val networkModule = module {
         GitHubClientProvider(
             tokenStore = get(),
             rateLimitRepository = get(),
+            authenticationState = get(),
             proxyConfigFlow = ProxyManager.currentProxyConfig
         )
     }
 
     single<HttpClient> {
         createGitHubHttpClient(
             tokenStore = get(),
-            rateLimitRepository = get()
+            rateLimitRepository = get(),
+            authenticationState = get(),
+            scope = get()
         )
     }
 
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/dto/GithubDeviceTokenSuccessDto.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/dto/GithubDeviceTokenSuccessDto.kt
@@ -10,5 +10,6 @@ data class GithubDeviceTokenSuccessDto(
     @SerialName("expires_in") val expiresIn: Long? = null,
     @SerialName("scope") val scope: String? = null,
     @SerialName("refresh_token") val refreshToken: String? = null,
-    @SerialName("refresh_token_expires_in") val refreshTokenExpiresIn: Long? = null
+    @SerialName("refresh_token_expires_in") val refreshTokenExpiresIn: Long? = null,
+    @SerialName("saved_at") val savedAtEpochMillis: Long? = null
 )
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
@@ -14,11 +14,13 @@ import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import zed.rainxch.core.data.data_source.TokenStore
 import zed.rainxch.core.domain.model.ProxyConfig
+import zed.rainxch.core.domain.repository.AuthenticationState
 import zed.rainxch.core.domain.repository.RateLimitRepository
 
 class GitHubClientProvider(
     private val tokenStore: TokenStore,
     private val rateLimitRepository: RateLimitRepository,
+    private val authenticationState: AuthenticationState,
     proxyConfigFlow: StateFlow<ProxyConfig>
 ) {
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
@@ -28,6 +30,8 @@ class GitHubClientProvider(
     private var currentClient: HttpClient = createGitHubHttpClient(
         tokenStore = tokenStore,
         rateLimitRepository = rateLimitRepository,
+        authenticationState = authenticationState,
+        scope = scope,
         proxyConfig = proxyConfigFlow.value
     )
 
@@ -41,6 +45,8 @@ class GitHubClientProvider(
                     currentClient = createGitHubHttpClient(
                         tokenStore = tokenStore,
                         rateLimitRepository = rateLimitRepository,
+                        authenticationState = authenticationState,
+                        scope = scope,
                         proxyConfig = proxyConfig
                     )
                 }
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/HttpClientFactory.kt
@@ -11,10 +11,13 @@ import io.ktor.serialization.kotlinx.json.*
 import io.ktor.util.network.UnresolvedAddressException
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.json.Json
+import kotlinx.coroutines.CoroutineScope
 import zed.rainxch.core.data.data_source.TokenStore
 import zed.rainxch.core.data.network.interceptor.RateLimitInterceptor
+import zed.rainxch.core.data.network.interceptor.UnauthorizedInterceptor
 import zed.rainxch.core.domain.model.ProxyConfig
 import zed.rainxch.core.domain.model.RateLimitException
+import zed.rainxch.core.domain.repository.AuthenticationState
 import zed.rainxch.core.domain.repository.RateLimitRepository
 import java.io.IOException
 import kotlin.coroutines.cancellation.CancellationException
@@ -24,6 +27,8 @@ expect fun createPlatformHttpClient(proxyConfig: ProxyConfig): HttpClient
 fun createGitHubHttpClient(
     tokenStore: TokenStore,
     rateLimitRepository: RateLimitRepository,
+    authenticationState: AuthenticationState? = null,
+    scope: CoroutineScope? = null,
     proxyConfig: ProxyConfig = ProxyConfig.None
 ): HttpClient {
     val json = Json {
@@ -36,6 +41,13 @@ fun createGitHubHttpClient(
             this.rateLimitRepository = rateLimitRepository
         }
 
+        if (authenticationState != null && scope != null) {
+            install(UnauthorizedInterceptor) {
+                this.authenticationState = authenticationState
+                this.scope = scope
+            }
+        }
+
         install(ContentNegotiation) {
             json(json)
         }
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/interceptor/UnauthorizedInterceptor.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/network/interceptor/UnauthorizedInterceptor.kt
@@ -0,0 +1,48 @@
+package zed.rainxch.core.data.network.interceptor
+
+import io.ktor.client.HttpClient
+import io.ktor.client.plugins.HttpClientPlugin
+import io.ktor.client.statement.HttpReceivePipeline
+import io.ktor.util.AttributeKey
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import zed.rainxch.core.domain.repository.AuthenticationState
+
+class UnauthorizedInterceptor(
+    private val authenticationState: AuthenticationState,
+    private val scope: CoroutineScope
+) {
+
+    class Config {
+        var authenticationState: AuthenticationState? = null
+        var scope: CoroutineScope? = null
+    }
+
+    companion object Plugin : HttpClientPlugin<Config, UnauthorizedInterceptor> {
+        override val key: AttributeKey<UnauthorizedInterceptor> =
+            AttributeKey("UnauthorizedInterceptor")
+
+        override fun prepare(block: Config.() -> Unit): UnauthorizedInterceptor {
+            val config = Config().apply(block)
+            return UnauthorizedInterceptor(
+                authenticationState = requireNotNull(config.authenticationState) {
+                    "AuthenticationState must be provided"
+                },
+                scope = requireNotNull(config.scope) {
+                    "CoroutineScope must be provided"
+                }
+            )
+        }
+
+        override fun install(plugin: UnauthorizedInterceptor, scope: HttpClient) {
+            scope.receivePipeline.intercept(HttpReceivePipeline.After) {
+                if (subject.status.value == 401) {
+                    plugin.scope.launch {
+                        plugin.authenticationState.notifySessionExpired()
+                    }
+                }
+                proceedWith(subject)
+            }
+        }
+    }
+}
diff --git a/core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/AuthenticationStateImpl.kt b/core/data/src/commonMain/kotlin/zed/rainxch/core/data/repository/AuthenticationStateImpl.kt
@@ -1,13 +1,20 @@
 package zed.rainxch.core.data.repository
 
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.map
 import zed.rainxch.core.data.data_source.TokenStore
 import zed.rainxch.core.domain.repository.AuthenticationState
 
 class AuthenticationStateImpl (
     private val tokenStore: TokenStore,
 ) : AuthenticationState {
+
+    private val _sessionExpiredEvent = MutableSharedFlow<Unit>(extraBufferCapacity = 1)
+    override val sessionExpiredEvent: SharedFlow<Unit> = _sessionExpiredEvent.asSharedFlow()
+
     override fun isUserLoggedIn(): Flow<Boolean> {
         return tokenStore
             .tokenFlow()
@@ -19,4 +26,9 @@ class AuthenticationStateImpl (
     override suspend fun isCurrentlyUserLoggedIn(): Boolean {
         return tokenStore.currentToken() != null
     }
+
+    override suspend fun notifySessionExpired() {
+        tokenStore.clear()
+        _sessionExpiredEvent.emit(Unit)
+    }
 }
diff --git a/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/repository/AuthenticationState.kt b/core/domain/src/commonMain/kotlin/zed/rainxch/core/domain/repository/AuthenticationState.kt
@@ -1,8 +1,11 @@
 package zed.rainxch.core.domain.repository
 
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.SharedFlow
 
 interface AuthenticationState {
     fun isUserLoggedIn() : Flow<Boolean>
     suspend fun isCurrentlyUserLoggedIn() : Boolean
+    val sessionExpiredEvent: SharedFlow<Unit>
+    suspend fun notifySessionExpired()
 }
diff --git a/core/presentation/src/commonMain/composeResources/values/strings.xml b/core/presentation/src/commonMain/composeResources/values/strings.xml
diff --git a/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/AuthenticationAction.kt b/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/AuthenticationAction.kt
diff --git a/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/AuthenticationRoot.kt b/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/AuthenticationRoot.kt
diff --git a/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/AuthenticationViewModel.kt b/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/AuthenticationViewModel.kt
diff --git a/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/model/AuthLoginState.kt b/feature/auth/presentation/src/commonMain/kotlin/zed/rainxch/auth/presentation/model/AuthLoginState.kt
diff --git a/feature/profile/data/src/commonMain/kotlin/zed/rainxch/profile/data/repository/ProfileRepositoryImpl.kt b/feature/profile/data/src/commonMain/kotlin/zed/rainxch/profile/data/repository/ProfileRepositoryImpl.kt
diff --git a/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/components/LogoutDialog.kt b/feature/profile/presentation/src/commonMain/kotlin/zed/rainxch/profile/presentation/components/LogoutDialog.kt

Original file line number	Diff line number	Diff line change
`@@ -2,4 +2,5 @@ package zed.rainxch.githubstore`
`2`	`2`
`3`	`3`	`sealed interface MainAction {`
`4`	`4`	`data object DismissRateLimitDialog : MainAction`
	`5`	`+ data object DismissSessionExpiredDialog : MainAction`
`5`	`6`	`}`
Original file line number	Diff line number	Diff line change
`@@ -89,6 +89,12 @@ class MainViewModel(`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`
	`92`	`+ viewModelScope.launch {`
	`93`	`+ authenticationState.sessionExpiredEvent.collect {`
	`94`	`+ _state.update { it.copy(showSessionExpiredDialog = true) }`
	`95`	`+ }`
	`96`	`+ }`
	`97`	`+`
`92`	`98`	`viewModelScope.launch(Dispatchers.IO) {`
`93`	`99`	`syncUseCase().onSuccess {`
`94`	`100`	`installedAppsRepository.checkAllForUpdates()`
`@@ -101,6 +107,9 @@ class MainViewModel(`
`101`	`107`	`MainAction.DismissRateLimitDialog -> {`
`102`	`108`	`_state.update { it.copy(showRateLimitDialog = false) }`
`103`	`109`	`}`
	`110`	`+ MainAction.DismissSessionExpiredDialog -> {`
	`111`	`+ _state.update { it.copy(showSessionExpiredDialog = false) }`
	`112`	`+ }`
`104`	`113`	`}`
`105`	`114`	`}`
`106`	`115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,4 +9,5 @@ interface TokenStore {`
`9`	`9`	`fun blockingCurrentToken() : GithubDeviceTokenSuccessDto?`
`10`	`10`	`suspend fun save(token: GithubDeviceTokenSuccessDto)`
`11`	`11`	`suspend fun clear()`
	`12`	`+ suspend fun isTokenExpired(): Boolean`
`12`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -143,14 +143,17 @@ val networkModule = module {`
`143`	`143`	`GitHubClientProvider(`
`144`	`144`	`tokenStore = get(),`
`145`	`145`	`rateLimitRepository = get(),`
	`146`	`+ authenticationState = get(),`
`146`	`147`	`proxyConfigFlow = ProxyManager.currentProxyConfig`
`147`	`148`	`)`
`148`	`149`	`}`
`149`	`150`
`150`	`151`	`single<HttpClient> {`
`151`	`152`	`createGitHubHttpClient(`
`152`	`153`	`tokenStore = get(),`
`153`		`- rateLimitRepository = get()`
	`154`	`+ rateLimitRepository = get(),`
	`155`	`+ authenticationState = get(),`
	`156`	`+ scope = get()`
`154`	`157`	`)`
`155`	`158`	`}`
`156`	`159`
Original file line number	Diff line number	Diff line change
`@@ -10,5 +10,6 @@ data class GithubDeviceTokenSuccessDto(`
`10`	`10`	`@SerialName("expires_in") val expiresIn: Long? = null,`
`11`	`11`	`@SerialName("scope") val scope: String? = null,`
`12`	`12`	`@SerialName("refresh_token") val refreshToken: String? = null,`
`13`		`- @SerialName("refresh_token_expires_in") val refreshTokenExpiresIn: Long? = null`
	`13`	`+ @SerialName("refresh_token_expires_in") val refreshTokenExpiresIn: Long? = null,`
	`14`	`+ @SerialName("saved_at") val savedAtEpochMillis: Long? = null`
`14`	`15`	`)`