native linux and windows support

core/build.gradle.kts

@@ -39,9 +39,9 @@
     // Native targets
     macosX64()
     macosArm64()
-    //linuxX64()
-    //linuxArm64()
-    //mingwX64()
+    linuxX64()
+    linuxArm64()
+    mingwX64()
 
     // jvm & js
     jvmToolchain(21)
@@ -92,6 +92,16 @@
                 api(libs.ktor.client.darwin)
             }
         }
+        val linuxMain by getting {
+            dependencies {
+                api(libs.ktor.client.curl)
+            }
+        }
+        val mingwMain by getting {
+            dependencies {
+                api(libs.ktor.client.winhttp)
+            }
+        }
         val jvmTest by getting {
             dependencies {
                 implementation(kotlin("test"))
@@ -103,6 +113,16 @@
                 implementation(kotlin("test"))
             }
         }
+        val linuxTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+            }
+        }
+        val mingwTest by getting {
+            dependencies {
+                implementation(kotlin("test"))
+            }
+        }
     }
 }
 

core/src/commonMain/kotlin/dev/kdriver/core/utils/Utils.kt

@@ -62,6 +62,79 @@
     return header == listOf(0x1F, 0x8B)
 }
 
+/**
+ * Browser search configuration flags
+ */
+data class BrowserSearchConfig(
+    val searchInPath: Boolean = true,
+    val searchMacosApplications: Boolean = false,
+    val searchWindowsProgramFiles: Boolean = false,
+    val searchLinuxCommonPaths: Boolean = false,
+)
+
+/**
+ * Common helper to search for browser executables based on platform configuration.
+ * @param config Platform-specific search configuration
+ * @param pathSeparator The path separator character (":" for POSIX, ";" for Windows)
+ * @param pathEnv The PATH environment variable value
+ * @param executableNames List of executable names to search for (e.g., ["chrome", "google-chrome"])
+ * @param macosAppPaths macOS .app bundle paths (only used if searchMacosApplications is true)
+ * @param windowsProgramFilesSuffixes Windows Program Files subdirectories (only used if searchWindowsProgramFiles is true)
+ * @param linuxCommonPaths Common Linux installation paths (only used if searchLinuxCommonPaths is true)
+ * @param windowsExecutableNames Windows executable names with .exe extension
+ * @param windowsProgramFilesGetter Callback to get Windows program files directories
+ */
+internal fun findBrowserExecutableCommon(
+    config: BrowserSearchConfig,
+    pathSeparator: String,
+    pathEnv: String?,
+    executableNames: List<String>,
+    macosAppPaths: List<String> = emptyList(),
+    windowsProgramFilesSuffixes: List<String> = emptyList(),
+    windowsExecutableNames: List<String> = emptyList(),
+    linuxCommonPaths: List<String> = emptyList(),
+    windowsProgramFilesGetter: () -> List<String> = { emptyList() },
+): Path? {
+    val candidates = mutableListOf<Path>()
+
+    // macOS applications
+    if (config.searchMacosApplications) {
+        candidates.addAll(macosAppPaths.map { Path(it) })
+    }
+
+    // Windows Program Files
+    if (config.searchWindowsProgramFiles) {
+        val programFiles = windowsProgramFilesGetter()
+        for (base in programFiles) {
+            for (suffix in windowsProgramFilesSuffixes) {
+                for (exe in windowsExecutableNames) {
+                    candidates.add(Path("$base/$suffix/$exe"))
+                }
+            }
+        }
+    }
+
+    // Linux common paths
+    if (config.searchLinuxCommonPaths) {
+        candidates.addAll(linuxCommonPaths.map { Path(it) })
+    }
+
+    // Search in PATH
+    if (config.searchInPath) {
+        val paths = pathEnv?.split(pathSeparator) ?: emptyList()
+        for (pathDir in paths) {
+            for (exe in executableNames) {
+                candidates.add(Path("$pathDir/$exe"))
+            }
+        }
+    }
+
+    // Return the shortest path that exists
+    return candidates
+        .filter { exists(it) }
+        .minByOrNull { it.toString().length }
+}
+
 expect abstract class Process {
     fun isAlive(): Boolean
     fun pid(): Long
@@ -74,6 +147,7 @@
 expect fun isRoot(): Boolean
 expect fun tempProfileDir(): Path
 expect fun exists(path: Path): Boolean
+expect fun getEnv(name: String): String?
 expect fun findChromeExecutable(): Path?
 expect fun findOperaExecutable(): Path?
 expect fun findBraveExecutable(): Path?

core/src/jsMain/kotlin/dev/kdriver/core/utils/Utils.js.kt

@@ -42,6 +42,10 @@
     throw UnsupportedOperationException()
 }
 
+actual fun getEnv(name: String): String? {
+    throw UnsupportedOperationException()
+}
+
 actual fun findChromeExecutable(): Path? {
     throw UnsupportedOperationException()
 }