WIP: Add JVM target for build testing (incomplete)

Added JVM target alongside native to enable build testing in sandbox environment.
Created expect/actual pattern for platform-specific code (file I/O, process execution, crypto).

Current issues with source files having corruption from file copies. Need to properly
restructure source files for multiplatform setup.

Alternative approach needed - either:
1. Use JVM-only build temporarily for testing
2. Create proper multiplatform structure from scratch
3. Use Docker-based build that has internet access for native toolchain

Co-authored-by: alexandru <[email protected]>

Author: Copilot

build.gradle.kts

@@ -15,7 +15,16 @@ repositories {
 }
 
 kotlin {
-    // Configure native targets for Linux
+    // JVM target for testing and development
+    jvm {
+        compilations.all {
+            compilerOptions.configure {
+                jvmTarget.set(org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_21)
+            }
+        }
+    }
+    
+    // Native target for production
     linuxX64("native") {
         binaries {
             executable {
@@ -32,7 +41,7 @@ kotlin {
     }
 
     sourceSets {
-        val nativeMain by getting {
+        val commonMain by getting {
             dependencies {
                 // Arrow libraries with native support
                 implementation(libs.arrow.core)
@@ -56,19 +65,32 @@ kotlin {
                 // Coroutines
                 implementation(libs.kotlinx.coroutines.core)
 
-                // Crypto for HMAC
-                implementation(libs.kcrypto)
-                
                 // Logging - using kotlin-logging with native support
                 implementation(libs.kotlin.logging)
             }
         }
+        
+        val jvmMain by getting {
+        }
 
-        val nativeTest by getting {
+        val nativeMain by getting {
+            dependencies {
+                // KCrypto only for native (not available in Maven Central, need to add repository)
+                implementation("com.soywiz:krypto:6.0.1")
+            }
+        }
+
+        val commonTest by getting {
             dependencies {
                 implementation(libs.kotlin.test)
             }
         }
+        
+        val jvmTest by getting {
+        }
+
+        val nativeTest by getting {
+        }
     }
 }
 

settings.gradle.kts

@@ -76,8 +76,8 @@ dependencyResolutionManagement {
                 .versionRef("kotlinLogging")
 
             // Crypto for HMAC (native support)
-            version("kcrypto", "5.4.0")
-            library("kcrypto", "com.soywiz.korlibs.krypto", "krypto")
+            version("kcrypto", "6.0.1")
+            library("kcrypto", "com.soywiz.krypto", "krypto")
                 .versionRef("kcrypto")
 
             // https://github.com/ajalt/clikt

…eMain/kotlin/org/alexn/hook/AppConfig.kt …nMain/kotlin/org/alexn/hook/AppConfig.ktsrc/nativeMain/kotlin/org/alexn/hook/AppConfig.kt renamed to src/commonMain/kotlin/org/alexn/hook/AppConfig.kt src/nativeMain/kotlin/org/alexn/hook/AppConfig.kt renamed to src/commonMain/kotlin/org/alexn/hook/AppConfig.kt

@@ -5,13 +5,8 @@ package org.alexn.hook
 import arrow.core.Either
 import com.charleskorn.kaml.Yaml
 import com.charleskorn.kaml.YamlConfiguration
-import kotlinx.cinterop.ExperimentalForeignApi
-import kotlinx.cinterop.toKString
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.Serializable
-import platform.posix.fclose
-import platform.posix.fgets
-import platform.posix.fopen
 import kotlin.time.Duration
 
 @Serializable
@@ -44,12 +39,11 @@ data class AppConfig(
     )
 
     companion object {
-        @OptIn(ExperimentalForeignApi::class)
         fun parseFile(filePath: String): Either<ConfigException, AppConfig> {
             val extension = filePath.substringAfterLast('.', "").lowercase()
 
             val content = try {
-                readFile(filePath)
+                readFileContent(filePath)
             } catch (ex: Exception) {
                 return Either.Left(
                     ConfigException(
@@ -94,23 +88,6 @@ data class AppConfig(
                         strictMode = false,
                     ),
             )
-
-        @OptIn(ExperimentalForeignApi::class)
-        private fun readFile(path: String): String {
-            val file = fopen(path, "r") ?: throw Exception("Cannot open file: $path")
-            try {
-                val content = StringBuilder()
-                val buffer = ByteArray(4096)
-                while (true) {
-                    val line = fgets(buffer.refTo(0), buffer.size, file)?.toKString()
-                    if (line == null) break
-                    content.append(line)
-                }
-                return content.toString()
-            } finally {
-                fclose(file)
-            }
-        }
     }
 }
 
@@ -122,3 +99,6 @@ class ConfigException(
     message: String,
     cause: Throwable? = null,
 ) : Exception(message, cause)
+
+// Platform-specific file reading
+expect fun readFileContent(path: String): String

…/kotlin/org/alexn/hook/CommandTrigger.kt …/kotlin/org/alexn/hook/CommandTrigger.ktsrc/nativeMain/kotlin/org/alexn/hook/CommandTrigger.kt renamed to src/commonMain/kotlin/org/alexn/hook/CommandTrigger.kt src/nativeMain/kotlin/org/alexn/hook/CommandTrigger.kt renamed to src/commonMain/kotlin/org/alexn/hook/CommandTrigger.kt

@@ -3,8 +3,6 @@ package org.alexn.hook
 import arrow.core.Either
 import arrow.core.left
 import arrow.core.right
-import com.soywiz.krypto.HMAC
-import com.soywiz.krypto.encoding.Hex
 import io.ktor.http.ContentType
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.Serializable
@@ -100,23 +98,6 @@ data class EventPayload(
                 RequestError.BadInput("Invalid form-urlencoded data", null).left()
             }
 
-        // HMAC using KCrypto library with native support
-        private fun hmacSha256(data: String, key: String): String {
-            val hmac = HMAC.hmacSHA256(
-                key.encodeToByteArray(),
-                data.encodeToByteArray()
-            )
-            return Hex.encode(hmac).lowercase()
-        }
-
-        private fun hmacSha1(data: String, key: String): String {
-            val hmac = HMAC.hmacSHA1(
-                key.encodeToByteArray(),
-                data.encodeToByteArray()
-            )
-            return Hex.encode(hmac).lowercase()
-        }
-
         // Simple URL decoding for native
         private fun urlDecode(str: String): String {
             return str.replace("+", " ")
@@ -260,68 +241,7 @@ sealed class RequestError(
 class RequestException(
     message: String,
     cause: Throwable?,
-) : java.lang.Exception(message, cause)
-
-sealed class RequestError(
-    val httpCode: Int,
-) {
-    abstract val message: String
-
-    fun toException(): Exception =
-        when (this) {
-            is BadInput ->
-                RequestException("$httpCode Bad Input — $message", exception)
-            is Forbidden ->
-                RequestException("$httpCode Forbidden — $message", null)
-            is Internal -> {
-                val metaStr = (meta ?: mapOf()).map { "\n  ${it.key}:${it.value}" }.joinToString("")
-                RequestException("$httpCode Internal Server Error — $message$metaStr", exception)
-            }
-            is NotFound ->
-                RequestException("$httpCode Not Found — $message", null)
-            is Skipped ->
-                RequestException("$httpCode Skipped — $message", null)
-            is TimedOut ->
-                RequestException("$httpCode Timed out — $message", null)
-            is UnsupportedMediaType ->
-                RequestException("$httpCode Unsupported Media Type — $message", null)
-        }
-
-    data class BadInput(
-        override val message: String,
-        val exception: Exception? = null,
-    ) : RequestError(400)
-
-    data class Forbidden(
-        override val message: String,
-    ) : RequestError(403)
-
-    data class Internal(
-        override val message: String,
-        val exception: Exception? = null,
-        val meta: Map<String, String>? = null,
-    ) : RequestError(
-            500,
-        )
-
-    data class NotFound(
-        override val message: String,
-    ) : RequestError(404)
 
-    data class Skipped(
-        override val message: String,
-    ) : RequestError(200)
-
-    data class TimedOut(
-        override val message: String,
-    ) : RequestError(408)
-
-    data class UnsupportedMediaType(
-        override val message: String,
-    ) : RequestError(415)
-}
-
-class RequestException(
-    message: String,
-    cause: Throwable?,
-) : Exception(message, cause)
+// Platform-specific HMAC implementations
+expect fun hmacSha256(data: String, key: String): String
+expect fun hmacSha1(data: String, key: String): String

…in/kotlin/org/alexn/hook/EventPayload.kt …in/kotlin/org/alexn/hook/EventPayload.ktsrc/nativeMain/kotlin/org/alexn/hook/EventPayload.kt renamed to src/commonMain/kotlin/org/alexn/hook/EventPayload.kt src/nativeMain/kotlin/org/alexn/hook/EventPayload.kt renamed to src/commonMain/kotlin/org/alexn/hook/EventPayload.kt

@@ -0,0 +1,41 @@
+package org.alexn.hook
+
+import arrow.core.Option
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.IO
+import kotlinx.coroutines.withContext
+
+data class CommandResult(
+    val exitCode: Int,
+    val stdout: String,
+    val stderr: String,
+) {
+    val isSuccessful get() = exitCode == 0
+}
+
+/**
+ * Executes shell commands.
+ */
+suspend fun executeRawShellCommand(
+    command: String,
+    dir: File? = null,
+): CommandResult =
+    withContext(Dispatchers.IO) {
+        executeCommand(command, dir)
+    }
+
+// File abstraction
+data class File(val path: String)
+
+val USER_HOME: File? by lazy {
+    Option
+        .fromNullable(getUserHomeDir())
+        .filter { it.isNotEmpty() }
+        .map { File(it) }
+        .getOrNull()
+}
+
+// Platform-specific implementations
+expect fun executeCommand(command: String, dir: File?): CommandResult
+expect fun getUserHomeDir(): String?
+

…nativeMain/kotlin/org/alexn/hook/Main.kt …commonMain/kotlin/org/alexn/hook/Main.ktsrc/nativeMain/kotlin/org/alexn/hook/Main.kt renamed to src/commonMain/kotlin/org/alexn/hook/Main.kt src/nativeMain/kotlin/org/alexn/hook/Main.kt renamed to src/commonMain/kotlin/org/alexn/hook/Main.kt

@@ -148,97 +148,4 @@ private fun urlEncode(str: String): String {
         .replace("@", "%40")
         .replace("[", "%5B")
         .replace("]", "%5D")
-}
-            configureRouting(appConfig, commandTrigger)
-        }
-    runInterruptible {
-        server.start(wait = true)
-    }
-}
-
-fun Application.configureRouting(
-    config: AppConfig,
-    commandTriggerService: CommandTrigger,
-) {
-    val logger: Logger by lazy {
-        LoggerFactory.getLogger("org.alexn.hook.Routing")
-    }
-    val basePath = config.http.basePath
-
-    routing {
-        if (config.http.basePath.isNotEmpty()) {
-            get(config.http.basePath) {
-                call.respondRedirect("$basePath/")
-            }
-        }
-
-        get("$basePath/") {
-            call.respondHtml(HttpStatusCode.OK) {
-                head {
-                    title { +"GitHub Webhook Listener" }
-                }
-                body {
-                    p { +"Configured hooks:" }
-                    ul {
-                        for (p in config.projects) {
-                            li { +URLEncoder.encode(p.key, UTF_8) }
-                        }
-                    }
-                }
-            }
-        }
-
-        post("$basePath/{project}") {
-            val projectKey = call.parameters["project"]
-            if (projectKey == null) {
-                call.respondText("Project key not specified", status = HttpStatusCode.BadRequest)
-                return@post
-            }
-
-            val response =
-                either {
-                    val project = config.projects[projectKey]
-                    ensureNotNull(project) {
-                        RequestError.NotFound("Project `$projectKey` does not exist")
-                    }
-
-                    val signature = call.request.header("X-Hub-Signature-256") ?: call.request.header("X-Hub-Signature")
-                    val body = call.receiveText()
-                    EventPayload
-                        .authenticateRequest(body, project.secret, signature)
-                        .bind()
-
-                    val parsed =
-                        EventPayload.parse(call.request.contentType(), body).bind()
-
-                    val result =
-                        if (parsed.shouldProcess(project)) {
-                            commandTriggerService.triggerCommand(projectKey)
-                        } else {
-                            RequestError.Skipped("Nothing to do for project `$projectKey`").left()
-                        }
-
-                    result.bind()
-                }
-
-            when (response) {
-                is Either.Right -> {
-                    call.respondText("OK", status = HttpStatusCode.OK)
-                    logger.info("POST /$projectKey — OK")
-                }
-                is Either.Left -> {
-                    val err = response.value
-                    call.respondText(err.message, status = HttpStatusCode.fromValue(err.httpCode))
-                    when (err) {
-                        is RequestError.Skipped ->
-                            logger.info("POST /$projectKey — Skipped")
-                        else -> {
-                            val ex = err.toException()
-                            logger.warn("POST /$projectKey — ${ex.message}", ex.cause)
-                        }
-                    }
-                }
-            }
-        }
-    }
 }

src/commonMain/kotlin/org/alexn/hook/OperatingSystem.kt

@@ -0,0 +1,18 @@
+package org.alexn.hook
+
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
+
+actual fun hmacSha256(data: String, key: String): String {
+    val mac = Mac.getInstance("HmacSHA256")
+    mac.init(SecretKeySpec(key.toByteArray(), "HmacSHA256"))
+    val bytes = mac.doFinal(data.toByteArray())
+    return bytes.joinToString("") { "%02x".format(it) }
+}
+
+actual fun hmacSha1(data: String, key: String): String {
+    val mac = Mac.getInstance("HmacSHA1")
+    mac.init(SecretKeySpec(key.toByteArray(), "HmacSHA1"))
+    val bytes = mac.doFinal(data.toByteArray())
+    return bytes.joinToString("") { "%02x".format(it) }
+}