Generated banner for Compose UI Control
Generated logo for Compose UI Control

Compose UI Control

JetBrainsOfficialCreated by ForketyforkDistributed by JetBrains

  • Skill
  • Tool integration
  • Software development
  • MIT
  • Low risk
  • Has scripts

From the author

Control a running Compose Desktop application via HTTP. Use when you need to interact with UI elements, click buttons, enter text, wait for elements to appear, or capture screenshots in a Compose Desktop app that has compose-ui-test-server enabled.
— the description by Forketyfork

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

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/jetbrains/compose-ui-control/download
  2. Unzip 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.

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-server

  • Imports 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 run

Verifying the Server

Always check health first:

curl http://localhost:54345/health
# Expected: "OK"

Available Endpoints

EndpointDescription
GET /healthHealth check
GET /onNodeWithTag/{tag}/performClickClick element by test tag
GET /onNodeWithTag/{tag}/performTextInput?text=...Enter text (URL-encode the text!)
GET /onNodeWithText/{text}/performClickClick element by display text
GET /waitUntilExactlyOneExists/tag/{tag}?timeout=5000Wait for element by tag
GET /waitUntilExactlyOneExists/text/{text}?exact=true&timeout=5000Wait for element by text
GET /waitForIdleWait for UI to stabilize
GET /captureScreenshot?path=screenshot.pngCapture 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.md for documented test tags

  • Test files in src/*Test/ directories

Important Notes

  • Always URL-encode special characters in text: space→%20, @→%40, &→%26

  • Use waitForIdle between operations for stability

  • Check 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:

  1. Check the element exists (search for its test tag in code)

  2. Ensure UI has finished loading (waitForIdle)

  3. Verify the server is still running (/health)

  4. Try with a longer timeout for wait operations

Files

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