Migrate project to Multiplatform (KMP) (#22)

* Migrate to Kotlin multiplatform

* Fix publication

* Switch to using `alias` for the AtomicFu plugin

---------

Co-authored-by: Alexander Sysoev <Alexander.Sysoev@jetbrains.com>

Author: devcrocod

build.gradle.kts

@@ -1,61 +1,35 @@
+@file:OptIn(ExperimentalKotlinGradlePluginApi::class)
+
 import org.jetbrains.dokka.gradle.engine.parameters.VisibilityModifier
+import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.dsl.ExplicitApiMode
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jreleaser.model.Active
 
 plugins {
-    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.multiplatform)
     alias(libs.plugins.kotlin.serialization)
     alias(libs.plugins.dokka)
     alias(libs.plugins.jreleaser)
+    alias(libs.plugins.atomicfu)
     `maven-publish`
 }
 
 group = "io.modelcontextprotocol"
 version = "0.2.0"
 
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    api(libs.kotlinx.serialization.json)
-    api(libs.ktor.client.cio)
-    api(libs.ktor.server.cio)
-    api(libs.ktor.server.sse)
-    api(libs.ktor.server.websockets)
-
-    implementation(libs.kotlin.logging)
-
-    testImplementation(libs.kotlin.test)
-    testImplementation(libs.mockk)
-    testImplementation(libs.ktor.server.test.host)
-    testImplementation(libs.kotlinx.coroutines.test)
-    testImplementation(libs.kotlinx.coroutines.debug)
-}
-
-val sources = tasks.create<Jar>("sourcesJar") {
-    from(sourceSets["main"].allSource)
-    archiveClassifier.set("sources")
+val mainSourcesJar = tasks.register<Jar>("mainSourcesJar") {
+    archiveClassifier = "sources"
+    from(kotlin.sourceSets.getByName("commonMain").kotlin)
 }
 
 publishing {
-    publications {
-        create<MavenPublication>("maven") {
-            groupId = project.group.toString()
-            artifactId = project.name
-            version = project.version.toString()
-
-            from(components["java"])
-        }
-    }
-
     val javadocJar = configureEmptyJavadocArtifact()
 
     publications.withType(MavenPublication::class).all {
         pom.configureMavenCentralMetadata()
         signPublicationIfKeyPresent()
         artifact(javadocJar)
-        artifact(sources)
     }
 
     repositories {
@@ -164,17 +138,7 @@ infix fun <T> Property<T>.by(value: T) {
     set(value)
 }
 
-tasks.create<Jar>("localJar") {
-    dependsOn(tasks.jar)
-
-    archiveFileName = "kotlin-sdk.jar"
-    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-    from(configurations.runtimeClasspath.map {
-        it.map { if (it.isDirectory) it else zipTree(it) }
-    })
-}
-
-tasks.test {
+tasks.withType<Test>().configureEach {
     useJUnitPlatform()
 }
 
@@ -205,7 +169,7 @@ abstract class GenerateLibVersionTask @Inject constructor(
 dokka {
     moduleName.set("MCP Kotlin SDK")
 
-    dokkaSourceSets.main {
+    dokkaSourceSets.configureEach {
         sourceLink {
             localDirectory.set(file("src/main/kotlin"))
             remoteUrl("https://github.com/modelcontextprotocol/kotlin-sdk")
@@ -224,13 +188,43 @@ val generateLibVersionTask =
     tasks.register<GenerateLibVersionTask>("generateLibVersion", version.toString(), sourcesDir)
 
 kotlin {
+    jvm {
+        compilerOptions {
+            jvmTarget = JvmTarget.JVM_17
+        }
+    }
+
     explicitApi = ExplicitApiMode.Strict
 
     jvmToolchain(21)
 
     sourceSets {
-        main {
+        commonMain {
             kotlin.srcDir(generateLibVersionTask.map { it.sourcesDir })
+            dependencies {
+                api(libs.kotlinx.serialization.json)
+                api(libs.ktor.client.cio)
+                api(libs.ktor.server.cio)
+                api(libs.ktor.server.sse)
+                api(libs.ktor.server.websockets)
+
+                implementation(libs.kotlin.logging)
+            }
+        }
+
+        commonTest {
+            dependencies {
+                implementation(libs.kotlin.test)
+                implementation(libs.ktor.server.test.host)
+                implementation(libs.kotlinx.coroutines.test)
+                implementation(libs.kotlinx.coroutines.debug)
+            }
+        }
+
+        jvmTest {
+            dependencies {
+                implementation(libs.mockk)
+            }
         }
     }
 }

gradle/libs.versions.toml

@@ -1,7 +1,8 @@
 [versions]
 # plugins version
 kotlin = "2.0.21"
-dokka = "2.0.0-Beta"
+dokka = "2.0.0"
+atomicfu = "0.26.1"
 
 # libraries version
 serialization = "1.7.3"
@@ -14,10 +15,9 @@ jreleaser = "1.15.0"
 [libraries]
 # Kotlinx libraries
 kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "serialization" }
-kotlin-logging = { group = "io.github.oshai", name = "kotlin-logging-jvm", version.ref = "logging" }
+kotlin-logging = { group = "io.github.oshai", name = "kotlin-logging", version.ref = "logging" }
 
 # Ktor
-ktor-client-apache = { group = "io.ktor", name = "ktor-client-apache", version.ref = "ktor" }
 ktor-client-cio = { group = "io.ktor", name = "ktor-client-cio", version.ref = "ktor" }
 ktor-server-sse = { group = "io.ktor", name = "ktor-server-sse", version.ref = "ktor" }
 ktor-server-websockets = { group = "io.ktor", name = "ktor-server-websockets", version.ref = "ktor" }
@@ -33,7 +33,8 @@ mockk = { group = "io.mockk", name = "mockk", version.ref = "mockk" }
 
 
 [plugins]
-kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
 kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
-jreleaser = { id = "org.jreleaser", version.ref = "jreleaser"}
+jreleaser = { id = "org.jreleaser", version.ref = "jreleaser"}
+atomicfu = { id = "org.jetbrains.kotlinx.atomicfu", version.ref = "atomicfu" }

settings.gradle.kts

@@ -1,5 +1,19 @@
-plugins {
-    id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+pluginManagement {
+    repositories {
+        mavenCentral()
+        gradlePluginPortal()
+    }
+
+    plugins {
+        id("org.gradle.toolchains.foojay-resolver-convention") version "0.8.0"
+    }
+}
+
+dependencyResolutionManagement {
+    repositories {
+        mavenCentral()
+    }
 }
+
 rootProject.name = "kotlin-sdk"
 

src/main/kotlin/io/modelcontextprotocol/kotlin/sdk/client/Client.kt renamed to src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/client/Client.kt

@@ -8,9 +8,10 @@ import io.ktor.http.*
 import io.modelcontextprotocol.kotlin.sdk.JSONRPCMessage
 import io.modelcontextprotocol.kotlin.sdk.shared.McpJson
 import io.modelcontextprotocol.kotlin.sdk.shared.Transport
+import kotlinx.atomicfu.AtomicBoolean
+import kotlinx.atomicfu.atomic
 import kotlinx.coroutines.*
 import kotlinx.serialization.encodeToString
-import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.properties.Delegates
 import kotlin.time.Duration
 
@@ -28,7 +29,7 @@ public class SSEClientTransport(
         CoroutineScope(session.coroutineContext + SupervisorJob())
     }
 
-    private val initialized = AtomicBoolean(false)
+    private val initialized: AtomicBoolean = atomic(false)
     private var session: ClientSSESession by Delegates.notNull()
     private val endpoint = CompletableDeferred<String>()
 
@@ -127,7 +128,7 @@ public class SSEClientTransport(
     }
 
     override suspend fun close() {
-        if (!initialized.get()) {
+        if (!initialized.value) {
             error("SSEClientTransport is not initialized!")
         }
 

src/main/kotlin/io/modelcontextprotocol/kotlin/sdk/client/SSEClientTransport.kt renamed to src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/client/SSEClientTransport.kt

@@ -5,14 +5,18 @@ import io.modelcontextprotocol.kotlin.sdk.JSONRPCMessage
 import io.modelcontextprotocol.kotlin.sdk.shared.ReadBuffer
 import io.modelcontextprotocol.kotlin.sdk.shared.Transport
 import io.modelcontextprotocol.kotlin.sdk.shared.serializeMessage
+import kotlinx.atomicfu.AtomicBoolean
+import kotlinx.atomicfu.atomic
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
 import kotlinx.coroutines.channels.consumeEach
-import java.io.InputStream
-import java.io.OutputStream
-import java.util.concurrent.atomic.AtomicBoolean
+import kotlinx.io.Buffer
+import kotlinx.io.Sink
+import kotlinx.io.Source
+import kotlinx.io.buffered
+import kotlinx.io.readByteArray
+import kotlinx.io.writeString
 import kotlin.coroutines.CoroutineContext
-import kotlin.text.Charsets.UTF_8
 
 /**
  * A transport implementation for JSON-RPC communication that leverages standard input and output streams.
@@ -24,16 +28,16 @@ import kotlin.text.Charsets.UTF_8
  * @param output The output stream where messages are sent.
  */
 public class StdioClientTransport(
-    private val input: InputStream,
-    private val output: OutputStream
+    private val input: Source,
+    private val output: Sink
 ) : Transport {
     private val logger = KotlinLogging.logger {}
     private val ioCoroutineContext: CoroutineContext = Dispatchers.IO
     private val scope by lazy {
         CoroutineScope(ioCoroutineContext + SupervisorJob())
     }
     private var job: Job? = null
-    private var initialized = AtomicBoolean(false)
+    private val initialized: AtomicBoolean = atomic(false)
     private val sendChannel = Channel<JSONRPCMessage>(Channel.UNLIMITED)
     private val readBuffer = ReadBuffer()
 
@@ -48,28 +52,26 @@ public class StdioClientTransport(
 
         logger.debug { "Starting StdioClientTransport..." }
 
-        val outputStream = output.bufferedWriter(UTF_8)
+        val outputStream = output.buffered()
 
         job = scope.launch(CoroutineName("StdioClientTransport.IO#${hashCode()}")) {
             val readJob = launch {
                 logger.debug { "Read coroutine started." }
                 try {
-                    val buffer = ByteArray(8192)
-                    while (isActive) {
-                        val bytesRead = input.read(buffer)
-                        if (bytesRead == -1) break
-                        if (bytesRead > 0) {
-                            readBuffer.append(buffer.copyOf(bytesRead))
-                            processReadBuffer()
+                    input.use {
+                        while (isActive) {
+                            val buffer = Buffer()
+                            val bytesRead = input.readAtMostTo(buffer, 8192)
+                            if (bytesRead == -1L) break
+                            if (bytesRead > 0L) {
+                                readBuffer.append(buffer.readByteArray())
+                                processReadBuffer()
+                            }
                         }
                     }
-                } catch (e: CancellationException) {
-                    throw e
                 } catch (e: Exception) {
                     onError?.invoke(e)
                     logger.error(e) { "Error reading from input stream" }
-                } finally {
-                    input.close()
                 }
             }
 
@@ -78,7 +80,7 @@ public class StdioClientTransport(
                 try {
                     sendChannel.consumeEach { message ->
                         val json = serializeMessage(message)
-                        outputStream.write(json)
+                        outputStream.writeString(json)
                         outputStream.flush()
                     }
                 } catch (e: Throwable) {
@@ -98,7 +100,7 @@ public class StdioClientTransport(
     }
 
     override suspend fun send(message: JSONRPCMessage) {
-        if (!initialized.get()) {
+        if (!initialized.value) {
             error("Transport not started")
         }
 

src/main/kotlin/io/modelcontextprotocol/kotlin/sdk/client/StdioClientTransport.kt renamed to src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/client/StdioClientTransport.kt

@@ -33,7 +33,7 @@ public suspend fun HttpClient.mcpWebSocket(
     val client = Client(
         Implementation(
             name = IMPLEMENTATION_NAME,
-            version = LIB_VERSION,
+            version = LIB_VERSION
         )
     )
     client.connect(transport)

src/main/kotlin/io/modelcontextprotocol/kotlin/sdk/client/WebSocketClientTransport.kt renamed to src/commonMain/kotlin/io/modelcontextprotocol/kotlin/sdk/client/WebSocketClientTransport.kt

@@ -38,7 +38,7 @@ public suspend fun HttpClient.mcpSse(
     val client = Client(
         Implementation(
             name = IMPLEMENTATION_NAME,
-            version = LIB_VERSION,
+            version = LIB_VERSION
         )
     )
     client.connect(transport)