feat: Store auth tokens on disk

darkfeed/src/main/kotlin/Main.kt

···
 import rs.averyrive.darkfeed.server.FeedServer
 import java.time.Instant
 import java.time.format.DateTimeFormatter
+import kotlin.io.path.Path
 
 val PACKAGE_NAME: String = object {}.javaClass.packageName
 
···
             by option(help = "Description to use for the feed", envvar = "FEED_DESCRIPTION")
                 .default("Development version of the NSFW Likes feed. Likely will not work.")
 
+    private val storageDir: String
+            by option(help = "Directory to store data in", envvar = "STORAGE_DIR")
+                .default("/var/lib/darkfeed")
+
     private val debug: Boolean
             by option(help = "Log debug information")
                 .flag(default = false)
···
             log.warn("Authorized requests (e.g. updating feed generator record) will not be available")
         }
 
+        // Create auth manager if the owner's account was found.
+        val authManager = authAccount?.let {
+            AuthManager(
+                authAccount = authAccount,
+                tokensPath = Path(storageDir, "auth_tokens.json")
+            )
+        }
+
         // Create the client used for Bluesky API calls.
         val bskyApi = BskyApi(
-            authManager = authAccount?.let { AuthManager(it) },
+            authManager = authManager,
             atpIdentityClient = atpIdentityClient,
         )
 

darkfeed/src/main/kotlin/api/AuthManager.kt

···
 import io.ktor.http.*
 import io.ktor.serialization.kotlinx.json.*
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.SerializationException
+import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
 import org.slf4j.Logger
 import org.slf4j.LoggerFactory
+import java.nio.file.Path
 
 /**
  * Stores auth tokens and handles all auth related requests.
  *
  * @param authAccount ATProto account to use for authorization.
  * @param httpClient Client to use for requests.
+ * @param tokensPath Path to store tokens in.
  */
 class AuthManager(
     private val authAccount: AuthAccount,
···
 
         install(Logging)
     },
+    private val tokensPath: Path,
 ) {
+    /** Logger to use for this class. */
+    private val log: Logger = LoggerFactory.getLogger(this.javaClass)
+
+    init {
+        loadTokens()
+    }
+
     /** The current bearer tokens. */
     var authTokens: AuthTokens? = null
         private set
···
     val authAccountDid
         get() = authAccount.username
 
-    /** Logger to use for this class. */
-    private val log: Logger = LoggerFactory.getLogger(this.javaClass)
 
     /** Create a new auth session. */
     suspend fun createSession() {
···
                     val authSession: AuthSession = response.body()
                     this.authTokens = authSession.into()
                     log.debug("New session created, updated auth tokens.")
+                    this.saveTokens()
                 } catch (error: Exception) {
                     TODO("Handle deserialization errors")
                 }
···
     /** Refresh the current auth session. */
     suspend fun refreshSession() {
         val refreshSessionUrl = buildUrl {
-            protocol = URLProtocol.HTTPS
-            host = [e-mail]
-            path("/xrpc/com.atproto.server.refreshSession")
+            takeFrom([e-mail])
+            appendPathSegments("xrpc", "com.atproto.server.refreshSession")
         }
 
         val refreshToken = this.authTokens?.refreshToken!!
···
                     val authSession: AuthSession = response.body()
                     this.authTokens = authSession.into()
                     log.debug("Session refreshed, updated auth tokens")
+                    this.saveTokens()
                 } catch (error: Exception) {
                     TODO("Handle deserialization errors")
                 }
···
             }
         }
     }
+
+    /**
+     * Load tokens from disk.
+     */
+    private fun loadTokens() {
+        log.debug("Loading auth tokens from '{}'...", tokensPath)
+
+        val tokensFile = tokensPath.toFile()
+
+        // Do nothing if tokens file doesn't exist.
+        if (!tokensFile.isFile) {
+            log.debug("No tokens found at '{}'", tokensPath)
+            return
+        }
+
+        // Load auth tokens from file.
+        val authTokens = try {
+            Json.decodeFromString<AuthTokens>(tokensFile.readText())
+        } catch (error: SerializationException) {
+            log.warn("Failed to load auth tokens from '{}': {}", tokensPath, error.message)
+            return
+        }
+
+        // Don't use tokens if they are for a different account.
+        if (this.authAccountDid != authTokens.did) {
+            log.info("Refusing to use stored auth tokens for '{}'", authTokens.did)
+            return
+        }
+
+        // Update auth tokens.
+        this.authTokens = authTokens
+
+        log.debug("Loaded tokens")
+    }
+
+    /**
+     * Save tokens to disk.
+     */
+    private fun saveTokens() {
+        log.debug("Saving auth tokens to '{}'...", tokensPath)
+
+        // Open file and create parent directory if necessary.
+        val tokensFile = tokensPath.toFile()
+        tokensFile.parentFile?.mkdirs()
+
+        // Serialize auth tokens and write to the tokens file.
+        val tokensData = Json.encodeToString(authTokens)
+        tokensFile.bufferedWriter().use { writer ->
+            writer.write(tokensData)
+        }
+
+        log.debug("Saved tokens")
+    }
 }
 
 /**
···
  * @param accessToken Token used for normal authorized requests.
  * @param refreshToken Token used for session refresh requests.
  */
+@Serializable
 data class AuthTokens(
     val accessToken: String,
     val refreshToken: String,
+    val did: String,
 )
 
 /**
···
 @Serializable
 data class AuthSession(
     val accessJwt: String,
-    val refreshJwt: String
+    val refreshJwt: String,
+    val did: String,
 ) {
     /** Create `AuthTokens` from an `AuthSession`. */
-    fun into(): AuthTokens = AuthTokens(this.accessJwt, this.refreshJwt)
+    fun into(): AuthTokens = AuthTokens(this.accessJwt, this.refreshJwt, this.did)
 }

darkfeed/src/main/kotlin/api/AuthPlugin.kt

···
 import org.slf4j.LoggerFactory
 
 const val PLUGIN_NAME: String = "AuthPlugin"
+val LOGGER_NAME: String = "${object {}.javaClass.packageName}.$PLUGIN_NAME"
 
 val AuthPlugin = createClientPlugin(PLUGIN_NAME, ::AuthPluginConfig) {
     val authManager = pluginConfig.authManager ?: throw AuthPluginConfigurationError("Auth manager is required")
     val authMutex = Mutex()
-    val log = LoggerFactory.getLogger(PLUGIN_NAME)
+    val log = LoggerFactory.getLogger(LOGGER_NAME)
 
     // Add authorization header to requests.
     onRequest { request, _ ->