feat: Migrate Android app to generated Kotlin SDK (#5)

Replace 52 manual data classes and 74 hand-written Retrofit endpoints
with the generated Kotlin SDK from the OpenAPI spec. The SDK is included
as a local Gradle module under sdk/.

- Delete Models.kt (1051 lines) and ArtifactKeeperApi.kt (405 lines)
- Add TypeAliases.kt bridging old model names to SDK types
- Add LocalModels.kt for staging-specific types not in SDK
- Add StagingApi.kt for staging endpoints not covered by SDK
- Refactor ApiClient.kt to expose typed SDK API services
- Update all 30+ screens and ViewModels to use SDK types
- Update formatRelativeTime to handle OffsetDateTime from SDK

Closes #4

Author: brandonrc

.gitignore

@@ -12,3 +12,4 @@ local.properties
 # Release signing
 *.jks
 *.keystore
+app/build/

app/build.gradle.kts

@@ -63,10 +63,12 @@ dependencies {
     implementation("androidx.activity:activity-compose:1.9.3")
     implementation("androidx.navigation:navigation-compose:2.8.5")
 
+    // SDK
+    implementation(project(":sdk"))
+
     // Networking
     implementation("com.squareup.retrofit2:retrofit:2.11.0")
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
-    implementation("com.jakewharton.retrofit:retrofit2-kotlinx-serialization-converter:1.0.0")
     implementation("com.squareup.okhttp3:okhttp:4.12.0")
     implementation("com.squareup.okhttp3:logging-interceptor:4.12.0")
 

app/src/main/java/com/artifactkeeper/android/data/api/ApiClient.kt

@@ -1,41 +1,77 @@
 package com.artifactkeeper.android.data.api
 
 import com.artifactkeeper.android.BuildConfig
-import com.jakewharton.retrofit2.converter.kotlinx.serialization.asConverterFactory
-import kotlinx.serialization.json.Json
-import okhttp3.MediaType.Companion.toMediaType
+import com.artifactkeeper.client.apis.AdminApi
+import com.artifactkeeper.client.apis.AnalyticsApi
+import com.artifactkeeper.client.apis.AuthApi
+import com.artifactkeeper.client.apis.BuildsApi
+import com.artifactkeeper.client.apis.GroupsApi
+import com.artifactkeeper.client.apis.HealthApi
+import com.artifactkeeper.client.apis.MonitoringApi
+import com.artifactkeeper.client.apis.PackagesApi
+import com.artifactkeeper.client.apis.PeersApi
+import com.artifactkeeper.client.apis.PromotionApi
+import com.artifactkeeper.client.apis.RepositoriesApi
+import com.artifactkeeper.client.apis.SbomApi
+import com.artifactkeeper.client.apis.SecurityApi
+import com.artifactkeeper.client.apis.SsoApi
+import com.artifactkeeper.client.apis.UsersApi
+import com.artifactkeeper.client.apis.WebhooksApi
+import com.artifactkeeper.client.infrastructure.ApiClient as SdkApiClient
 import okhttp3.OkHttpClient
 import okhttp3.logging.HttpLoggingInterceptor
-import retrofit2.Retrofit
+import retrofit2.Response
 import java.security.SecureRandom
 import java.security.cert.X509Certificate
 import javax.net.ssl.SSLContext
 import javax.net.ssl.TrustManager
 import javax.net.ssl.X509TrustManager
 
+/**
+ * Unwrap a Retrofit [Response], returning the body on success
+ * or throwing an exception with the error body on failure.
+ */
+suspend fun <T> Response<T>.unwrap(): T {
+    if (isSuccessful) return body()!!
+    throw Exception(errorBody()?.string() ?: "HTTP ${code()}")
+}
+
 object ApiClient {
-    private val json = Json {
-        ignoreUnknownKeys = true
-        encodeDefaults = true
-    }
     private var _baseUrl = ""
     private var _token: String? = null
+    private var sdkClient: SdkApiClient? = null
 
     val isConfigured: Boolean get() = _baseUrl.isNotBlank()
+    val baseUrl: String get() = _baseUrl
+    val token: String? get() = _token
+
+    // --- Typed API services ---
+    lateinit var authApi: AuthApi private set
+    lateinit var reposApi: RepositoriesApi private set
+    lateinit var packagesApi: PackagesApi private set
+    lateinit var buildsApi: BuildsApi private set
+    lateinit var securityApi: SecurityApi private set
+    lateinit var adminApi: AdminApi private set
+    lateinit var usersApi: UsersApi private set
+    lateinit var groupsApi: GroupsApi private set
+    lateinit var peersApi: PeersApi private set
+    lateinit var webhooksApi: WebhooksApi private set
+    lateinit var analyticsApi: AnalyticsApi private set
+    lateinit var monitoringApi: MonitoringApi private set
+    lateinit var healthApi: HealthApi private set
+    lateinit var sbomApi: SbomApi private set
+    lateinit var ssoApi: SsoApi private set
+    lateinit var promotionApi: PromotionApi private set
+    lateinit var stagingApi: StagingApi private set
 
-    private fun buildClient(): OkHttpClient {
+    // Keep a raw OkHttpClient for cases that need direct HTTP access
+    val httpClient: OkHttpClient get() = buildOkHttpClientBuilder().build()
+
+    private fun buildOkHttpClientBuilder(): OkHttpClient.Builder {
         val builder = OkHttpClient.Builder()
             .addInterceptor(HttpLoggingInterceptor().apply {
                 level = HttpLoggingInterceptor.Level.BODY
             })
-            .addInterceptor { chain ->
-                val request = _token?.let {
-                    chain.request().newBuilder()
-                        .addHeader("Authorization", "Bearer $it")
-                        .build()
-                } ?: chain.request()
-                chain.proceed(request)
-            }
 
         if (BuildConfig.DEBUG) {
             val trustAllManager = object : X509TrustManager {
@@ -49,42 +85,66 @@ object ApiClient {
             builder.hostnameVerifier { _, _ -> true }
         }
 
-        return builder.build()
+        return builder
     }
 
-    private fun buildRetrofit(): Retrofit {
+    private fun rebuildServices() {
         val url = _baseUrl.ifBlank { "http://localhost/" }
-        return Retrofit.Builder()
-            .baseUrl(url)
-            .client(buildClient())
-            .addConverterFactory(json.asConverterFactory("application/json".toMediaType()))
-            .build()
-    }
-
-    var api: ArtifactKeeperApi = buildRetrofit().create(ArtifactKeeperApi::class.java)
-        private set
+        val okBuilder = buildOkHttpClientBuilder()
 
-    val httpClient: OkHttpClient get() = buildClient()
+        val client = if (_token != null) {
+            SdkApiClient(
+                baseUrl = url,
+                okHttpClientBuilder = okBuilder,
+                authName = "bearer_auth",
+                bearerToken = _token!!
+            )
+        } else {
+            SdkApiClient(
+                baseUrl = url,
+                okHttpClientBuilder = okBuilder,
+                authNames = arrayOf("bearer_auth")
+            )
+        }
+        sdkClient = client
 
-    val baseUrl: String get() = _baseUrl
+        authApi = client.createService(AuthApi::class.java)
+        reposApi = client.createService(RepositoriesApi::class.java)
+        packagesApi = client.createService(PackagesApi::class.java)
+        buildsApi = client.createService(BuildsApi::class.java)
+        securityApi = client.createService(SecurityApi::class.java)
+        adminApi = client.createService(AdminApi::class.java)
+        usersApi = client.createService(UsersApi::class.java)
+        groupsApi = client.createService(GroupsApi::class.java)
+        peersApi = client.createService(PeersApi::class.java)
+        webhooksApi = client.createService(WebhooksApi::class.java)
+        analyticsApi = client.createService(AnalyticsApi::class.java)
+        monitoringApi = client.createService(MonitoringApi::class.java)
+        healthApi = client.createService(HealthApi::class.java)
+        sbomApi = client.createService(SbomApi::class.java)
+        ssoApi = client.createService(SsoApi::class.java)
+        promotionApi = client.createService(PromotionApi::class.java)
+        stagingApi = client.createService(StagingApi::class.java)
+    }
 
-    val token: String? get() = _token
+    init {
+        rebuildServices()
+    }
 
     fun configure(baseUrl: String, token: String? = null) {
         _baseUrl = if (baseUrl.endsWith("/")) baseUrl else "$baseUrl/"
         _token = token
-        api = buildRetrofit().create(ArtifactKeeperApi::class.java)
+        rebuildServices()
     }
 
     fun clearConfig() {
         _baseUrl = ""
         _token = null
-        api = buildRetrofit().create(ArtifactKeeperApi::class.java)
+        rebuildServices()
     }
 
     fun setToken(token: String?) {
         _token = token
-        api = buildRetrofit().create(ArtifactKeeperApi::class.java)
+        rebuildServices()
     }
-
 }