impl: setup auth manager with auth and token endpoints

Toolbox API comes with a basic oauth2 client. This commit
sets-up details about two important oauth flows:

- authorization flow, in which the user is sent to web page
  where an authorization code is generated which is exchanged
  for an access token.
- details about token refresh endpoint where users can obtain
  a new access token and a new refresh token.

A couple of important aspects:
- the client app id is resolved in upstream
- as well as the actual endpoints for authorization and token refresh
- S256 is the only code challenge supported

Author: fioan89

src/main/kotlin/com/coder/toolbox/oauth/AuthorizationServer.kt

@@ -0,0 +1,22 @@
+package com.coder.toolbox.oauth
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+data class AuthorizationServer(
+    @field:Json(name = "authorization_endpoint") val authorizationEndpoint: String,
+    @field:Json(name = "token_endpoint") val tokenEndpoint: String,
+    @property:Json(name = "token_endpoint_auth_methods_supported") val authMethodForTokenEndpoint: List<TokenEndpointAuthMethod>,
+)
+
+enum class TokenEndpointAuthMethod {
+    @Json(name = "none")
+    NONE,
+
+    @Json(name = "client_secret_post")
+    CLIENT_SECRET_POST,
+
+    @Json(name = "client_secret_basic")
+    CLIENT_SECRET_BASIC,
+}

src/main/kotlin/com/coder/toolbox/oauth/CoderAccount.kt

@@ -0,0 +1,5 @@
+package com.coder.toolbox.oauth
+
+import com.jetbrains.toolbox.api.core.auth.Account
+
+data class CoderAccount(override val id: String, override val fullName: String) : Account

src/main/kotlin/com/coder/toolbox/oauth/CoderOAuthManager.kt

@@ -0,0 +1,60 @@
+package com.coder.toolbox.oauth
+
+import com.coder.toolbox.util.toBaseURL
+import com.jetbrains.toolbox.api.core.auth.AuthConfiguration
+import com.jetbrains.toolbox.api.core.auth.ContentType
+import com.jetbrains.toolbox.api.core.auth.ContentType.FORM_URL_ENCODED
+import com.jetbrains.toolbox.api.core.auth.OAuthToken
+import com.jetbrains.toolbox.api.core.auth.PluginAuthInterface
+import com.jetbrains.toolbox.api.core.auth.RefreshConfiguration
+
+class CoderOAuthManager(
+    private val clientId: String,
+    private val authServer: AuthorizationServer
+) : PluginAuthInterface<CoderAccount, CoderLoginCfg> {
+    override fun serialize(account: CoderAccount): String = "${account.id}|${account.fullName}"
+
+    override fun deserialize(string: String): CoderAccount = CoderAccount(
+        string.split('|')[0],
+        string.split('|')[1]
+    )
+
+    override suspend fun createAccount(
+        token: OAuthToken,
+        config: AuthConfiguration
+    ): CoderAccount {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun updateAccount(
+        token: OAuthToken,
+        account: CoderAccount
+    ): CoderAccount {
+        TODO("Not yet implemented")
+    }
+
+    override fun createAuthConfig(loginConfiguration: CoderLoginCfg): AuthConfiguration = AuthConfiguration(
+        authParams = mapOf("response_type" to "code", "client_id" to clientId),
+        tokenParams = mapOf("grant_type" to "authorization_code", "client_id" to clientId),
+        baseUrl = authServer.authorizationEndpoint.toBaseURL().toString(),
+        authUrl = authServer.authorizationEndpoint,
+        tokenUrl = authServer.tokenEndpoint,
+        codeChallengeParamName = "code_challenge",
+        codeChallengeMethod = "S256",
+        verifierParamName = "code_verifier",
+        authorization = null
+    )
+
+
+    override fun createRefreshConfig(account: CoderAccount): RefreshConfiguration {
+        return object : RefreshConfiguration {
+            override val refreshUrl: String = authServer.tokenEndpoint
+            override val parameters: Map<String, String> =
+                mapOf("grant_type" to "refresh_token", "client_id" to clientId)
+            override val authorization: String? = null
+            override val contentType: ContentType = FORM_URL_ENCODED
+        }
+    }
+}
+
+object CoderLoginCfg

src/main/kotlin/com/coder/toolbox/util/URLExtensions.kt

@@ -8,6 +8,12 @@ import java.net.URL
 
 fun String.toURL(): URL = URI.create(this).toURL()
 
+fun String.toBaseURL(): URL {
+    val url = this.toURL()
+    val port = if (url.port != -1) ":${url.port}" else ""
+    return URI.create("${url.protocol}://${url.host}$port").toURL()
+}
+
 fun String.validateStrictWebUrl(): WebUrlValidationResult = try {
     val uri = URI(this)
 
@@ -21,15 +27,18 @@ fun String.validateStrictWebUrl(): WebUrlValidationResult = try {
             "The URL \"$this\" is missing a scheme (like https://). " +
                     "Please enter a full web address like \"https://example.com\""
         )
+
         uri.scheme?.lowercase() !in setOf("http", "https") ->
             Invalid(
                 "The URL \"$this\" must start with http:// or https://, not \"${uri.scheme}\""
             )
+
         uri.authority.isNullOrBlank() ->
             Invalid(
                 "The URL \"$this\" does not include a valid website name. " +
                         "Please enter a full web address like \"https://example.com\""
             )
+
         else -> Valid
     }
 } catch (_: Exception) {

src/test/kotlin/com/coder/toolbox/util/URLExtensionsTest.kt

@@ -4,6 +4,7 @@ import java.net.URI
 import java.net.URL
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 
 internal class URLExtensionsTest {
     @Test
@@ -152,4 +153,37 @@ internal class URLExtensionsTest {
             result
         )
     }
+
+    @Test
+    fun `returns base URL without path or query`() {
+        val fullUrl = "https://example.com/path/to/page?param=1"
+        val result = fullUrl.toBaseURL()
+        assertEquals(URL("https://example.com"), result)
+    }
+
+    @Test
+    fun `includes port if specified`() {
+        val fullUrl = "https://example.com:8080/api/v1/resource"
+        val result = fullUrl.toBaseURL()
+        assertEquals(URL("https://example.com:8080"), result)
+    }
+
+    @Test
+    fun `handles subdomains correctly`() {
+        val fullUrl = "http://api.subdomain.example.org/v2/users"
+        val result = fullUrl.toBaseURL()
+        assertEquals(URL("http://api.subdomain.example.org"), result)
+    }
+
+    @Test
+    fun `handles simple domain without path`() {
+        val fullUrl = "https://test.com"
+        val result = fullUrl.toBaseURL()
+        assertEquals(URL("https://test.com"), result)
+    }
+
+    @Test
+    fun `throws exception for invalid URL`() {
+        assertFailsWith<IllegalArgumentException> { "ht!tp://bad_url".toBaseURL() }
+    }
 }