Flocon Desktop mock mode

--mock=<scenario> starts Flocon Desktop with fake connected devices and pre-filled data. The data goes through the real handlers, Room and UI, exactly like a real SDK would send it. Timestamps are relative to the launch time, so the screens always look recent.

Covered plugins: network, timeline, crash reporter, analytics, feature flags (+ devices/apps). Not covered: database, files, shared preferences, images, dashboards… use the sample app for those.

Launch

From FloconDesktop/, with JDK 21:

export JAVA_HOME=$(/usr/libexec/java_home -v 21)
./gradlew :composeApp:run --args="--mock=default"

• --mock=list (or --mock) prints the scenarios and exits.
• An unknown name exits with the list of available names.
• Run it in the background: the app blocks until its window is closed. It is ready when the MCP port answers: lsof -nP -iTCP:9042 -sTCP:LISTEN.
• Each mock launch wipes and reuses ~/.flocon/mock/flocon_room.db: the same scenario always gives the same screens. The real database (~/.flocon/flocon_room.db) is never touched.
• adb and the iOS simulator are disabled in mock mode (no command reaches a real phone).

Limits

• The MCP server listens on the usual port 9042: close the real Flocon Desktop first, or the mock one can't start its MCP server and your MCP calls reach the real app.
• Settings (theme, app scale, hidden menus, columns…) are the user's real settings, shared with the normal app.
• Commands sent by the desktop to the device (network mocks, bad network, toggling a flag…) are accepted and ignored.

Scenarios

Code: FloconDesktop/data/remote/src/commonMain/kotlin/com/flocon/data/remote/mock/ (scenarios/Scenarios.kt and the shared scenarios/SampleData.kt).

Take screenshots / check the data

With the mock app running, use its MCP server (http://localhost:9042/mcp, the flocon MCP tools if connected):

• flocon_navigate_into_desktop_app with screen (network, timeline, analytics, feature_flags, crash_reporter…) to show a screen.
• take_flocon_desktop_screenshot returns a PNG of the window.
• list_devices, list_network_calls, get_timeline, list_crash_reports, list_analytics_events, list_feature_flags to check the data.

Without the MCP tools connected, call them with curl (stateless JSON-RPC):

curl -s -H 'Content-Type: application/json' -H 'Accept: application/json, text/event-stream' \
  http://localhost:9042/mcp \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"take_flocon_desktop_screenshot","arguments":{}}}'

The image is base64 in result.content[].data.

Write a new scenario

Scenarios are Kotlin, compiled with the app, and committed with the change they test.

1. Add a file in mock/scenarios/ (or extend Scenarios.kt):

internal val checkoutErrorsScenario = scenario("checkout-errors", description = "Checkout failing in every way") {
    android("Pixel 8", app = SAMPLE_APP, packageName = SAMPLE_PACKAGE) {
        network(5.minutes.ago, "POST", "https://api.example.com/checkout", status = 500, duration = 1.seconds) {
            requestHeader("content-type", "application/json")
            requestBody("""{"cartId":"c-1"}""")
            responseBody("""{"error":"internal_error"}""")
        }
        network(4.minutes.ago, "POST", "https://api.example.com/checkout", error = "java.net.SocketTimeoutException: timeout")
        network(3.minutes.ago, "GET", "https://api.example.com/slow", pending = true)
        repeat(100) { network((200 - it).seconds.ago, "GET", "https://api.example.com/items/$it") }
        timeline(6.minutes.ago, "CheckoutScreen", type = "navigation", level = null)
        timeline(3.minutes.ago, "Checkout failed", type = "billing", level = "error", params = mapOf("code" to "500"))
        crash(2.minutes.ago, exceptionType = "java.lang.IllegalStateException", message = "boom", stackTrace = "at a.b(C.kt:1)")
        analytics(1.minutes.ago, "checkout_error", "code" to "500", tableId = "analytics")
        featureFlags("firebase") { flag("checkout_v2", state = "custom", variant = "treatment", payload = "{}") }
        raw(30.seconds.ago, plugin = "network", method = "log_network_call_request", body = "{not json")
    }
    ios("iPhone 16", app = "Shop", packageName = "com.example.shop", appStartedAt = 10.minutes.ago, sdkVersion = "1.0.0") { }
}

2. Add it to MockScenarios.all (mock/MockScenarios.kt).
3. ./gradlew :data:remote:desktopTest --tests "*MockScenariosTest" (update the expected name list there), then launch it.

DSL notes:

• at is the time before launch (5.minutes.ago).
• appStartedAt is when the app started (default: 1 s before its first event); the timeline session starts there.
• sdkVersion is the Flocon SDK version on the device (default: the desktop version, so no "SDK out of date" banner).
• raw(plugin, method, body) sends any message as is, to test what a real SDK would not send.
• Timeline types navigation, userAction, lifecycle have their own icon; use level = null for them.