chore: kotlin native refactorings

Author: sureshg

backend/native/build.gradle.kts

@@ -21,7 +21,7 @@ val appBinName = "app"
 description = "Ktor native application"
 
 kotlin {
-  allNativeTargets()
+  nativeTargets(project)
 
   targets.withType<KotlinNativeTarget>().configureEach {
     binaries {
@@ -49,12 +49,11 @@ kotlin {
     commonMain { dependencies { api(projects.shared) } }
     nativeMain {
       dependencies {
-        api(libs.ktor.client.cio)
         api(libs.kaml)
         api(libs.kmp.appdirs)
         api(libs.kfswatch)
         api(libs.chasm)
-        // api(libs.arrow.suspendapp.ktor)
+        api(libs.kmp.process)
       }
     }
 

backend/native/src/appleMain/kotlin/Env.kt

@@ -0,0 +1,4 @@
+import kotlinx.cinterop.toKString
+import platform.posix.getpass
+
+actual fun readPassword(prompt: String) = getpass(prompt)?.toKString()

backend/native/src/appleMain/kotlin/Process.kt

@@ -0,0 +1,4 @@
+import kotlinx.cinterop.toKString
+import platform.posix.getpass
+
+actual fun readPassword(prompt: String) = getpass(prompt)?.toKString()

backend/native/src/linuxMain/kotlin/Env.kt

@@ -0,0 +1,32 @@
+import kotlinx.cinterop.*
+import platform.windows.*
+
+actual fun readPassword(prompt: String): String? = memScoped {
+  print(prompt)
+
+  val handle = GetStdHandle(STD_INPUT_HANDLE)
+  if (handle == INVALID_HANDLE_VALUE) {
+    error("Standard input not available!")
+  }
+
+  val record = alloc<INPUT_RECORD>()
+  val read = alloc<DWORDVar>()
+
+  buildString {
+    while (true) {
+      val numberOfRecordsToRead = 1.convert<DWORD>()
+      if (ReadConsoleInput?.let { it(handle, record.ptr, numberOfRecordsToRead, read.ptr) } == 0) {
+        error("Could not read console input")
+      }
+
+      if (record.EventType == KEY_EVENT.toUShort() && record.Event.KeyEvent.bKeyDown != 0) {
+        val char = record.Event.KeyEvent.uChar.UnicodeChar
+        if (char == '\r'.code.toUShort()) {
+          break
+        } else if (char != 0.toUShort()) {
+          append(char)
+        }
+      }
+    }
+  }
+}

backend/native/src/linuxMain/kotlin/Process.kt

@@ -2,18 +2,17 @@ import com.charleskorn.kaml.Yaml
 import dev.suresh.Greeting
 import dev.suresh.flow.timerComposeFlow
 import dev.suresh.http.MediaApiClient
+import io.matthewnelson.kmp.process.*
 import kotlin.reflect.typeOf
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.runBlocking
 import kotlinx.io.files.Path
-import kotlinx.serialization.*
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
 import wasm.execWasm
 
-data class ProcessResult(val code: Int, val rawOutput: String?)
-
-expect fun execute(command: String, vararg args: String): ProcessResult
-
 expect fun readPassword(prompt: String): String?
 
 fun main(args: Array<String>): Unit = runBlocking {
@@ -25,8 +24,15 @@ fun main(args: Array<String>): Unit = runBlocking {
   timerComposeFlow().take(count).collect(::println)
 
   println("Executing command...")
-  runCatching { execute("ls", "-l").also(::println) }
-      .onFailure { println("Failed to execute command: ${it.message}") }
+  val ps =
+      Process.Builder(command = "ls")
+          .args("-l")
+          .destroySignal(Signal.SIGKILL)
+          .stdout(Stdio.Inherit)
+          .stderr(Stdio.Inherit)
+
+  val exit = ps.spawn { it.waitForAsync(2.seconds) ?: -1 }
+  println("Process exited: $exit")
 
   println("Reflection Simple name ${this::class.simpleName}")
   println("Reflection Simple name ${this::class.qualifiedName}")

backend/native/src/mingwMain/kotlin/Env.kt

@@ -22,7 +22,6 @@ kotlin.build.report.output=build_scan
 kotlinx.atomicfu.enableJvmIrTransformation=true
 kotlinx.atomicfu.enableNativeIrTransformation=true
 kotlinx.atomicfu.enableJsIrTransformation=true
-kapt.use.k2=true
 
 ## Kotlin/JS
 kotlin.js.yarn=false
@@ -31,6 +30,7 @@ kotlin.js.yarn=false
 kotlin.incremental.native=true
 kotlin.native.binary.gc=cms
 kotlin.native.ignoreDisabledTargets=true
+kotlin.native.enableKlibsCrossCompilation=true
 # kotlin.mpp.enableCInteropCommonization=true
 
 ## Dokka

backend/native/src/mingwMain/kotlin/Process.kt

@@ -4,7 +4,6 @@ import org.gradle.api.GradleException
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.*
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinNativeCompilerOptions
 import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackConfig
@@ -260,32 +259,47 @@ fun KotlinMultiplatformExtension.hostNativeTarget(configure: KotlinNativeTarget.
           throw GradleException("Host OS '${Platform.currentOS}' is not supported in Kotlin/Native")
     }
 
-fun KotlinNativeCompilerOptions.configureKotlinNative() {
-  // freeCompilerArgs.addAll("-Xverbose-phases=Linker", "-Xruntime-logs=gc=info")
-}
-
-fun KotlinMultiplatformExtension.allNativeTargets(winTarget: Boolean = false, configure: KotlinNativeTarget.() -> Unit = {}) {
-  fun KotlinNativeTarget.configureAll() {
-    // KotlinNativeTargetWithHostTests
-    compilerOptions { configureKotlinNative() }
-    configure()
-  }
-
-  compilerOptions {
-    optIn.addAll(
-        "kotlinx.cinterop.ExperimentalForeignApi",
-        "kotlin.experimental.ExperimentalNativeApi",
-    )
-  }
-
-  macosX64 { configureAll() }
-  macosArm64 { configureAll() }
-  linuxX64 { configureAll() }
-  linuxArm64 { configureAll() }
-  if(winTarget) {
-    mingwX64 { configureAll() }
-  }
-}
+fun KotlinMultiplatformExtension.nativeTargets(
+    project: Project,
+    configure: KotlinNativeTarget.() -> Unit = {}
+) =
+    with(project) {
+      val nativeBuild: String? by project
+      val nativeWinTarget: String? by project
+
+      if (nativeBuild.toBoolean()) {
+        fun KotlinNativeTarget.configureAll() {
+          compilerOptions {
+            // freeCompilerArgs.addAll("-Xverbose-phases=Linker", "-Xruntime-logs=gc=info")
+          }
+          configure()
+        }
+
+        compilerOptions {
+          optIn.addAll(
+              "kotlinx.cinterop.ExperimentalForeignApi",
+              "kotlin.experimental.ExperimentalNativeApi",
+          )
+        }
+
+        macosX64 { configureAll() }
+        macosArm64 { configureAll() }
+        linuxX64 { configureAll() }
+        linuxArm64 { configureAll() }
+        if (nativeWinTarget.toBoolean()) {
+          mingwX64 { configureAll() }
+        }
+
+        sourceSets {
+          nativeMain {
+            dependencies {
+              api(libs.ktor.client.cio)
+              // api(libs.arrow.suspendapp.ktor)
+            }
+          }
+        }
+      }
+    }
 
 fun KotlinMultiplatformExtension.addKspDependencyForAllTargets(
     project: Project,