refactor: reorganize utils

cdp-generate/build.gradle.kts

@@ -9,7 +9,7 @@ repositories {
 
 kotlin {
     dependencies {
-        implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.10")
+        implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.21")
         implementation("com.squareup:kotlinpoet:2.2.0")
     }
 }

core/build.gradle.kts

@@ -92,11 +92,18 @@
                 api(libs.ktor.client.darwin)
             }
         }
+        val posixMain by creating {
+            dependsOn(commonMain)
+        }
         val linuxMain by getting {
+            dependsOn(posixMain)
             dependencies {
                 api(libs.ktor.client.curl)
             }
         }
+        val macosMain by getting {
+            dependsOn(posixMain)
+        }
         val mingwMain by getting {
             dependencies {
                 api(libs.ktor.client.winhttp)

core/src/appleMain/kotlin/dev/kdriver/core/utils/Client.apple.kt → core/src/appleMain/kotlin/dev/kdriver/core/connection/Client.apple.kt

@@ -1,7 +1,7 @@
-package dev.kdriver.core.utils
+package dev.kdriver.core.connection
 
 import io.ktor.client.engine.*
 import io.ktor.client.engine.darwin.*
 
 actual fun getWebSocketClientEngine(): HttpClientEngineFactory<*> = Darwin
 actual fun getHttpApiClientEngine(): HttpClientEngineFactory<*> = Darwin

core/src/appleMain/kotlin/dev/kdriver/core/network/Extensions.apple.kt

@@ -0,0 +1,60 @@
+package dev.kdriver.core.network
+
+import kotlinx.cinterop.BetaInteropApi
+import kotlinx.cinterop.ExperimentalForeignApi
+import kotlinx.cinterop.addressOf
+import kotlinx.cinterop.usePinned
+import platform.Foundation.*
+import platform.posix.memcpy
+
+actual fun ByteArray.decompressZstd(): ByteArray {
+    // Zstandard decompression is not readily available in Kotlin/Native without additional libraries
+    // For now, return data as-is or throw an exception
+    throw UnsupportedOperationException("Zstandard decompression not yet supported on macOS native")
+}
+
+@OptIn(ExperimentalForeignApi::class, BetaInteropApi::class)
+actual fun ByteArray.decompressGzip(): ByteArray {
+    // Create NSData from ByteArray
+    val nsData = usePinned { pinned ->
+        NSData.create(bytes = pinned.addressOf(0), length = size.toULong())
+    }
+
+    // Use the /usr/bin/gunzip command as a workaround
+    // This is not ideal but works without needing zlib cinterop definitions
+    val tempDir = NSTemporaryDirectory()
+    val inputPath = tempDir + "input.gz"
+
+    // Write compressed data to temp file
+    nsData.writeToFile(inputPath, atomically = false)
+
+    // Run gunzip command
+    val task = NSTask()
+    task.launchPath = "/usr/bin/gunzip"
+    task.arguments = listOf("-c", inputPath)
+
+    val outputPipe = NSPipe()
+    task.standardOutput = outputPipe
+    task.standardError = NSPipe()
+
+    task.launch()
+    task.waitUntilExit()
+
+    // Read decompressed data
+    val outputData = outputPipe.fileHandleForReading.readDataToEndOfFile()
+
+    // Clean up temp file
+    NSFileManager.defaultManager.removeItemAtPath(inputPath, error = null)
+
+    // Convert NSData back to ByteArray
+    val size = outputData.length.toInt()
+    return if (size > 0) {
+        val result = ByteArray(size)
+        result.usePinned { pinned ->
+            memcpy(pinned.addressOf(0), outputData.bytes, size.toULong())
+        }
+        result
+    } else {
+        this // Return original if decompression failed
+    }
+}

core/src/commonMain/kotlin/dev/kdriver/core/browser/BrowserSearchConfig.kt

@@ -0,0 +1,175 @@
+package dev.kdriver.core.browser
+
+import kotlinx.io.files.Path
+
+/**
+ * Browser search configuration flags
+ */
+data class BrowserSearchConfig(
+    val pathSeparator: String,
+    val searchInPath: Boolean = true,
+    val searchMacosApplications: Boolean = false,
+    val searchWindowsProgramFiles: Boolean = false,
+    val searchLinuxCommonPaths: Boolean = false,
+) {
+
+    fun findBrowserExecutable(): Path? {
+        return findChromeExecutable()
+            ?: findOperaExecutable()
+            ?: findBraveExecutable()
+            ?: findEdgeExecutable()
+    }
+
+    fun findChromeExecutable(): Path? {
+        return findBrowserExecutableCommon(
+            executableNames = listOf(
+                "google-chrome",
+                "chromium",
+                "chromium-browser",
+                "chrome",
+                "google-chrome-stable"
+            ),
+            macosAppPaths = listOf(
+                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+                "/Applications/Chromium.app/Contents/MacOS/Chromium"
+            ),
+            linuxCommonPaths = listOf(
+                "/usr/bin/google-chrome",
+                "/usr/bin/chromium",
+                "/usr/bin/chromium-browser",
+                "/snap/bin/chromium",
+                "/opt/google/chrome/chrome",
+            ),
+            windowsProgramFilesSuffixes = listOf(
+                "Google/Chrome/Application",
+                "Google/Chrome Beta/Application",
+                "Google/Chrome Canary/Application",
+                "Google/Chrome SxS/Application",
+            ),
+            windowsExecutableNames = listOf("chrome.exe"),
+        )
+    }
+
+    fun findOperaExecutable(): Path? {
+        return findBrowserExecutableCommon(
+            executableNames = listOf("opera"),
+            macosAppPaths = listOf(
+                "/Applications/Opera.app/Contents/MacOS/Opera"
+            ),
+            linuxCommonPaths = listOf(
+                "/usr/bin/opera",
+                "/usr/local/bin/opera",
+            ),
+            windowsProgramFilesSuffixes = listOf(
+                "Opera",
+                "Programs/Opera"
+            ),
+            windowsExecutableNames = listOf("opera.exe"),
+        )
+    }
+
+    fun findBraveExecutable(): Path? {
+        return findBrowserExecutableCommon(
+            executableNames = listOf("brave-browser", "brave"),
+            macosAppPaths = listOf(
+                "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"
+            ),
+            linuxCommonPaths = listOf(
+                "/usr/bin/brave-browser",
+                "/usr/bin/brave",
+                "/snap/bin/brave",
+            ),
+            windowsProgramFilesSuffixes = listOf(
+                "BraveSoftware/Brave-Browser/Application"
+            ),
+            windowsExecutableNames = listOf("brave.exe"),
+        )
+    }
+
+    fun findEdgeExecutable(): Path? {
+        return findBrowserExecutableCommon(
+            executableNames = listOf(
+                "microsoft-edge",
+                "microsoft-edge-stable",
+                "microsoft-edge-beta",
+                "microsoft-edge-dev"
+            ),
+            macosAppPaths = listOf(
+                "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"
+            ),
+            linuxCommonPaths = listOf(
+                "/usr/bin/microsoft-edge",
+                "/usr/bin/microsoft-edge-stable",
+            ),
+            windowsProgramFilesSuffixes = listOf(
+                "Microsoft/Edge/Application"
+            ),
+            windowsExecutableNames = listOf("msedge.exe"),
+        )
+    }
+
+    /**
+     * Common helper to search for browser executables based on platform configuration.
+     *
+     * @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
+     *
+     * @return The Path to the found executable, or null if not found.
+     */
+    private fun findBrowserExecutableCommon(
+        executableNames: List<String>,
+        macosAppPaths: List<String> = emptyList(),
+        windowsProgramFilesSuffixes: List<String> = emptyList(),
+        windowsExecutableNames: List<String> = emptyList(),
+        linuxCommonPaths: List<String> = emptyList(),
+    ): Path? {
+        val candidates = mutableListOf<Path>()
+
+        // macOS applications
+        if (searchMacosApplications) {
+            candidates.addAll(macosAppPaths.map { Path(it) })
+        }
+
+        // Windows Program Files
+        if (searchWindowsProgramFiles) {
+            val programFiles = listOfNotNull(
+                getEnv("PROGRAMFILES"),
+                getEnv("PROGRAMFILES(X86)"),
+                getEnv("LOCALAPPDATA"),
+                getEnv("PROGRAMW6432")
+            )
+            for (base in programFiles) {
+                for (suffix in windowsProgramFilesSuffixes) {
+                    for (exe in windowsExecutableNames) {
+                        candidates.add(Path("$base/$suffix/$exe"))
+                    }
+                }
+            }
+        }
+
+        // Linux common paths
+        if (searchLinuxCommonPaths) {
+            candidates.addAll(linuxCommonPaths.map { Path(it) })
+        }
+
+        // Search in PATH
+        if (searchInPath) {
+            val pathEnv = getEnv("PATH")
+            val paths = pathEnv?.split(pathSeparator) ?: emptyList()
+            for (pathDir in paths) {
+                for (exe in executableNames + windowsExecutableNames) {
+                    candidates.add(Path("$pathDir/$exe"))
+                }
+            }
+        }
+
+        // Return the shortest path that exists
+        return candidates
+            .filter { exists(it) }
+            .minByOrNull { it.toString().length }
+    }
+
+}

core/src/commonMain/kotlin/dev/kdriver/core/browser/Config.kt

@@ -1,7 +1,6 @@
 package dev.kdriver.core.browser
 
 import dev.kdriver.core.exceptions.NoBrowserExecutablePathException
-import dev.kdriver.core.utils.*
 import io.ktor.util.logging.*
 import kotlinx.io.files.Path
 
@@ -30,10 +29,7 @@ class Config(
     internal val _extensions: MutableList<Path> = mutableListOf()
 
     val browserExecutablePath: Path = browserExecutablePath
-        ?: findChromeExecutable()
-        ?: findOperaExecutable()
-        ?: findBraveExecutable()
-        ?: findEdgeExecutable()
+        ?: defaultBrowserSearchConfig().findBrowserExecutable()
         ?: throw NoBrowserExecutablePathException()
 
     var sandbox: Boolean = sandbox

core/src/commonMain/kotlin/dev/kdriver/core/browser/DefaultBrowser.kt

@@ -11,7 +11,6 @@ import dev.kdriver.core.exceptions.BrowserExecutableNotFoundException
 import dev.kdriver.core.exceptions.FailedToConnectToBrowserException
 import dev.kdriver.core.tab.DefaultTab
 import dev.kdriver.core.tab.Tab
-import dev.kdriver.core.utils.*
 import io.ktor.util.logging.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.sync.Mutex

core/src/commonMain/kotlin/dev/kdriver/core/browser/HTTPApi.kt

@@ -1,7 +1,7 @@
 package dev.kdriver.core.browser
 
 import dev.kaccelero.serializers.Serialization
-import dev.kdriver.core.utils.getHttpApiClientEngine
+import dev.kdriver.core.connection.getHttpApiClientEngine
 import io.ktor.client.*
 import io.ktor.client.call.*
 import io.ktor.client.plugins.contentnegotiation.*

core/src/commonMain/kotlin/dev/kdriver/core/browser/Process.kt

@@ -0,0 +1,19 @@
+package dev.kdriver.core.browser
+
+import kotlinx.io.files.Path
+
+expect abstract class Process {
+    fun isAlive(): Boolean
+    fun pid(): Long
+    abstract fun destroy()
+}
+
+expect suspend fun startProcess(exe: Path, params: List<String>): Process
+expect fun addShutdownHook(hook: suspend () -> Unit)
+expect fun isPosix(): Boolean
+expect fun isRoot(): Boolean
+expect fun tempProfileDir(): Path
+expect fun exists(path: Path): Boolean
+expect fun getEnv(name: String): String?
+expect fun freePort(): Int?
+expect fun defaultBrowserSearchConfig(): BrowserSearchConfig

core/src/commonMain/kotlin/dev/kdriver/core/utils/Client.kt → core/src/commonMain/kotlin/dev/kdriver/core/connection/Client.kt

@@ -1,6 +1,6 @@
-package dev.kdriver.core.utils
+package dev.kdriver.core.connection
 
 import io.ktor.client.engine.*
 
 expect fun getWebSocketClientEngine(): HttpClientEngineFactory<*>
 expect fun getHttpApiClientEngine(): HttpClientEngineFactory<*>

core/src/commonMain/kotlin/dev/kdriver/core/connection/DefaultConnection.kt

@@ -4,8 +4,7 @@
 import dev.kdriver.cdp.*
 import dev.kdriver.cdp.domain.*
 import dev.kdriver.core.browser.Browser
-import dev.kdriver.core.utils.getWebSocketClientEngine
-import dev.kdriver.core.utils.parseWebSocketUrl
+import dev.kdriver.core.browser.WebSocketInfo
 import io.ktor.client.*
 import io.ktor.client.plugins.websocket.*
 import io.ktor.http.*
@@ -27,7 +26,7 @@
 /**
  * Default implementation of the [Connection] interface.
  */
 open class DefaultConnection(
     private val websocketUrl: String,
     private val messageListeningScope: CoroutineScope,
     override var targetInfo: Target.TargetInfo? = null,
@@ -207,6 +206,20 @@
         prepareExpertDone = true
     }
 
+    private fun parseWebSocketUrl(url: String): WebSocketInfo {
+        val uri = Url(url)
+
+        val host = uri.host
+        val port = if (uri.port != -1) uri.port else when (uri.protocol) {
+            URLProtocol.WS -> 80
+            URLProtocol.WSS -> 443
+            else -> throw IllegalArgumentException("Unsupported scheme: ${uri.protocol}")
+        }
+        val path = uri.encodedPath
+
+        return WebSocketInfo(host, port, path)
+    }
+
     override fun toString(): String {
         return "Connection: ${targetInfo?.toString() ?: "no target"}"
     }