Compose UI Control
JetBrainsOfficialCreated by ForketyforkDistributed by JetBrains
- Skill
- Tool integration
- Software development
- MIT
- Low risk
- Has scripts
AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
The compose-ui-control skill provides a mechanism to interact with running Compose Desktop applications through an HTTP server. By integrating the library into a project, developers can enable an agent to perform UI operations such as clicking buttons, entering text, waiting for specific elements, and capturing screenshots. This allows for programmatic control of the application interface, facilitating automated testing or remote interaction workflows.
What it does
- Enables HTTP-based control of Compose Desktop applications
- Allows clicking UI elements via test tags or display text
- Supports text input into fields with URL-encoded values
- Provides synchronization primitives like waiting for elements or UI idle states
- Captures screenshots of the application window
- Integrates into existing Gradle-based Compose projects
When to use it
- When you need to automate interactions with a Compose Desktop application
- When building test suites that require runtime UI manipulation
- When an AI agent needs to verify application state through visual or structural checks
- When you need to drive an application's UI from an external script or agent
Advantages
- Decouples UI interaction from the application's internal code
- Uses standard HTTP requests for broad compatibility
- Supports stable testing patterns with wait-for-idle and timeout mechanisms
- Easy to integrate into existing Compose Desktop projects
Usage examples
- “Click the login button in my Compose Desktop app.”
- The agent sends a GET request to /onNodeWithTag/login_button/performClick to trigger the button action.
- “Enter 'admin' into the username field.”
- The agent sends a GET request to /onNodeWithTag/username_field/performTextInput?text=admin to populate the text field.
- “Wait for the dashboard to load and take a screenshot.”
- The agent calls /waitUntilExactlyOneExists/tag/dashboard?timeout=10000 followed by /captureScreenshot?path=dashboard.png.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/jetbrains/compose-ui-control/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip compose-ui-control.zip -d .agents/skills
Documentation by Forketyfork
compose-ui-test-server
A library that enables AI coding agents to control Compose Desktop applications at runtime via HTTP.
Repository: https://github.com/forketyfork/compose-ui-test-server
Maven Central:
io.github.forketyfork:compose-ui-test-serverCurrent version: 0.2.0
Checking If Already Installed
Before setting up, check if the project already has the library:
grep -r "compose-ui-test-server\|composeuittest" --include="*.gradle*" --include="*.kt" .Look for:
Dependency on
io.github.forketyfork:compose-ui-test-serverImports from
io.github.forketyfork.composeuittest
If found, skip to Starting the Application.
Installing in a Compose Desktop Project
Step 1: Add the dependency
Find the app's build.gradle.kts and locate the desktop source set dependencies. Add compose-ui-test-server and compose.uiTest:
kotlin {
sourceSets {
val desktopMain by getting {
dependencies {
// Existing dependencies...
// Add these two:
implementation("io.github.forketyfork:compose-ui-test-server:0.2.0")
@OptIn(org.jetbrains.compose.ExperimentalComposeLibrary::class)
implementation(compose.uiTest)
}
}
}
}For projects using version catalogs, add to gradle/libs.versions.toml:
[libraries]
compose-ui-test-server = { module = "io.github.forketyfork:compose-ui-test-server", version = "0.2.0" }Then reference in build.gradle.kts:
implementation(libs.compose.ui.test.server)Step 2: Update the main function
Find the application's main() function (usually in Main.kt or similar). Replace the standard Compose Desktop launcher with runApplication:
Before (typical Compose Desktop main):
import androidx.compose.ui.window.Window
import androidx.compose.ui.window.application
fun main() = application {
Window(onCloseRequest = ::exitApplication, title = "My App") {
App()
}
}After (with agent control support):
import io.github.forketyfork.composeuittest.WindowConfig
import io.github.forketyfork.composeuittest.runApplication
fun main() =
runApplication(
windowConfig = WindowConfig(
title = "My App",
minimumWidth = 1024,
minimumHeight = 768,
),
) {
App()
}The app now runs normally by default, but supports agent control when launched with COMPOSE_UI_TEST_SERVER_ENABLED=true.
Step 3: Add test tags to UI elements
For agents to interact with specific UI elements, add test tags:
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.testTag
Button(
onClick = { /* ... */ },
modifier = Modifier.testTag("login_button")
) {
Text("Login")
}
TextField(
value = username,
onValueChange = { username = it },
modifier = Modifier.testTag("username_field")
)Starting the Application
# Normal mode (no server)
./gradlew run
# Agent-controlled mode (server enabled)
COMPOSE_UI_TEST_SERVER_ENABLED=true ./gradlew run
# With custom port (default is 54345)
COMPOSE_UI_TEST_SERVER_ENABLED=true COMPOSE_UI_TEST_SERVER_PORT=8080 ./gradlew runVerifying the Server
Always check health first:
curl http://localhost:54345/health
# Expected: "OK"Available Endpoints
| Endpoint | Description |
|---|---|
GET /health | Health check |
GET /onNodeWithTag/{tag}/performClick | Click element by test tag |
GET /onNodeWithTag/{tag}/performTextInput?text=... | Enter text (URL-encode the text!) |
GET /onNodeWithText/{text}/performClick | Click element by display text |
GET /waitUntilExactlyOneExists/tag/{tag}?timeout=5000 | Wait for element by tag |
GET /waitUntilExactlyOneExists/text/{text}?exact=true&timeout=5000 | Wait for element by text |
GET /waitForIdle | Wait for UI to stabilize |
GET /captureScreenshot?path=screenshot.png | Capture screenshot |
Workflow Pattern
Follow this sequence for reliable interactions:
# 1. Verify server is running
curl http://localhost:54345/health
# 2. Wait for UI to be ready
curl http://localhost:54345/waitForIdle
# 3. Perform action
curl "http://localhost:54345/onNodeWithTag/username/performTextInput?text=myuser"
# 4. Wait for UI to settle
curl http://localhost:54345/waitForIdle
# 5. Perform next action
curl http://localhost:54345/onNodeWithTag/login_button/performClick
# 6. Wait for result
curl "http://localhost:54345/waitUntilExactlyOneExists/tag/dashboard?timeout=10000"
# 7. Capture screenshot to verify
curl "http://localhost:54345/captureScreenshot?path=result.png"Finding Test Tags
Search the codebase for existing test tags:
grep -r "testTag\|Modifier.testTag" --include="*.kt" .Also check:
CLAUDE.mdfor documented test tagsTest files in
src/*Test/directories
Important Notes
Always URL-encode special characters in text: space→
%20,@→%40,&→%26Use
waitForIdlebetween operations for stabilityCheck HTTP status codes: 200=success, 400=bad request, 500=error
Use appropriate timeouts for waits (default 5000ms may be too short)
Screenshots require absolute paths
Error Handling
If an endpoint returns an error:
Check the element exists (search for its test tag in code)
Ensure UI has finished loading (
waitForIdle)Verify the server is still running (
/health)Try with a longer timeout for wait operations
Files
- .github/dependabot.yml342 B
- .github/workflows/build.yml646 B
- .github/workflows/junie.yml472 B
- .github/workflows/release.yml1.6 KiB
- .gitignore343 B
- ATTRIBUTION.mdAdded by AutoGineer941 B
- CLAUDE.md2.9 KiB
- LICENSE1.0 KiB
- README.md8.4 KiB
- SKILL.md6.0 KiB
- build.gradle.kts2.3 KiB
- docs/PUBLICATION.md6.0 KiB
- gradle/libs.versions.toml909 B
- gradle/wrapper/gradle-wrapper.properties252 B
- gradlewScript8.4 KiB
- gradlew.batScript2.7 KiB
- settings.gradle.kts145 B
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/ApplicationLauncher.ktScript2.7 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/ComposeUiTestServer.ktScript4.5 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/ComposeUiTestServerConfig.ktScript1.2 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/Extensions.ktScript3.1 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/TestEndpoint.ktScript1.2 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/endpoint/ClickEndpoints.ktScript2.0 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/endpoint/HealthEndpoint.ktScript611 B
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/endpoint/ScreenshotEndpoint.ktScript1.9 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/endpoint/TextInputEndpoint.ktScript1.6 KiB
- src/jvmMain/kotlin/io/github/forketyfork/composeuittest/endpoint/WaitEndpoints.ktScript3.2 KiB
Requirements and compatibility
Written for: Claude Code
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Claude Code frontmatter, Needs network access
Security
What our scanner noticed· Low risk
- Instructions that use the network
- Scripts that your agent may run
This skill includes scripts that your agent may run. Read them before you use it.
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Created by
- Forketyfork
- Publisher
- JetBrains (Official)
- Distributed by
- JetBrains
- Source
- JetBrains/skills · compose-ui-test-server · commit 3f53782
- Licence
- MIT License (redistribution allowed)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Forketyfork or JetBrains.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download compose-ui-control.zip