Add MCP screenshots for Compose dev tools

build.gradle.kts

@@ -12,6 +12,11 @@ plugins {
   alias(libs.plugins.spotless)
 }
 
+allprojects {
+  group = "com.composables"
+  version = "0.1.0"
+}
+
 configure<com.diffplug.gradle.spotless.SpotlessExtension> {
   kotlinGradle {
     target("*.gradle.kts")

devtools/gradle-plugin/build.gradle.kts

@@ -22,8 +22,13 @@
 plugins {
   `kotlin-dsl`
   `java-gradle-plugin`
+  `maven-publish`
 }
 
+group = "com.composables"
+
+version = "0.1.0"
+
 java { toolchain { languageVersion = JavaLanguageVersion.of(17) } }
 
 dependencies {

devtools/gradle-plugin/src/main/kotlin/com/composables/devtools/gradle/ComposablesDevToolsPlugin.kt

@@ -7,8 +7,10 @@ import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.model.ObjectFactory
 import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.JavaExec
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.TaskAction
+import org.gradle.work.DisableCachingByDefault
 import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.create
 import org.gradle.kotlin.dsl.named
@@ -21,8 +23,10 @@ import javax.inject.Inject
 
 abstract class ComposablesDevToolsExtension @Inject constructor(objects: ObjectFactory) {
   val appComposable: Property<String> = objects.property(String::class.java)
+  val runtimeDependencyPath: Property<String> = objects.property(String::class.java).convention(DEV_TOOLS_RUNTIME_PATH)
 }
 
+@DisableCachingByDefault(because = "The task writes a generated source file from a small extension value.")
 abstract class GenerateComposablesDevToolsMainTask : DefaultTask() {
   @get:Input
   abstract val appComposable: Property<String>
@@ -76,70 +80,74 @@ abstract class GenerateComposablesDevToolsMainTask : DefaultTask() {
       import com.composables.devtools.oppositeDevToolsLayoutDirection
       import com.composables.devtools.requestDevToolsHotReload
       import com.composables.devtools.rotated
+      import com.composables.devtools.startDevToolsAutomationServer
 
-      fun main() = application {
-        val windowState = rememberWindowState(width = 960.dp, height = 860.dp)
-        var selectedDevice by remember { mutableStateOf(DevToolsDevices.Desktop) }
-        var selectedOrientation by remember { mutableStateOf(DevToolsOrientation.Portrait) }
-        var selectedLayoutDirection by remember { mutableStateOf(LayoutDirection.Ltr) }
-        var selectedZoom by remember { mutableStateOf(DevToolsZoom.Default) }
-        var toolbarVisible by remember { mutableStateOf(true) }
-        var saveScreenshotRequest by remember { mutableStateOf(0) }
-        var copyScreenshotRequest by remember { mutableStateOf(0) }
-
-        Window(
-          onCloseRequest = ::exitApplication,
-          state = windowState,
-          title = "Composables Dev Tools",
-          onKeyEvent = { event ->
-            val shortcutDevice = deviceForDevToolsShortcut(event)
-            if (shortcutDevice != null) {
-              selectedDevice = shortcutDevice
-              true
-            } else if (isDevToolsHotReloadShortcut(event) && isDevToolsHotReloadAvailable()) {
-              runCatching { requestDevToolsHotReload() }
-              true
-            } else if (isDevToolsScreenshotSaveShortcut(event)) {
-              saveScreenshotRequest++
-              true
-            } else if (isDevToolsScreenshotCopyShortcut(event)) {
-              copyScreenshotRequest++
-              true
-            } else if (isDevToolsRotationShortcut(event) && selectedDevice.canRotate) {
-              selectedOrientation = selectedOrientation.rotated()
-              true
-            } else if (isDevToolsLayoutDirectionShortcut(event)) {
-              selectedLayoutDirection = selectedLayoutDirection.oppositeDevToolsLayoutDirection()
-              true
-            } else if (isDevToolsToolbarShortcut(event)) {
-              toolbarVisible = !toolbarVisible
-              true
-            } else {
-              val shortcutZoom = devToolsZoomForShortcut(event, selectedZoom)
-              if (shortcutZoom != null) {
-                selectedZoom = shortcutZoom
+      fun main() {
+        startDevToolsAutomationServer()
+        application {
+          val windowState = rememberWindowState(width = 960.dp, height = 860.dp)
+          var selectedDevice by remember { mutableStateOf(DevToolsDevices.Desktop) }
+          var selectedOrientation by remember { mutableStateOf(DevToolsOrientation.Portrait) }
+          var selectedLayoutDirection by remember { mutableStateOf(LayoutDirection.Ltr) }
+          var selectedZoom by remember { mutableStateOf(DevToolsZoom.Default) }
+          var toolbarVisible by remember { mutableStateOf(true) }
+          var saveScreenshotRequest by remember { mutableStateOf(0) }
+          var copyScreenshotRequest by remember { mutableStateOf(0) }
+
+          Window(
+            onCloseRequest = ::exitApplication,
+            state = windowState,
+            title = "Composables Dev Tools",
+            onKeyEvent = { event ->
+              val shortcutDevice = deviceForDevToolsShortcut(event)
+              if (shortcutDevice != null) {
+                selectedDevice = shortcutDevice
+                true
+              } else if (isDevToolsHotReloadShortcut(event) && isDevToolsHotReloadAvailable()) {
+                runCatching { requestDevToolsHotReload() }
+                true
+              } else if (isDevToolsScreenshotSaveShortcut(event)) {
+                saveScreenshotRequest++
+                true
+              } else if (isDevToolsScreenshotCopyShortcut(event)) {
+                copyScreenshotRequest++
+                true
+              } else if (isDevToolsRotationShortcut(event) && selectedDevice.canRotate) {
+                selectedOrientation = selectedOrientation.rotated()
+                true
+              } else if (isDevToolsLayoutDirectionShortcut(event)) {
+                selectedLayoutDirection = selectedLayoutDirection.oppositeDevToolsLayoutDirection()
+                true
+              } else if (isDevToolsToolbarShortcut(event)) {
+                toolbarVisible = !toolbarVisible
                 true
               } else {
-                false
+                val shortcutZoom = devToolsZoomForShortcut(event, selectedZoom)
+                if (shortcutZoom != null) {
+                  selectedZoom = shortcutZoom
+                  true
+                } else {
+                  false
+                }
               }
-            }
-          },
-        ) {
-          DevTools(
-            initialDevice = DevToolsDevices.Desktop,
-            selectedDevice = selectedDevice,
-            onDeviceSelected = { selectedDevice = it },
-            selectedOrientation = selectedOrientation,
-            onOrientationSelected = { selectedOrientation = it },
-            selectedLayoutDirection = selectedLayoutDirection,
-            onLayoutDirectionSelected = { selectedLayoutDirection = it },
-            selectedZoom = selectedZoom,
-            onZoomSelected = { selectedZoom = it },
-            showControls = toolbarVisible,
-            saveScreenshotRequest = saveScreenshotRequest,
-            copyScreenshotRequest = copyScreenshotRequest,
+            },
           ) {
-            $appComposableCall()
+            DevTools(
+              initialDevice = DevToolsDevices.Desktop,
+              selectedDevice = selectedDevice,
+              onDeviceSelected = { selectedDevice = it },
+              selectedOrientation = selectedOrientation,
+              onOrientationSelected = { selectedOrientation = it },
+              selectedLayoutDirection = selectedLayoutDirection,
+              onLayoutDirectionSelected = { selectedLayoutDirection = it },
+              selectedZoom = selectedZoom,
+              onZoomSelected = { selectedZoom = it },
+              showControls = toolbarVisible,
+              saveScreenshotRequest = saveScreenshotRequest,
+              copyScreenshotRequest = copyScreenshotRequest,
+            ) {
+              $appComposableCall()
+            }
           }
         }
       }
@@ -152,8 +160,10 @@ class ComposablesDevToolsPlugin : Plugin<Project> {
   override fun apply(project: Project) {
     val extension = project.extensions.create<ComposablesDevToolsExtension>("composablesDevTools")
     val generatedSourceDirectory = project.layout.buildDirectory.dir("generated/composablesDevTools/kotlin")
+    val mcpRuntimeConfiguration = project.configurations.create("devToolsMcpRuntime")
 
     project.pluginManager.apply("org.jetbrains.compose.hot-reload")
+    project.dependencies.add(mcpRuntimeConfiguration.name, DEV_TOOLS_MCP_RUNTIME_COORDINATES)
 
     val generateMain = project.tasks.register<GenerateComposablesDevToolsMainTask>("generateDevToolsMain") {
       appComposable.set(extension.appComposable)
@@ -175,18 +185,43 @@ class ComposablesDevToolsPlugin : Plugin<Project> {
           devCompilation.defaultSourceSet.apply {
             kotlin.srcDir(generateMain.map { it.outputDirectory })
             dependencies {
-              implementation(project.dependencies.project(mapOf("path" to DEV_TOOLS_RUNTIME_PATH)))
+              val runtimeDependencyPath = extension.runtimeDependencyPath.get()
+              val runtimeDependency = if (project.rootProject.findProject(runtimeDependencyPath) == null) {
+                DEV_TOOLS_RUNTIME_COORDINATES
+              } else {
+                project.dependencies.project(mapOf("path" to runtimeDependencyPath))
+              }
+              implementation(runtimeDependency)
               implementation(ComposePlugin.Dependencies(project).desktop.currentOs)
             }
           }
 
-          project.tasks.register<ComposeHotRun>("runDevTools") {
+          val runDevTools = project.tasks.register<ComposeHotRun>("runDevTools") {
             group = "compose dev tools"
             description = "Runs the configured Compose app composable inside the dev tools host with automatic hot reload."
             dependsOn(generateMain)
             compilation.set(devCompilation)
             mainClass.set(DEV_TOOLS_MAIN_CLASS)
             isAutoReloadEnabled.set(true)
+            systemProperty(DEV_TOOLS_PORT_FILE_PROPERTY, DEV_TOOLS_PORT_FILE_PATH)
+            runHotReloadDevToolsHeadless(project)
+          }
+
+          project.gradle.projectsEvaluated {
+            runDevTools.configure {
+              runHotReloadDevToolsHeadless(project)
+            }
+          }
+
+          project.tasks.register<JavaExec>("runDevToolsMcpServer") {
+            group = "compose dev tools"
+            description = "Runs an MCP server for controlling the running Compose dev tools host."
+            classpath = mcpRuntimeConfiguration
+            mainClass.set("com.composables.devtools.DevToolsMcpServer_jvmKt")
+            systemProperty(DEV_TOOLS_PORT_FILE_PROPERTY, DEV_TOOLS_PORT_FILE_PATH)
+            standardInput = System.`in`
+            standardOutput = System.out
+            errorOutput = System.err
           }
 
           project.tasks.register("checkDevToolsCompatibility") {
@@ -200,5 +235,29 @@ class ComposablesDevToolsPlugin : Plugin<Project> {
   }
 }
 
+private fun ComposeHotRun.runHotReloadDevToolsHeadless(project: Project) {
+  val enabled = project.providers.provider { true }
+  jvmArgumentProviders
+      .filter { arguments -> arguments.javaClass.name == HOT_RELOAD_ARGUMENTS_CLASS_NAME }
+      .forEach { arguments ->
+        arguments.invokeHotReloadArgumentSetter("setDevToolsEnabled", enabled)
+        arguments.invokeHotReloadArgumentSetter("setDevToolsHeadless", enabled)
+      }
+}
+
+private fun Any.invokeHotReloadArgumentSetter(name: String, value: Any) {
+  val setter =
+      javaClass.methods.firstOrNull { method ->
+        method.name == name && method.parameterTypes.size == 1
+      } ?: error("Compose Hot Reload no longer exposes $name on ${javaClass.name}.")
+
+  setter.invoke(this, value)
+}
+
 private const val DEV_TOOLS_RUNTIME_PATH = ":devtools:runtime"
+private const val DEV_TOOLS_RUNTIME_COORDINATES = "com.composables:runtime:0.1.0"
+private const val DEV_TOOLS_MCP_RUNTIME_COORDINATES = "com.composables:runtime-jvm:0.1.0"
 private const val DEV_TOOLS_MAIN_CLASS = "com.composables.devtools.generated.DevToolsMainKt"
+private const val DEV_TOOLS_PORT_FILE_PROPERTY = "composables.devtools.portFile"
+private const val DEV_TOOLS_PORT_FILE_PATH = "/tmp/composables-devtools.port"
+private const val HOT_RELOAD_ARGUMENTS_CLASS_NAME = "org.jetbrains.compose.reload.gradle.ComposeHotReloadArguments"

devtools/insets/build.gradle.kts

@@ -23,6 +23,7 @@ plugins {
   alias(libs.plugins.kotlin.multiplatform)
   alias(libs.plugins.compose)
   alias(libs.plugins.compose.compiler)
+  `maven-publish`
 }
 
 java { toolchain { languageVersion = JavaLanguageVersion.of(17) } }

devtools/runtime/build.gradle.kts

@@ -23,6 +23,7 @@ plugins {
   alias(libs.plugins.kotlin.multiplatform)
   alias(libs.plugins.compose)
   alias(libs.plugins.compose.compiler)
+  `maven-publish`
 }
 
 java { toolchain { languageVersion = JavaLanguageVersion.of(17) } }

devtools/runtime/src/commonMain/kotlin/com/composables/devtools/DevTools.kt

@@ -150,6 +150,7 @@ import kotlin.math.abs
 import kotlin.math.roundToInt
 import kotlin.math.roundToLong
 import kotlin.time.Duration.Companion.milliseconds
+import kotlinx.coroutines.async
 import kotlinx.coroutines.launch
 
 data class DevToolsDevice(
@@ -894,6 +895,12 @@ private fun DevToolsStage(
   RunOnRequestChange(saveScreenshotRequest) { saveCurrentDevToolsScreenshot(screenshotLayer) }
   RunOnRequestChange(copyScreenshotRequest) { copyCurrentDevToolsScreenshot(screenshotLayer) }
 
+  LaunchedEffect(screenshotLayer) {
+    registerDevToolsScreenshotProvider {
+      coroutineScope.async { screenshotLayer.toImageBitmap() }.await()
+    }
+  }
+
   LaunchedEffect(device.id, device.canRotate, orientation) {
     suspend fun animateFrameRotationTo(
         targetRotation: Float,

devtools/runtime/src/commonMain/kotlin/com/composables/devtools/DevToolsScreenshot.kt

@@ -26,3 +26,5 @@ import androidx.compose.ui.graphics.ImageBitmap
 expect fun saveDevToolsScreenshot(image: ImageBitmap)
 
 expect fun copyDevToolsScreenshotToClipboard(image: ImageBitmap)
+
+expect fun registerDevToolsScreenshotProvider(provider: (suspend () -> ImageBitmap)?)

devtools/runtime/src/jvmMain/kotlin/com/composables/devtools/DevToolsAutomationServer.jvm.kt

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2026 Composable Horizons
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.composables.devtools
+
+import com.sun.net.httpserver.HttpExchange
+import com.sun.net.httpserver.HttpServer
+import java.io.File
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.util.concurrent.Executors
+
+private var devToolsAutomationServer: HttpServer? = null
+
+fun startDevToolsAutomationServer(
+    portFile: File = defaultDevToolsAutomationPortFile(),
+) {
+  if (devToolsAutomationServer != null) return
+
+  val server = HttpServer.create(InetSocketAddress(InetAddress.getLoopbackAddress(), 0), 0)
+  server.createContext("/status") { exchange ->
+    exchange.respondText("""{"ready":${captureDevToolsScreenshotPng() != null}}""")
+  }
+  server.createContext("/screenshot") { exchange ->
+    val screenshot = captureDevToolsScreenshotPng()
+    if (screenshot == null) {
+      exchange.respondText("""{"error":"screenshot_not_ready"}""", code = 409)
+    } else {
+      exchange.responseHeaders.add("Content-Type", "image/png")
+      exchange.sendResponseHeaders(200, screenshot.size.toLong())
+      exchange.responseBody.use { it.write(screenshot) }
+    }
+  }
+  server.executor =
+      Executors.newSingleThreadExecutor { runnable ->
+        Thread(runnable, "Composables DevTools Automation").apply { isDaemon = true }
+      }
+  server.start()
+
+  portFile.parentFile?.mkdirs()
+  portFile.writeText("${server.address.port}\n")
+  devToolsAutomationServer = server
+}
+
+internal fun defaultDevToolsAutomationPortFile(): File {
+  val configuredPath = System.getProperty("composables.devtools.portFile")
+  return if (configuredPath.isNullOrBlank()) {
+    File(System.getProperty("java.io.tmpdir"), "composables-devtools.port")
+  } else {
+    File(configuredPath)
+  }
+}
+
+private fun HttpExchange.respondText(text: String, code: Int = 200) {
+  val bytes = text.toByteArray(Charsets.UTF_8)
+  responseHeaders.add("Content-Type", "application/json; charset=utf-8")
+  sendResponseHeaders(code, bytes.size.toLong())
+  responseBody.use { it.write(bytes) }
+}