Phase 3: resumable multi-source downloader (HF, Ollama, direct URL)

app/src/main/java/io/github/abrarul/modularai/model/ModelDownloader.kt

@@ -0,0 +1,98 @@
+package io.github.abrarul.modularai.model
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+import java.io.File
+import java.io.RandomAccessFile
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+
+sealed class Source {
+    data class HuggingFace(val repo: String, val file: String, val rev: String = "main") : Source()
+    data class Ollama(val name: String, val tag: String = "latest") : Source()
+    data class Url(val url: String) : Source()
+}
+
+class ModelDownloader(private val modelsDir: File) {
+
+    init { modelsDir.mkdirs() }
+
+    suspend fun download(
+        src: Source,
+        sha256: String? = null,
+        onProgress: (done: Long, total: Long) -> Unit = { _, _ -> }
+    ): File = withContext(Dispatchers.IO) {
+        val (url, fileName, digest) = resolve(src)
+        val out = File(modelsDir, fileName)
+        val part = File(modelsDir, "$fileName.part")
+        var have = if (part.exists()) part.length() else 0L
+
+        val c = URL(url).openConnection() as HttpURLConnection
+        c.instanceFollowRedirects = true
+        if (have > 0) c.setRequestProperty("Range", "bytes=$have-")
+        c.connect()
+        val resumed = c.responseCode == 206
+        if (!resumed) have = 0L
+        val total = have + c.contentLengthLong
+
+        RandomAccessFile(part, "rw").use { raf ->
+            if (resumed) raf.seek(have) else raf.setLength(0)
+            c.inputStream.use { inp ->
+                val buf = ByteArray(256 * 1024)
+                while (true) {
+                    val n = inp.read(buf)
+                    if (n < 0) break
+                    raf.write(buf, 0, n)
+                    have += n
+                    onProgress(have, total)
+                }
+            }
+        }
+
+        val expected = sha256 ?: digest
+        if (expected != null) {
+            val actual = sha256Of(part)
+            if (!actual.equals(expected.removePrefix("sha256:"), ignoreCase = true)) {
+                part.delete()
+                error("Checksum mismatch for $fileName")
+            }
+        }
+        if (out.exists()) out.delete()
+        part.renameTo(out)
+        out
+    }
+
+    private fun resolve(src: Source): Triple<String, String, String?> = when (src) {
+        is Source.HuggingFace ->
+            Triple("https://huggingface.co/${src.repo}/resolve/${src.rev}/${src.file}", src.file.substringAfterLast('/'), null)
+        is Source.Url ->
+            Triple(src.url, src.url.substringAfterLast('/').substringBefore('?').ifBlank { "model.gguf" }, null)
+        is Source.Ollama -> {
+            val base = "https://registry.ollama.ai/v2/library/${src.name}"
+            val m = JSONObject(URL("$base/manifests/${src.tag}").readText())
+            val layers = m.getJSONArray("layers")
+            var digest = ""
+            for (i in 0 until layers.length()) {
+                val l = layers.getJSONObject(i)
+                if (l.getString("mediaType") == "application/vnd.ollama.image.model") digest = l.getString("digest")
+            }
+            require(digest.isNotEmpty()) { "No model layer in Ollama manifest" }
+            Triple("$base/blobs/$digest", "${src.name}-${src.tag}.gguf", digest)
+        }
+    }
+
+    fun list(): List<File> = modelsDir.listFiles { f -> f.extension in setOf("gguf", "onnx") }?.toList() ?: emptyList()
+    fun remove(f: File) = f.delete()
+    fun wipeAll() = modelsDir.listFiles()?.forEach { it.delete() }
+
+    private fun sha256Of(f: File): String {
+        val md = MessageDigest.getInstance("SHA-256")
+        f.inputStream().use { i ->
+            val b = ByteArray(1 shl 20)
+            while (true) { val n = i.read(b); if (n < 0) break; md.update(b, 0, n) }
+        }
+        return md.digest().joinToString("") { "%02x".format(it) }
+    }
+}