diff --git a/.gitignore b/.gitignore
index 090a6598..f13cd4ab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,20 @@ dist/
release-bin/
/.pipelines-releases.json
/.pipelines-releases-*
+
+# Android client: ignore Gradle build outputs and local configuration, but keep
+# the Kotlin sources. The negation is required because the runtime `data/` rule
+# above would otherwise exclude the app's net.awan.pipelines.data package.
+android/.gradle/
+android/.kotlin/
+android/local.properties
+android/**/build/
+android/captures/
+android/.idea/
+android/*.iml
+android/**/*.apk
+android/**/*.aab
+android/**/*.jks
+android/**/*.keystore
+!android/**/data/
+
diff --git a/android/README.md b/android/README.md
new file mode 100644
index 00000000..7e1f27d9
--- /dev/null
+++ b/android/README.md
@@ -0,0 +1,125 @@
+# Pipelines Android client
+
+A native Android (Kotlin + Jetpack Compose Material 3) client for an existing
+Pipelines server. All execution, model credentials, definitions and run history
+stay on the server; the app only speaks the existing WebSocket protocol.
+
+## Scope and safety
+
+- **Trusted LAN/VPN only.** The Pipelines API has **no authentication** and is
+ **not internet-safe**. Do not expose the server to untrusted networks.
+- **No secrets.** The app stores no credentials, tokens or provider keys and
+ sends no auth headers. Only the server URL and workspace path are persisted as
+ plain, non-secret preferences.
+- **No hardcoded server.** The server URL and workspace path must be entered
+ explicitly by the user; there is no default/disposable address baked in.
+- The app does **not** run Docker, execute stages, or reimplement any Go
+ parsing/execution logic. `android/` contains only the client.
+
+## Requirements
+
+- JDK 17 (see `compileOptions` / `kotlinOptions.jvmTarget`).
+- Android SDK with a platform and build-tools matching `compileSdk = 35`
+ (`app/build.gradle.kts`), and `ANDROID_HOME`/`ANDROID_SDK_ROOT` set.
+- Gradle 8.9+ (AGP 8.7.2, Kotlin 2.0.21).
+
+The version numbers above are deliberate defaults chosen without a discovered
+SDK; adjust `compileSdk`, `targetSdk`, and the versions in
+`gradle/libs.versions.toml` to whatever is actually installed. If a required
+SDK/Gradle component is missing, fix the environment rather than downloading
+untracked artifacts.
+
+### Gradle wrapper
+
+`gradle/wrapper/gradle-wrapper.jar` is a generated binary and is intentionally
+**not committed**. Generate a working wrapper on a machine with Gradle installed:
+
+```sh
+cd android
+gradle wrapper --gradle-version 8.9
+```
+
+Until then, build with a locally installed Gradle:
+
+```sh
+cd android
+gradle :app:assembleDebug
+```
+
+## Build, test and install
+
+```sh
+cd android
+gradle :app:testDebugUnitTest # protocol/URL/graph unit tests
+gradle :app:assembleDebug # debug APK
+gradle :app:lintDebug # Android lint
+# install on a connected device/emulator:
+gradle :app:installDebug
+adb shell am start -n net.awan.pipelines/.MainActivity
+```
+
+## Configuration
+
+Open the **Settings** tab and enter:
+
+- **Server URL** — `ws://HOST:PORT/connect` (LAN/VPN) or `wss://…/connect`
+ (proxy/VPN). A path is optional and defaults to `/connect`, matching the Go
+ server's `GET /connect`. `http(s)`, userinfo and fragments are rejected with a
+ specific message.
+- **Workspace path** — an **absolute directory that already exists on the
+ execution server**. This is *not* the phone's storage. For Docker, mount the
+ host directory at the same absolute path with the owner's UID/GID so the
+ server can resolve it (see `docs/docker.md` and `compose.yaml`). The field
+ flags a non-absolute path and will not save it, mirroring the repository's
+ start-run guard.
+
+Tap **Connect** to open the single shared WebSocket (probed with `ping`, showing
+the server build). Reconnect uses bounded exponential backoff; **Disconnect**
+stops it.
+
+## Features
+
+- Pipeline list (search/refresh, empty/error/loading states), pipeline details
+ (version list, content hash, source) and the workflow graph.
+- Workflow graph composable: content-sized nodes, labelled outcome edges
+ (`error*` marks the implicit fallback), `#success`/`#failure` terminals, loops
+ and branches, pan/zoom, and run highlighting (executed routes highlighted,
+ others dimmed) plus a screen-reader description.
+- Run history with server `usage` aggregates, and run details with steps
+ (status/outcome/diagnostic/session/transcript/file changes/notifications/
+ control evidence). Session evidence is scoped to the selected run and each
+ record is rendered (sequence/session id/backend/directory/data/diagnostic) on
+ demand via `get_run_evidence`; it is never part of the 1s poll.
+- A shared connection banner above every screen surfaces a distinct
+ Idle/Connecting/Disconnected state with a Reconnect action (and stays hidden
+ while connected), so a dropped connection is not just a generic request error.
+- Start run (confirmation dialog; sends `PipelineID`, `Version`, a reused
+ `request_key` ≤128 chars, the configured absolute workspace and `input.prompt`)
+ and cancel run (confirmation; sends the `RunID`, then refreshes). Retry is
+ offered only for terminal failed runs.
+- A run being polled at a fixed 1s interval is stopped as soon as it is no
+ longer executing.
+
+## Architecture
+
+```
+data/protocol kotlinx.serialization models mirroring internal/protocol/*
+ (Message, Graph/Stage, RunDetail/RunStep, UsageStats, …) plus
+ GraphSemantics reproducing internal/tui/graph.go rules.
+data/transport ServerUrl validation (mirrors internal/client/config.go) and
+ PipelinesClient — one reused WebSocket, serialized requests,
+ client ids matched against replies, unsolicited envelopes
+ dropped, bounded reconnect backoff.
+data SettingsRepository (non-secret prefs) and PipelinesRepository
+ (typed request builders + per-session graph/detail cache).
+ui Compose Material 3 screens, one AppViewModel, navigation.
+```
+
+## Verification status
+
+The project sources, protocol model and unit tests are present, but **no build,
+lint, unit test or emulator run has been performed here**: this stage has no
+command-execution tool, and no JDK/Gradle/Android SDK was discoverable in the
+environment. The exact commands to run are listed above; run them on a machine
+with the toolchain and capture the real results. Do not treat this file as
+evidence of a successful build.
diff --git a/android/app/build.gradle.kts b/android/app/build.gradle.kts
new file mode 100644
index 00000000..4b89f8dc
--- /dev/null
+++ b/android/app/build.gradle.kts
@@ -0,0 +1,69 @@
+plugins {
+ alias(libs.plugins.android.application)
+ alias(libs.plugins.kotlin.android)
+ alias(libs.plugins.kotlin.compose)
+ alias(libs.plugins.kotlin.serialization)
+}
+
+android {
+ namespace = "net.awan.pipelines"
+ // Version numbers follow what the build environment provides; adjust to the
+ // installed SDK/build-tools if the release/target differs. See android/README.md.
+ compileSdk = 35
+
+ defaultConfig {
+ applicationId = "net.awan.pipelines"
+ minSdk = 26
+ targetSdk = 35
+ versionCode = 1
+ versionName = "0.1.0"
+ vectorDrawables { useSupportLibrary = true }
+ }
+
+ buildTypes {
+ release {
+ isMinifyEnabled = false
+ proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+ }
+ }
+
+ compileOptions {
+ sourceCompatibility = JavaVersion.VERSION_17
+ targetCompatibility = JavaVersion.VERSION_17
+ }
+
+ kotlinOptions {
+ jvmTarget = "17"
+ }
+
+ buildFeatures {
+ compose = true
+ }
+
+ packaging {
+ resources {
+ excludes += "/META-INF/{AL2.0,LGPL2.1}"
+ }
+ }
+}
+
+dependencies {
+ implementation(libs.androidx.core.ktx)
+ implementation(libs.androidx.activity.compose)
+ implementation(platform(libs.androidx.compose.bom))
+ implementation(libs.androidx.compose.ui)
+ implementation(libs.androidx.compose.ui.graphics)
+ implementation(libs.androidx.compose.ui.tooling.preview)
+ implementation(libs.androidx.compose.material3)
+ implementation(libs.androidx.compose.material.icons.extended)
+ implementation(libs.androidx.navigation.compose)
+ implementation(libs.androidx.lifecycle.runtime.compose)
+ implementation(libs.androidx.lifecycle.viewmodel.compose)
+ implementation(libs.androidx.lifecycle.viewmodel.ktx)
+ implementation(libs.kotlinx.coroutines.android)
+ implementation(libs.kotlinx.serialization.json)
+ implementation(libs.okhttp)
+
+ testImplementation(libs.junit)
+ debugImplementation(libs.androidx.compose.ui.tooling)
+}
diff --git a/android/app/proguard-rules.pro b/android/app/proguard-rules.pro
new file mode 100644
index 00000000..477726d6
--- /dev/null
+++ b/android/app/proguard-rules.pro
@@ -0,0 +1,11 @@
+# Default ProGuard/R8 rules. The app keeps kotlinx.serialization models used by the
+# Pipelines protocol, which are otherwise pruned when minification is enabled.
+-keepattributes *Annotation*, InnerClasses
+-dontnote kotlinx.serialization.**
+
+-keepclassmembers class net.awan.pipelines.data.protocol.** {
+ *** Companion;
+}
+-keepclasseswithmembers class net.awan.pipelines.data.protocol.** {
+ kotlinx.serialization.KSerializer serializer(...);
+}
diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..5b9ad4e3
--- /dev/null
+++ b/android/app/src/main/AndroidManifest.xml
@@ -0,0 +1,32 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/android/app/src/main/java/net/awan/pipelines/MainActivity.kt b/android/app/src/main/java/net/awan/pipelines/MainActivity.kt
new file mode 100644
index 00000000..8f61c8ce
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/MainActivity.kt
@@ -0,0 +1,24 @@
+package net.awan.pipelines
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.lifecycle.viewmodel.compose.viewModel
+import net.awan.pipelines.ui.AppViewModel
+import net.awan.pipelines.ui.PipelinesApp
+import net.awan.pipelines.ui.theme.PipelinesTheme
+
+class MainActivity : ComponentActivity() {
+ override fun onCreate(savedInstanceState: Bundle?) {
+ super.onCreate(savedInstanceState)
+ enableEdgeToEdge()
+ val app = application as PipelinesApplication
+ setContent {
+ PipelinesTheme {
+ val vm: AppViewModel = viewModel(factory = AppViewModel.factory(app))
+ PipelinesApp(vm)
+ }
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/PipelinesApplication.kt b/android/app/src/main/java/net/awan/pipelines/PipelinesApplication.kt
new file mode 100644
index 00000000..ffc183d2
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/PipelinesApplication.kt
@@ -0,0 +1,24 @@
+package net.awan.pipelines
+
+import android.app.Application
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import net.awan.pipelines.data.PipelinesRepository
+import net.awan.pipelines.data.SettingsRepository
+import net.awan.pipelines.data.transport.PipelinesClient
+
+/**
+ * Holds the single long-lived repository, WebSocket client and application
+ * scope. There is intentionally no dependency-injection framework here.
+ */
+class PipelinesApplication : Application() {
+
+ private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+ val settings: SettingsRepository by lazy { SettingsRepository(this) }
+
+ val client: PipelinesClient by lazy { PipelinesClient(scope = applicationScope) }
+
+ val repository: PipelinesRepository by lazy { PipelinesRepository(client, settings) }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/data/ErrorMessages.kt b/android/app/src/main/java/net/awan/pipelines/data/ErrorMessages.kt
new file mode 100644
index 00000000..c0a97179
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/ErrorMessages.kt
@@ -0,0 +1,23 @@
+package net.awan.pipelines.data
+
+import java.io.IOException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import net.awan.pipelines.data.transport.NotConnectedException
+import net.awan.pipelines.data.transport.ProtocolException
+
+/**
+ * Turns transport failures into distinct, non-technical messages. The server
+ * error text is surfaced verbatim because it is actionable (bad workspace,
+ * missing prompt, active run).
+ */
+object ErrorMessages {
+ fun describe(t: Throwable): String = when (t) {
+ is ProtocolException -> t.message ?: "The server rejected the request."
+ is NotConnectedException -> "Not connected. Check the server URL, then reconnect."
+ is UnknownHostException -> "Server not found. Check the host name and that you are on the trusted LAN/VPN."
+ is SocketTimeoutException -> "The server did not respond in time. Check the connection and retry."
+ is IOException -> "Network error: ${t.message ?: "connection failed"}. Reconnect and retry."
+ else -> t.message?.takeIf { it.isNotBlank() } ?: "Unexpected error: ${t.javaClass.simpleName}"
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt
new file mode 100644
index 00000000..088261ef
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt
@@ -0,0 +1,136 @@
+package net.awan.pipelines.data
+
+import java.util.UUID
+import java.util.concurrent.ConcurrentHashMap
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.JsonElement
+import net.awan.pipelines.data.protocol.Message
+import net.awan.pipelines.data.protocol.PipelineDetail
+import net.awan.pipelines.data.protocol.PipelineSummary
+import net.awan.pipelines.data.protocol.Protocol
+import net.awan.pipelines.data.protocol.RunDetail
+import net.awan.pipelines.data.protocol.RunSummary
+import net.awan.pipelines.data.protocol.SessionEvidence
+import net.awan.pipelines.data.protocol.UsageStats
+import net.awan.pipelines.data.transport.NotConnectedException
+import net.awan.pipelines.data.transport.PipelinesClient
+import net.awan.pipelines.data.transport.ProtocolException
+import net.awan.pipelines.data.transport.ServerUrl
+
+/** Run history plus the server's aggregate usage statistics. */
+data class RunHistory(val runs: List, val usage: UsageStats?)
+
+/**
+ * Typed access to the existing WebSocket protocol. Request builders and ID
+ * matching live here so screens never construct frames by hand or invent
+ * divergent field names. Pipeline details/graphs are cached per session.
+ */
+class PipelinesRepository(
+ private val client: PipelinesClient,
+ private val settings: SettingsRepository,
+) {
+ val connectionState = client.state
+
+ /** Opens the single shared connection to a validated server URL. */
+ fun connect(validated: ServerUrl.Validated) = client.connect(validated)
+
+ /** Explicit disconnect; the client then stays Idle. */
+ fun disconnect() = client.disconnect()
+
+ private data class CacheKey(val id: Long, val version: Int)
+
+ private val detailCache = ConcurrentHashMap()
+
+ fun clearCache() = detailCache.clear()
+
+ suspend fun ping(): Message = client.call(Message(type = Protocol.PING))
+
+ suspend fun listPipelines(): List =
+ client.call(Message(type = Protocol.LIST)).pipelines ?: emptyList()
+
+ suspend fun getPipeline(id: Long, version: Int): PipelineDetail {
+ val key = CacheKey(id, version)
+ detailCache[key]?.let { return it }
+ val response = client.call(
+ Message(type = Protocol.GET_PIPELINE, pipelineId = id, version = version),
+ )
+ val detail = response.detail
+ ?: throw ProtocolException("The server returned no pipeline detail.")
+ if (detail.version > 0) detailCache[key] = detail
+ return detail
+ }
+
+ suspend fun listRuns(): RunHistory {
+ val response = client.call(Message(type = Protocol.LIST_RUNS))
+ return RunHistory(response.runs ?: emptyList(), response.usage)
+ }
+
+ suspend fun getRun(id: Long): RunDetail = client.call(
+ Message(type = Protocol.GET_RUN, runId = id),
+ ).runDetail ?: throw ProtocolException("The server returned no run detail.")
+
+ suspend fun getRunEvidence(id: Long): List =
+ client.call(Message(type = Protocol.GET_RUN_EVIDENCE, runId = id)).evidence ?: emptyList()
+
+ suspend fun startRun(
+ pipelineId: Long,
+ version: Int,
+ prompt: String,
+ requestKey: String,
+ ): RunDetail {
+ requireConfigured()
+ if (pipelineId <= 0) throw ProtocolException("Select a pipeline to run.")
+ if (version <= 0) throw ProtocolException("An explicit pipeline version is required.")
+ if (requestKey.isBlank() || requestKey.length > MAX_REQUEST_KEY) {
+ throw ProtocolException("A run request key of at most $MAX_REQUEST_KEY characters is required.")
+ }
+ if (prompt.trim().isEmpty()) throw ProtocolException("Enter a non-empty prompt before starting a run.")
+ val workspace = settings.workspace.value
+ if (!workspace.startsWith("/")) {
+ throw ProtocolException("Set an absolute workspace path that exists on the execution server.")
+ }
+ val input: Map = mapOf("prompt" to JsonPrimitive(prompt.trim()))
+ val response = client.call(
+ Message(
+ type = Protocol.RUN_PIPELINE,
+ pipelineId = pipelineId,
+ version = version,
+ requestKey = requestKey,
+ workspace = workspace,
+ input = input,
+ ),
+ )
+ return response.runDetail ?: throw ProtocolException("The server returned no run detail.")
+ }
+
+ suspend fun cancelRun(id: Long): RunDetail = client.call(
+ Message(type = Protocol.CANCEL_RUN, runId = id),
+ ).runDetail ?: throw ProtocolException("The server returned no run detail.")
+
+ /**
+ * Retry is only offered for terminal failed runs; the server enforces this
+ * too. The caller supplies a new request key so the retry is its own run.
+ */
+ suspend fun retryRun(id: Long, requestKey: String): RunDetail = client.call(
+ Message(type = Protocol.RETRY_RUN, runId = id, requestKey = requestKey),
+ ).runDetail ?: throw ProtocolException("The server returned no run detail.")
+
+ private fun requireConfigured() {
+ if (settings.serverUrl.value.isBlank()) {
+ throw NotConnectedException("Set the Pipelines server URL in Settings first.")
+ }
+ if (settings.workspace.value.isBlank()) {
+ throw ProtocolException("Set the workspace path in Settings first.")
+ }
+ }
+
+ companion object {
+ const val MAX_REQUEST_KEY = 128
+
+ /**
+ * A stable per-start request key (<=128 chars). Reuse it across retries of
+ * the same start intent so the server can dedupe idempotent repeats.
+ */
+ fun newRequestKey(): String = "android-" + UUID.randomUUID().toString()
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt
new file mode 100644
index 00000000..f29a9c8e
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt
@@ -0,0 +1,43 @@
+package net.awan.pipelines.data
+
+import android.content.Context
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Persists the explicitly configured server URL and workspace path as plain,
+ * non-secret preferences. No credentials or tokens are ever stored, because the
+ * server has no authentication.
+ */
+class SettingsRepository(context: Context) {
+
+ private val prefs = context.applicationContext
+ .getSharedPreferences("pipelines_settings", Context.MODE_PRIVATE)
+
+ private val _serverUrl = MutableStateFlow(prefs.getString(KEY_SERVER_URL, "").orEmpty())
+ val serverUrl: StateFlow = _serverUrl.asStateFlow()
+
+ private val _workspace = MutableStateFlow(prefs.getString(KEY_WORKSPACE, "").orEmpty())
+ val workspace: StateFlow = _workspace.asStateFlow()
+
+ fun setServerUrl(value: String) {
+ val trimmed = value.trim()
+ _serverUrl.value = trimmed
+ prefs.edit().putString(KEY_SERVER_URL, trimmed).apply()
+ }
+
+ fun setWorkspace(value: String) {
+ val trimmed = value.trim()
+ _workspace.value = trimmed
+ prefs.edit().putString(KEY_WORKSPACE, trimmed).apply()
+ }
+
+ /** True only when the user has explicitly supplied both required values. */
+ fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank()
+
+ private companion object {
+ const val KEY_SERVER_URL = "server_url"
+ const val KEY_WORKSPACE = "workspace"
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt
new file mode 100644
index 00000000..6e09e422
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/GraphSemantics.kt
@@ -0,0 +1,97 @@
+package net.awan.pipelines.data.protocol
+
+/**
+ * Shared graph semantics reproduced from internal/tui/graph.go. Keeping the
+ * outcome ordering, fallback-label and compact thresholds here means the UI has a
+ * single source of truth and cannot diverge between the pipeline and run screens.
+ */
+object GraphSemantics {
+
+ /** Same ordering as tui.outcomes: success first, error last, others alphabetical. */
+ fun outcomes(stage: Stage): List = stage.edges.keys.sortedWith(
+ compareBy({ priority(it) }, { it }),
+ )
+
+ private fun priority(outcome: String): Int = when (outcome) {
+ "success" -> 0
+ "error" -> 2
+ else -> 1
+ }
+
+ /** Mirrors tui.compactGraph: oversized graphs use a reduced-detail layout. */
+ fun compactGraph(graph: Graph): Boolean {
+ var edges = 0
+ for (stage in graph.stages) edges += stage.edges.size
+ return graph.stages.size > 200 || edges > 500
+ }
+
+ fun nodeLabel(key: String): String = when (key) {
+ Protocol.SUCCESS_END -> "SUCCESS"
+ Protocol.FAILURE_END -> "FAILURE"
+ else -> key
+ }
+
+ /**
+ * The outcome label shown on an edge. Matches tui.graphEdges: the implicit
+ * fallback error route is marked `error*`.
+ */
+ fun edgeLabel(stage: Stage, outcome: String): String =
+ if (outcome == "error" && stage.fallbackError) "error*" else outcome
+}
+
+data class GraphRoute(val source: String, val outcome: String, val target: String)
+
+data class GraphEdge(
+ val id: Int,
+ val source: String,
+ val outcome: String,
+ val target: String,
+ val label: String,
+)
+
+/** Builds every definition edge in stable id order, exactly like tui.graphEdges. */
+fun Graph.edges(): List {
+ val result = ArrayList()
+ for (stage in stages) {
+ for (outcome in GraphSemantics.outcomes(stage)) {
+ val target = Protocol.resolveTarget(outcome, stage.edges[outcome] ?: continue)
+ result += GraphEdge(
+ id = result.size + 1,
+ source = stage.key,
+ outcome = outcome,
+ target = target,
+ label = GraphSemantics.edgeLabel(stage, outcome),
+ )
+ }
+ }
+ return result
+}
+
+/**
+ * Which stages and routes a run actually recorded, used to highlight executed
+ * paths and dim everything else (tui/run_graph.go runGraphState).
+ */
+data class RunGraphState(
+ val visitedStages: Set,
+ val takenRoutes: Set,
+ val currentStage: String?,
+) {
+ companion object {
+ fun from(run: RunDetail): RunGraphState {
+ val stages = LinkedHashSet()
+ val routes = LinkedHashSet()
+ for (step in run.steps) {
+ stages += step.stage
+ if (step.target.isNotEmpty() && step.outcome.isNotEmpty()) {
+ val target = Protocol.resolveTarget(step.outcome, step.target)
+ routes += GraphRoute(step.stage, step.outcome, target)
+ if (Protocol.isTerminal(target)) stages += target
+ }
+ }
+ val current = run.currentStage.ifEmpty {
+ run.steps.lastOrNull()?.stage ?: ""
+ }
+ return RunGraphState(stages, routes, current.ifEmpty { null })
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Json.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Json.kt
new file mode 100644
index 00000000..d3c1b769
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Json.kt
@@ -0,0 +1,16 @@
+package net.awan.pipelines.data.protocol
+
+import kotlinx.serialization.json.Json
+
+/**
+ * Tolerant JSON: unknown server fields are ignored, explicit nulls are dropped,
+ * and wrong types fall back to defaults so a partial or newer envelope never
+ * crashes the client.
+ */
+val PipelinesJson: Json = Json {
+ ignoreUnknownKeys = true
+ explicitNulls = false
+ coerceInputValues = true
+ isLenient = true
+ encodeDefaults = false
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt
new file mode 100644
index 00000000..4b4a0288
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt
@@ -0,0 +1,395 @@
+package net.awan.pipelines.data.protocol
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonElement
+
+/**
+ * Protocol command/type constants. These mirror the Go constants in
+ * internal/protocol/message.go, runs.go and status.go exactly so later renames
+ * cannot drift from the server.
+ */
+object Protocol {
+ // message.go
+ const val PING = "ping"
+ const val PONG = "pong"
+ const val ERROR = "error"
+ const val SUBMIT = "submit"
+ const val SUBMITTED = "submitted"
+ const val LIST = "list_pipelines"
+ const val PIPELINE_LIST = "pipelines"
+ const val GET_PIPELINE = "get_pipeline"
+ const val PIPELINE = "pipeline"
+ const val LIST_TEMPLATES = "list_templates"
+ const val TEMPLATES = "templates"
+ const val VALIDATE = "validate"
+ const val VALIDATED = "validated"
+
+ // runs.go
+ const val RUN_PIPELINE = "run_pipeline"
+ const val RUN_STARTED = "run_started"
+ const val LIST_RUNS = "list_runs"
+ const val RUNS = "runs"
+ const val GET_RUN = "get_run"
+ const val RUN = "run"
+ const val CANCEL_RUN = "cancel_run"
+ const val RETRY_RUN = "retry_run"
+ const val GET_RUN_EVIDENCE = "get_run_evidence"
+ const val RUN_EVIDENCE = "run_evidence"
+
+ // status.go
+ const val GET_STATUS = "get_status"
+ const val STATUS = "status"
+
+ // terminals.go
+ const val SUCCESS_END = "#success"
+ const val FAILURE_END = "#failure"
+
+ fun isTerminal(target: String): Boolean = target == SUCCESS_END || target == FAILURE_END
+
+ /** Mirrors protocol.ResolveTarget: preserve the # shorthand as an explicit terminal. */
+ fun resolveTarget(outcome: String, target: String): String = when {
+ target != "#" -> target
+ outcome == "error" -> FAILURE_END
+ else -> SUCCESS_END
+ }
+}
+
+@Serializable
+data class BuildInfo(
+ val version: String = "",
+ val commit: String = "",
+ val dirty: Boolean? = null,
+)
+
+@Serializable
+data class NotificationEndpoint(
+ val destination: String = "",
+ @SerialName("server_url") val serverUrl: String? = null,
+ val topic: String = "",
+)
+
+@Serializable
+data class Template(
+ val key: String = "",
+ val name: String = "",
+ val description: String = "",
+ val source: String = "",
+ val scheduled: Boolean = false,
+)
+
+@Serializable
+data class StageLimits(
+ @SerialName("max_visits") val maxVisits: Int = 0,
+ val on: List? = null,
+)
+
+@Serializable
+data class NotificationPolicy(
+ val on: List = emptyList(),
+ val destination: String = "",
+ val artifacts: List? = null,
+)
+
+@Serializable
+data class Stage(
+ val limits: StageLimits? = null,
+ val memory: Map? = null,
+ val notify: NotificationPolicy? = null,
+ val key: String = "",
+ val type: String? = null,
+ val output: String = "",
+ val prompt: String = "",
+ val configs: Map = emptyMap(),
+ val edges: Map = emptyMap(),
+ @SerialName("fallback_error") val fallbackError: Boolean = false,
+ val blocks: Map? = null,
+)
+
+@Serializable
+data class Schedule(
+ val days: List? = null,
+ val times: List? = null,
+ val every: String? = null,
+ val timezone: String? = null,
+)
+
+@Serializable
+data class Settings(
+ val prompt: String = "",
+ val schedules: List = emptyList(),
+)
+
+@Serializable
+data class Graph(
+ val stages: List = emptyList(),
+ val settings: Settings? = null,
+)
+
+@Serializable
+data class PipelineSummary(
+ val id: Long = 0,
+ val name: String = "",
+ val version: Int = 0,
+ val stages: Int = 0,
+ @SerialName("created_at") val createdAt: String = "",
+ @SerialName("updated_at") val updatedAt: String = "",
+)
+
+@Serializable
+data class VersionSummary(
+ val version: Int = 0,
+ val stages: Int = 0,
+ @SerialName("created_at") val createdAt: String = "",
+)
+
+// kotlinx.serialization rejects overriding an inherited serializable property
+// (duplicate serial name in the class and its supertype), so the server's
+// embedded PipelineSummary fields are declared flat here with the same wire
+// names as internal/protocol/message.go.
+@Serializable
+data class PipelineDetail(
+ val id: Long = 0,
+ val name: String = "",
+ val version: Int = 0,
+ val stages: Int = 0,
+ @SerialName("created_at") val createdAt: String = "",
+ @SerialName("updated_at") val updatedAt: String = "",
+ @SerialName("latest_version") val latestVersion: Int = 0,
+ @SerialName("version_created_at") val versionCreatedAt: String = "",
+ @SerialName("content_hash") val contentHash: String = "",
+ val source: String = "",
+ val graph: Graph = Graph(),
+ val versions: List = emptyList(),
+)
+
+@Serializable
+data class MemoryRead(
+ val source: String = "",
+ val sequence: Int = 0,
+)
+
+@Serializable
+data class ControlEvidence(
+ val visit: Int = 0,
+ @SerialName("max_visits") val maxVisits: Int = 0,
+ @SerialName("limit_reached") val limitReached: Boolean = false,
+ @SerialName("model_target") val modelTarget: String? = null,
+ val memory: Map? = null,
+)
+
+@Serializable
+data class FileChange(
+ val path: String = "",
+ val kind: String = "",
+ val patch: String? = null,
+ val binary: Boolean = false,
+ val truncated: Boolean = false,
+ @SerialName("before_mode") val beforeMode: String? = null,
+ @SerialName("after_mode") val afterMode: String? = null,
+)
+
+@Serializable
+data class StageFileChanges(
+ val omitted: Int = 0,
+ val scope: String? = null,
+ val status: String = "",
+ val files: List = emptyList(),
+ val skipped: Int = 0,
+ val diagnostic: String? = null,
+)
+
+@Serializable
+data class NotificationReceipt(
+ val destination: String = "",
+ val status: String = "",
+ val filename: String? = null,
+ @SerialName("message_id") val messageId: String? = null,
+ @SerialName("attachment_url") val attachmentUrl: String? = null,
+ val diagnostic: String? = null,
+)
+
+@Serializable
+data class SessionEvidence(
+ val sequence: Int = 0,
+ @SerialName("session_id") val sessionId: String = "",
+ val backend: String = "",
+ val directory: String = "",
+ val data: String? = null,
+ val diagnostic: String? = null,
+)
+
+@Serializable
+data class RunSummary(
+ val id: Long = 0,
+ @SerialName("pipeline_id") val pipelineId: Long = 0,
+ val name: String = "",
+ val version: Int = 0,
+ @SerialName("content_hash") val contentHash: String = "",
+ val status: String = "",
+ val executing: Boolean = false,
+ val outcome: String = "",
+ @SerialName("current_stage") val currentStage: String = "",
+ @SerialName("created_at") val createdAt: String = "",
+ @SerialName("finished_at") val finishedAt: String = "",
+ val diagnostic: String = "",
+ @SerialName("result_preview") val resultPreview: String? = null,
+ @SerialName("completed_steps") val completedSteps: Int = 0,
+)
+
+@Serializable
+data class RunStep(
+ val control: ControlEvidence? = null,
+ @SerialName("file_changes") val fileChanges: StageFileChanges? = null,
+ val notifications: List? = null,
+ val sequence: Int = 0,
+ val stage: String = "",
+ val status: String = "",
+ val outcome: String = "",
+ val target: String = "",
+ val input: Map? = null,
+ val output: Map? = null,
+ val diagnostic: String = "",
+ @SerialName("session_id") val sessionId: String = "",
+ @SerialName("agent_active") val agentActive: Boolean = false,
+ val transcript: String = "",
+ @SerialName("started_at") val startedAt: String = "",
+ @SerialName("finished_at") val finishedAt: String = "",
+)
+
+// Same flattening as PipelineDetail: the embedded RunSummary fields are
+// declared directly with the exact internal/protocol/runs.go wire names.
+@Serializable
+data class RunDetail(
+ val id: Long = 0,
+ @SerialName("pipeline_id") val pipelineId: Long = 0,
+ val name: String = "",
+ val version: Int = 0,
+ @SerialName("content_hash") val contentHash: String = "",
+ val status: String = "",
+ val executing: Boolean = false,
+ val outcome: String = "",
+ @SerialName("current_stage") val currentStage: String = "",
+ @SerialName("created_at") val createdAt: String = "",
+ @SerialName("finished_at") val finishedAt: String = "",
+ val diagnostic: String = "",
+ @SerialName("result_preview") val resultPreview: String? = null,
+ @SerialName("completed_steps") val completedSteps: Int = 0,
+ val graph: Graph = Graph(),
+ @SerialName("retry_of") val retryOf: Long = 0,
+ val workspace: String = "",
+ @SerialName("allow_tools") val allowTools: Boolean = false,
+ @SerialName("write_paths") val writePaths: List = emptyList(),
+ val input: Map? = null,
+ val output: Map? = null,
+ val steps: List = emptyList(),
+)
+
+@Serializable
+data class RunCounts(
+ val total: Int = 0,
+ val succeeded: Int = 0,
+ val failed: Int = 0,
+ val canceled: Int = 0,
+ val interrupted: Int = 0,
+ val active: Int = 0,
+ @SerialName("average_seconds") val averageSeconds: Double = 0.0,
+)
+
+// The server embeds RunCounts (internal/protocol/stats.go); flatten its fields
+// with matching wire names rather than overriding a serializable supertype.
+@Serializable
+data class PipelineUsage(
+ @SerialName("pipeline_id") val pipelineId: Long = 0,
+ val name: String = "",
+ val total: Int = 0,
+ val succeeded: Int = 0,
+ val failed: Int = 0,
+ val canceled: Int = 0,
+ val interrupted: Int = 0,
+ val active: Int = 0,
+ @SerialName("average_seconds") val averageSeconds: Double = 0.0,
+)
+
+@Serializable
+data class DailyUsage(
+ val date: String = "",
+ val runs: Int = 0,
+)
+
+@Serializable
+data class UsageStats(
+ val total: Int = 0,
+ val succeeded: Int = 0,
+ val failed: Int = 0,
+ val canceled: Int = 0,
+ val interrupted: Int = 0,
+ val active: Int = 0,
+ @SerialName("average_seconds") val averageSeconds: Double = 0.0,
+ val pipelines: List = emptyList(),
+ val days: List = emptyList(),
+)
+
+@Serializable
+data class NetworkAddress(
+ @SerialName("interface") val interfaceName: String? = null,
+ val ip: String = "",
+)
+
+@Serializable
+data class ServiceStatus(
+ val health: String = "",
+ val url: String? = null,
+ val port: String? = null,
+ @SerialName("candidate_urls") val candidateUrls: List? = null,
+)
+
+@Serializable
+data class SystemStatus(
+ val hostname: String = "",
+ @SerialName("started_at") val startedAt: String = "",
+ val uptime: String = "",
+ val addresses: List = emptyList(),
+ val server: ServiceStatus = ServiceStatus(),
+ val ntfy: ServiceStatus = ServiceStatus(),
+ val topic: String? = null,
+ @SerialName("ntfy_user") val ntfyUser: String? = null,
+ val note: String = "",
+)
+
+/**
+ * The shared JSON envelope. Every field is optional/nullable with defaults so
+ * unknown or missing server fields never crash the client.
+ */
+@Serializable
+data class Message(
+ @SerialName("default_harness") val defaultHarness: String? = null,
+ val build: BuildInfo? = null,
+ @SerialName("default_model") val defaultModel: String? = null,
+ val evidence: List? = null,
+ val usage: UsageStats? = null,
+ val status: SystemStatus? = null,
+ val graph: Graph? = null,
+ @SerialName("expected_version") val expectedVersion: Int = 0,
+ val templates: List? = null,
+ @SerialName("create_only") val createOnly: Boolean = false,
+ @SerialName("notification_endpoints") val notificationEndpoints: List? = null,
+ val type: String = "",
+ val id: String? = null,
+ val time: String? = null,
+ val error: String? = null,
+ val name: String? = null,
+ val source: String? = null,
+ val version: Int = 0,
+ val pipelines: List? = null,
+ @SerialName("pipeline_id") val pipelineId: Long = 0,
+ val detail: PipelineDetail? = null,
+ @SerialName("run_id") val runId: Long = 0,
+ @SerialName("run_detail") val runDetail: RunDetail? = null,
+ val runs: List? = null,
+ val input: Map? = null,
+ @SerialName("allow_tools") val allowTools: Boolean = false,
+ @SerialName("write_paths") val writePaths: List? = null,
+ @SerialName("request_key") val requestKey: String? = null,
+ val workspace: String? = null,
+)
diff --git a/android/app/src/main/java/net/awan/pipelines/data/transport/ConnectionState.kt b/android/app/src/main/java/net/awan/pipelines/data/transport/ConnectionState.kt
new file mode 100644
index 00000000..1dc2b2b3
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/transport/ConnectionState.kt
@@ -0,0 +1,14 @@
+package net.awan.pipelines.data.transport
+
+import net.awan.pipelines.data.protocol.BuildInfo
+
+/** Connection lifecycle exposed to the UI, including the last server build. */
+sealed interface ConnectionState {
+ data object Idle : ConnectionState
+
+ data class Connecting(val attempt: Int) : ConnectionState
+
+ data class Connected(val build: BuildInfo?, val serverTime: String?) : ConnectionState
+
+ data class Disconnected(val message: String, val retrying: Boolean) : ConnectionState
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/data/transport/PipelinesClient.kt b/android/app/src/main/java/net/awan/pipelines/data/transport/PipelinesClient.kt
new file mode 100644
index 00000000..2e43d153
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/transport/PipelinesClient.kt
@@ -0,0 +1,210 @@
+package net.awan.pipelines.data.transport
+
+import java.io.IOException
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicLong
+import kotlin.random.Random
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.json.Json
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import net.awan.pipelines.data.protocol.Message
+import net.awan.pipelines.data.protocol.PipelinesJson
+import net.awan.pipelines.data.protocol.Protocol
+
+/** A server `type:"error"` reply, surfaced with the server's own text. */
+class ProtocolException(message: String) : Exception(message)
+
+/** No live WebSocket connection is available for the request. */
+class NotConnectedException(message: String = "Not connected to the Pipelines server") : Exception(message)
+
+/**
+ * A single, reused WebSocket connection to `/connect`.
+ *
+ * Requests are serialized; each carries a client-generated stable id and the
+ * client matches replies by id, skipping unsolicited envelopes exactly like
+ * internal/client/client.go Call. There is no authentication of any kind.
+ */
+class PipelinesClient(
+ private val json: Json = PipelinesJson,
+ private val scope: CoroutineScope,
+ private val ioDispatcher: CoroutineDispatcher = Dispatchers.IO,
+ private val requestTimeoutMillis: Long = 30_000L,
+ clientFactory: () -> OkHttpClient = { defaultPipelinesHttpClient() },
+) {
+ private val httpClient = clientFactory()
+
+ private val _state = MutableStateFlow(ConnectionState.Idle)
+ val state: StateFlow = _state.asStateFlow()
+
+ private val sendLock = Mutex()
+ private val pending = ConcurrentHashMap>()
+ private val sequence = AtomicLong(0)
+
+ @Volatile
+ private var webSocket: WebSocket? = null
+
+ @Volatile
+ private var endpoint: String? = null
+
+ @Volatile
+ private var manualClose = false
+
+ private var reconnectJob: Job? = null
+ private var attempt = 0
+
+ /** Opens (or re-opens) the connection to a validated server URL. */
+ fun connect(validated: ServerUrl.Validated) {
+ val httpUrl = validated.httpUrl ?: throw IllegalArgumentException("server URL is not valid")
+ endpoint = httpUrl
+ manualClose = false
+ attempt = 0
+ reconnectJob?.cancel()
+ reconnectJob = null
+ open()
+ }
+
+ /** Explicit user disconnect: stops reconnection and closes the socket. */
+ fun disconnect() {
+ manualClose = true
+ reconnectJob?.cancel()
+ reconnectJob = null
+ val socket = webSocket
+ webSocket = null
+ socket?.close(NORMAL_CLOSURE, "client closing")
+ failPending("Disconnected")
+ _state.value = ConnectionState.Idle
+ }
+
+ fun close() {
+ disconnect()
+ httpClient.dispatcher.executorService.shutdown()
+ }
+
+ /**
+ * Sends one request and awaits the reply with the matching id. Serialized by
+ * a mutex so concurrent screens cannot interleave frames.
+ */
+ suspend fun call(request: Message): Message = withContext(ioDispatcher) {
+ sendLock.withLock {
+ val socket = webSocket ?: throw NotConnectedException()
+ if (_state.value !is ConnectionState.Connected) throw NotConnectedException()
+ val id = "android-" + sequence.incrementAndGet()
+ val deferred = CompletableDeferred()
+ pending[id] = deferred
+ try {
+ val payload = json.encodeToString(Message.serializer(), request.copy(id = id))
+ if (!socket.send(payload)) throw IOException("websocket send failed")
+ val response = withTimeout(requestTimeoutMillis) { deferred.await() }
+ if (response.type == Protocol.ERROR) {
+ throw ProtocolException(response.error?.ifBlank { "server error" } ?: "server error")
+ }
+ response
+ } finally {
+ pending.remove(id)
+ }
+ }
+ }
+
+ private fun open() {
+ val current = endpoint ?: return
+ attempt += 1
+ _state.value = ConnectionState.Connecting(attempt)
+ val request = Request.Builder().url(current).build()
+ webSocket = httpClient.newWebSocket(request, listener)
+ }
+
+ private fun failPending(reason: String) {
+ val snapshot = pending.keys.toList()
+ for (key in snapshot) {
+ pending.remove(key)?.completeExceptionally(IOException(reason))
+ }
+ }
+
+ private fun handleClosed(reason: String) {
+ webSocket = null
+ failPending(reason)
+ if (manualClose) {
+ _state.value = ConnectionState.Idle
+ return
+ }
+ scheduleReconnect(reason)
+ }
+
+ private fun scheduleReconnect(reason: String) {
+ if (reconnectJob?.isActive == true) return
+ _state.value = ConnectionState.Disconnected(reason, retrying = true)
+ val nextAttempt = attempt
+ val backoff = (BASE_BACKOFF_MILLIS shl (nextAttempt - 1).coerceAtMost(6))
+ .coerceAtMost(MAX_BACKOFF_MILLIS)
+ val jitter = Random.nextLong(0, 400)
+ reconnectJob = scope.launch {
+ delay(backoff + jitter)
+ if (!manualClose && endpoint != null) open()
+ }
+ }
+
+ private val listener = object : WebSocketListener() {
+ override fun onOpen(webSocket: WebSocket, response: Response) {
+ attempt = 0
+ _state.value = ConnectionState.Connected(build = null, serverTime = null)
+ }
+
+ override fun onMessage(webSocket: WebSocket, text: String) {
+ val message = try {
+ json.decodeFromString(Message.serializer(), text)
+ } catch (_: Exception) {
+ // Malformed frame: never misattribute it to a request.
+ return
+ }
+ val id = message.id
+ val deferred = if (id != null) pending.remove(id) else null
+ if (deferred != null) {
+ deferred.complete(message)
+ }
+ // Unsolicited envelopes (for example the connection's initial
+ // pipeline_list) have no matching id and are intentionally dropped.
+ }
+
+ override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+ handleClosed("Connection closed (${code})")
+ }
+
+ override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+ webSocket.close(NORMAL_CLOSURE, null)
+ }
+
+ override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+ val reason = t.message?.ifBlank { t.javaClass.simpleName } ?: "connection failed"
+ handleClosed(reason)
+ }
+ }
+
+ companion object {
+ private const val NORMAL_CLOSURE = 1000
+ private const val BASE_BACKOFF_MILLIS = 1_000L
+ private const val MAX_BACKOFF_MILLIS = 30_000L
+ }
+}
+
+private fun defaultPipelinesHttpClient(): OkHttpClient = OkHttpClient.Builder()
+ .pingInterval(20, java.util.concurrent.TimeUnit.SECONDS)
+ .readTimeout(0, java.util.concurrent.TimeUnit.MILLISECONDS)
+ .connectTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+ .build()
diff --git a/android/app/src/main/java/net/awan/pipelines/data/transport/ServerUrl.kt b/android/app/src/main/java/net/awan/pipelines/data/transport/ServerUrl.kt
new file mode 100644
index 00000000..d3e91554
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/data/transport/ServerUrl.kt
@@ -0,0 +1,85 @@
+package net.awan.pipelines.data.transport
+
+import java.net.URI
+import java.net.URISyntaxException
+
+/**
+ * Server-URL validation mirroring internal/client/config.go: only ws/wss with a
+ * non-empty hostname and no userinfo/fragment. The endpoint path defaults to
+ * /connect, matching internal/server/websocket.go `GET /connect`.
+ */
+object ServerUrl {
+
+ enum class ErrorKind {
+ EMPTY,
+ MALFORMED,
+ UNSUPPORTED_SCHEME,
+ MISSING_HOST,
+ USER_INFO,
+ FRAGMENT,
+ }
+
+ data class Validated(
+ val valid: Boolean,
+ val wsUrl: String? = null,
+ val httpUrl: String? = null,
+ val host: String? = null,
+ val port: Int = 0,
+ val secure: Boolean = false,
+ val kind: ErrorKind? = null,
+ val message: String? = null,
+ )
+
+ fun validate(raw: String): Validated {
+ val trimmed = raw.trim()
+ if (trimmed.isEmpty()) {
+ return Validated(false, kind = ErrorKind.EMPTY, message = "Enter the Pipelines server URL, for example ws://192.168.1.20:8081/connect")
+ }
+ val uri = try {
+ URI(trimmed)
+ } catch (e: URISyntaxException) {
+ return Validated(false, kind = ErrorKind.MALFORMED, message = "That is not a valid URL: ${e.reason ?: "malformed syntax"}")
+ }
+ val scheme = uri.scheme?.lowercase()
+ if (scheme == null) {
+ return Validated(false, kind = ErrorKind.UNSUPPORTED_SCHEME, message = "The URL must start with ws:// or wss://")
+ }
+ if (scheme != "ws" && scheme != "wss") {
+ return Validated(false, kind = ErrorKind.UNSUPPORTED_SCHEME, message = "Unsupported scheme \"$scheme\"; use ws:// (trusted LAN/VPN) or wss://")
+ }
+ if (uri.userInfo != null) {
+ return Validated(false, kind = ErrorKind.USER_INFO, message = "Credentials are not supported; the server has no authentication. Remove userinfo from the URL")
+ }
+ if (!uri.fragment.isNullOrEmpty()) {
+ return Validated(false, kind = ErrorKind.FRAGMENT, message = "Remove the # fragment; it is not part of the server endpoint")
+ }
+ val host = uri.host
+ if (host.isNullOrBlank()) {
+ return Validated(false, kind = ErrorKind.MISSING_HOST, message = "The URL is missing a host, for example ws://192.168.1.20:8081/connect")
+ }
+ val secure = scheme == "wss"
+ val port = if (uri.port != -1) uri.port else if (secure) 443 else 80
+ var path = uri.path ?: ""
+ if (path.isBlank() || path == "/") path = "/connect"
+ val normalized = buildString {
+ append(scheme).append("://").append(host)
+ if (uri.port != -1) append(':').append(uri.port)
+ append(path)
+ if (!uri.query.isNullOrEmpty()) append('?').append(uri.query)
+ }
+ val httpUrl = buildString {
+ append(if (secure) "https" else "http").append("://").append(host)
+ if (uri.port != -1) append(':').append(uri.port)
+ append(path)
+ if (!uri.query.isNullOrEmpty()) append('?').append(uri.query)
+ }
+ return Validated(
+ valid = true,
+ wsUrl = normalized,
+ httpUrl = httpUrl,
+ host = host,
+ port = port,
+ secure = secure,
+ )
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt
new file mode 100644
index 00000000..9595c232
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt
@@ -0,0 +1,265 @@
+package net.awan.pipelines.ui
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.initializer
+import androidx.lifecycle.viewmodel.viewModelFactory
+import java.util.concurrent.ConcurrentHashMap
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+import net.awan.pipelines.PipelinesApplication
+import net.awan.pipelines.data.ErrorMessages
+import net.awan.pipelines.data.PipelinesRepository
+import net.awan.pipelines.data.RunHistory
+import net.awan.pipelines.data.SettingsRepository
+import net.awan.pipelines.data.protocol.BuildInfo
+import net.awan.pipelines.data.protocol.PipelineDetail
+import net.awan.pipelines.data.protocol.PipelineSummary
+import net.awan.pipelines.data.protocol.RunDetail
+import net.awan.pipelines.data.protocol.SessionEvidence
+import net.awan.pipelines.data.transport.ConnectionState
+import net.awan.pipelines.data.transport.ServerUrl
+
+/** Generic loading/empty/error/data state used by every screen. */
+data class LoadState(
+ val loading: Boolean = false,
+ val data: T? = null,
+ val error: String? = null,
+ val loaded: Boolean = false,
+)
+
+/**
+ * Single application ViewModel. It owns screen state and delegates all network
+ * work to [PipelinesRepository]; it never touches the socket directly and does
+ * no blocking work on the main thread.
+ */
+class AppViewModel(
+ private val repository: PipelinesRepository,
+ private val settings: SettingsRepository,
+) : ViewModel() {
+
+ val connectionState: StateFlow = repository.connectionState
+ val configuredServerUrl: StateFlow = settings.serverUrl
+ val configuredWorkspace: StateFlow = settings.workspace
+
+ private val _serverUrlDraft = MutableStateFlow(settings.serverUrl.value)
+ val serverUrlDraft: StateFlow = _serverUrlDraft.asStateFlow()
+
+ private val _workspaceDraft = MutableStateFlow(settings.workspace.value)
+ val workspaceDraft: StateFlow = _workspaceDraft.asStateFlow()
+
+ private val _urlError = MutableStateFlow(null)
+ val urlError: StateFlow = _urlError.asStateFlow()
+
+ private val _workspaceError = MutableStateFlow(null)
+ val workspaceError: StateFlow = _workspaceError.asStateFlow()
+
+ private val _serverBuild = MutableStateFlow(null)
+ val serverBuild: StateFlow = _serverBuild.asStateFlow()
+
+ private val _serverTime = MutableStateFlow(null)
+ val serverTime: StateFlow = _serverTime.asStateFlow()
+
+ private val _pipelines = MutableStateFlow(LoadState>())
+ val pipelines: StateFlow>> = _pipelines.asStateFlow()
+
+ private val _pipelineDetail = MutableStateFlow(LoadState())
+ val pipelineDetail: StateFlow> = _pipelineDetail.asStateFlow()
+
+ private val _runs = MutableStateFlow(LoadState())
+ val runs: StateFlow> = _runs.asStateFlow()
+
+ private val _runDetail = MutableStateFlow(LoadState())
+ val runDetail: StateFlow> = _runDetail.asStateFlow()
+
+ private val _evidence = MutableStateFlow(LoadState>())
+ val evidence: StateFlow>> = _evidence.asStateFlow()
+
+ private val startKeys = ConcurrentHashMap()
+ private val retryKeys = ConcurrentHashMap()
+
+ fun updateServerUrlDraft(value: String) {
+ _serverUrlDraft.value = value
+ _urlError.value = null
+ }
+
+ fun updateWorkspaceDraft(value: String) {
+ _workspaceDraft.value = value
+ _workspaceError.value = validateWorkspace(value)
+ }
+
+ /** Saves only an absolute path, mirroring the repository's start-run guard. */
+ fun saveWorkspace() {
+ val error = validateWorkspace(_workspaceDraft.value)
+ _workspaceError.value = error
+ if (error == null) settings.setWorkspace(_workspaceDraft.value)
+ }
+
+ private fun validateWorkspace(value: String): String? {
+ val trimmed = value.trim()
+ return when {
+ trimmed.isEmpty() -> null
+ !trimmed.startsWith("/") ->
+ "The workspace must be an absolute path that exists on the execution server."
+ else -> null
+ }
+ }
+
+ var lastConnectError: String? = null
+ private set
+
+ /** Validates and opens the shared connection, then probes with ping. */
+ fun connect() {
+ val result = ServerUrl.validate(_serverUrlDraft.value)
+ if (!result.valid) {
+ _urlError.value = result.message
+ return
+ }
+ _urlError.value = null
+ _serverUrlDraft.value = result.wsUrl ?: _serverUrlDraft.value
+ settings.setServerUrl(result.wsUrl ?: _serverUrlDraft.value)
+ repository.connect(result)
+ awaitConnected()
+ }
+
+ /** Manual reconnect using the already saved URL. */
+ fun reconnect() {
+ val result = ServerUrl.validate(settings.serverUrl.value)
+ if (!result.valid) {
+ _urlError.value = result.message
+ return
+ }
+ repository.connect(result)
+ awaitConnected()
+ }
+
+ fun disconnect() = repository.disconnect()
+
+ private fun awaitConnected() {
+ viewModelScope.launch {
+ val connected = withTimeoutOrNull(CONNECT_TIMEOUT_MILLIS) {
+ connectionState.filterIsInstance().first()
+ }
+ if (connected != null) {
+ probe()
+ } else {
+ lastConnectError = (connectionState.value as? ConnectionState.Disconnected)?.message
+ ?: "Could not reach the server. Check the URL and that you are on the trusted LAN/VPN."
+ }
+ }
+ }
+
+ private suspend fun probe() {
+ try {
+ val pong = repository.ping()
+ _serverBuild.value = pong.build
+ _serverTime.value = pong.time
+ } catch (t: Throwable) {
+ if (t is CancellationException) throw t
+ // Connection state already reflects a failed probe; nothing to add.
+ }
+ }
+
+ fun refreshPipelines() = load(_pipelines) { repository.listPipelines() }
+
+ fun loadPipeline(id: Long, version: Int) = load(_pipelineDetail) {
+ repository.getPipeline(id, version)
+ }
+
+ fun refreshRuns() = load(_runs) { repository.listRuns() }
+
+ fun loadEvidence(id: Long) = load(_evidence) { repository.getRunEvidence(id) }
+
+ /**
+ * Drops any previously loaded evidence so a different run never shows the
+ * previous run's records. Evidence is then fetched on demand, never polled.
+ */
+ fun resetEvidence() {
+ _evidence.value = LoadState()
+ }
+
+ /**
+ * Loads a run. [silent] is used by the bounded poll while a run is executing
+ * so the screen does not flash a spinner on every tick.
+ */
+ fun loadRun(id: Long, silent: Boolean = false) {
+ viewModelScope.launch {
+ if (!silent) _runDetail.value = _runDetail.value.copy(loading = true, error = null)
+ try {
+ val run = repository.getRun(id)
+ _runDetail.value = LoadState(loading = false, data = run, loaded = true)
+ } catch (t: Throwable) {
+ if (t is CancellationException) throw t
+ if (!silent) {
+ _runDetail.value = _runDetail.value.copy(loading = false, error = ErrorMessages.describe(t))
+ }
+ }
+ }
+ }
+
+ fun startRun(pipelineId: Long, version: Int, prompt: String, onResult: (Result) -> Unit) {
+ viewModelScope.launch {
+ try {
+ // Reuse the key across failed/duplicated attempts, clear on success.
+ val key = startKeys.getOrPut(pipelineId) { PipelinesRepository.newRequestKey() }
+ val run = repository.startRun(pipelineId, version, prompt, key)
+ startKeys.remove(pipelineId)
+ onResult(Result.success(run))
+ } catch (t: Throwable) {
+ if (t is CancellationException) throw t
+ onResult(Result.failure(t))
+ }
+ }
+ }
+
+ fun cancelRun(id: Long, onResult: (Result) -> Unit) {
+ viewModelScope.launch {
+ try {
+ onResult(Result.success(repository.cancelRun(id)))
+ } catch (t: Throwable) {
+ if (t is CancellationException) throw t
+ onResult(Result.failure(t))
+ }
+ }
+ }
+
+ fun retryRun(id: Long, onResult: (Result) -> Unit) {
+ viewModelScope.launch {
+ try {
+ val key = retryKeys.getOrPut(id) { PipelinesRepository.newRequestKey() }
+ val run = repository.retryRun(id, key)
+ retryKeys.remove(id)
+ onResult(Result.success(run))
+ } catch (t: Throwable) {
+ if (t is CancellationException) throw t
+ onResult(Result.failure(t))
+ }
+ }
+ }
+
+ private fun load(target: MutableStateFlow>, block: suspend () -> T) {
+ viewModelScope.launch {
+ target.value = target.value.copy(loading = true, error = null)
+ try {
+ target.value = LoadState(loading = false, data = block(), loaded = true)
+ } catch (t: Throwable) {
+ if (t is CancellationException) throw t
+ target.value = target.value.copy(loading = false, error = ErrorMessages.describe(t))
+ }
+ }
+ }
+
+ companion object {
+ private const val CONNECT_TIMEOUT_MILLIS = 20_000L
+
+ fun factory(app: PipelinesApplication) = viewModelFactory {
+ initializer { AppViewModel(app.repository, app.settings) }
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/Format.kt b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt
new file mode 100644
index 00000000..c954b0aa
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/Format.kt
@@ -0,0 +1,33 @@
+package net.awan.pipelines.ui
+
+import java.time.Duration
+import java.time.OffsetDateTime
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+
+/** Human duration between two RFC3339 timestamps, or null when unavailable. */
+fun formatDuration(start: String, end: String): String? {
+ if (start.isBlank() || end.isBlank()) return null
+ return runCatching {
+ val seconds = Duration.between(OffsetDateTime.parse(start), OffsetDateTime.parse(end)).seconds
+ when {
+ seconds < 0 -> null
+ seconds < 60 -> "${seconds}s"
+ seconds < 3600 -> "${seconds / 60}m ${seconds % 60}s"
+ else -> "${seconds / 3600}h ${(seconds % 3600) / 60}m"
+ }
+ }.getOrNull()
+}
+
+/** Compact rendering of arbitrary protocol JSON values for read-only display. */
+fun JsonElement.displayText(): String = when (this) {
+ is JsonPrimitive -> content
+ is JsonArray -> joinToString(", ") { it.displayText() }
+ is JsonObject -> entries.joinToString(", ") { "${it.key}=${it.value.displayText()}" }
+ else -> toString()
+}
+
+fun Map?.displayMap(): String =
+ this?.entries?.joinToString("\n") { "${it.key}: ${it.value.displayText()}" }.orEmpty()
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt
new file mode 100644
index 00000000..b67f1979
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt
@@ -0,0 +1,122 @@
+package net.awan.pipelines.ui
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.List
+import androidx.compose.material.icons.filled.History
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material3.Icon
+import androidx.compose.material3.NavigationBar
+import androidx.compose.material3.NavigationBarItem
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import androidx.navigation.NavType
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.currentBackStackEntryAsState
+import androidx.navigation.compose.rememberNavController
+import androidx.navigation.navArgument
+import net.awan.pipelines.ui.components.ConnectionBanner
+import net.awan.pipelines.ui.screens.PipelineDetailScreen
+import net.awan.pipelines.ui.screens.PipelineListScreen
+import net.awan.pipelines.ui.screens.RunDetailScreen
+import net.awan.pipelines.ui.screens.RunHistoryScreen
+import net.awan.pipelines.ui.screens.SettingsScreen
+
+private data class TopDestination(val route: String, val label: String, val icon: ImageVector)
+
+private val destinations = listOf(
+ TopDestination("pipelines", "Pipelines", Icons.AutoMirrored.Filled.List),
+ TopDestination("runs", "Runs", Icons.Default.History),
+ TopDestination("settings", "Settings", Icons.Default.Settings),
+)
+
+@Composable
+fun PipelinesApp(vm: AppViewModel) {
+ val navController = rememberNavController()
+ val backStackEntry by navController.currentBackStackEntryAsState()
+ val currentRoute = backStackEntry?.destination?.route
+ val connectionState by vm.connectionState.collectAsStateWithLifecycle()
+ val configuredUrl by vm.configuredServerUrl.collectAsStateWithLifecycle()
+
+ Scaffold(
+ bottomBar = {
+ NavigationBar {
+ destinations.forEach { destination ->
+ val selected = currentRoute == destination.route ||
+ (destination.route == "pipelines" && currentRoute?.startsWith("pipeline/") == true) ||
+ (destination.route == "runs" && currentRoute?.startsWith("run/") == true)
+ NavigationBarItem(
+ selected = selected,
+ onClick = {
+ if (currentRoute != destination.route) {
+ navController.navigate(destination.route) {
+ popUpTo("pipelines") { inclusive = destination.route == "pipelines" }
+ launchSingleTop = true
+ }
+ }
+ },
+ icon = { Icon(destination.icon, contentDescription = destination.label) },
+ label = { Text(destination.label) },
+ )
+ }
+ }
+ },
+ ) { padding ->
+ Column(Modifier.padding(padding)) {
+ ConnectionBanner(
+ state = connectionState,
+ configuredUrl = configuredUrl,
+ onReconnect = vm::reconnect,
+ )
+ NavHost(
+ navController = navController,
+ startDestination = "pipelines",
+ modifier = Modifier.weight(1f),
+ ) {
+ composable("pipelines") {
+ PipelineListScreen(vm, onOpen = { id, version ->
+ navController.navigate("pipeline/$id/$version")
+ })
+ }
+ composable(
+ route = "pipeline/{id}/{version}",
+ arguments = listOf(
+ navArgument("id") { type = NavType.LongType },
+ navArgument("version") { type = NavType.IntType },
+ ),
+ ) { entry ->
+ PipelineDetailScreen(
+ vm = vm,
+ pipelineId = entry.arguments?.getLong("id") ?: 0L,
+ version = entry.arguments?.getInt("version") ?: 0,
+ onBack = { navController.popBackStack() },
+ onOpenRun = { runId -> navController.navigate("run/$runId") },
+ )
+ }
+ composable("runs") {
+ RunHistoryScreen(vm, onOpenRun = { runId -> navController.navigate("run/$runId") })
+ }
+ composable(
+ route = "run/{id}",
+ arguments = listOf(navArgument("id") { type = NavType.LongType }),
+ ) { entry ->
+ RunDetailScreen(
+ vm = vm,
+ runId = entry.arguments?.getLong("id") ?: 0L,
+ onBack = { navController.popBackStack() },
+ )
+ }
+ composable("settings") {
+ SettingsScreen(vm)
+ }
+ }
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/ConnectionBanner.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/ConnectionBanner.kt
new file mode 100644
index 00000000..0e15de4b
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/components/ConnectionBanner.kt
@@ -0,0 +1,88 @@
+package net.awan.pipelines.ui.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.unit.dp
+import net.awan.pipelines.data.transport.ConnectionState
+
+/**
+ * A small, shared connection banner shown above every screen so a disconnected
+ * client reads as a distinct state with a reconnect affordance rather than as a
+ * generic request error. It reuses the Settings connection copy and renders
+ * nothing while connected.
+ */
+@Composable
+fun ConnectionBanner(
+ state: ConnectionState,
+ configuredUrl: String,
+ onReconnect: () -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ when (state) {
+ is ConnectionState.Connected -> return
+ is ConnectionState.Idle -> Banner(
+ text = "Not connected. Enter the server URL in Settings, then connect.",
+ container = MaterialTheme.colorScheme.surfaceVariant,
+ contentColor = MaterialTheme.colorScheme.onSurfaceVariant,
+ actionLabel = "Reconnect",
+ onAction = onReconnect,
+ actionEnabled = configuredUrl.isNotBlank(),
+ modifier = modifier,
+ )
+ is ConnectionState.Connecting -> Banner(
+ text = "Connecting (attempt ${state.attempt})…",
+ container = MaterialTheme.colorScheme.surfaceVariant,
+ contentColor = MaterialTheme.colorScheme.onSurfaceVariant,
+ modifier = modifier,
+ )
+ is ConnectionState.Disconnected -> Banner(
+ text = buildString {
+ append("Disconnected: ${state.message}")
+ if (state.retrying) append(" · retrying with backoff")
+ },
+ container = MaterialTheme.colorScheme.errorContainer,
+ contentColor = MaterialTheme.colorScheme.onErrorContainer,
+ actionLabel = "Reconnect",
+ onAction = onReconnect,
+ modifier = modifier,
+ )
+ }
+}
+
+@Composable
+private fun Banner(
+ text: String,
+ container: Color,
+ contentColor: Color,
+ modifier: Modifier = Modifier,
+ actionLabel: String? = null,
+ onAction: (() -> Unit)? = null,
+ actionEnabled: Boolean = true,
+) {
+ Surface(color = container, contentColor = contentColor, modifier = modifier.fillMaxWidth()) {
+ Row(
+ modifier = Modifier.padding(horizontal = 16.dp, vertical = 8.dp),
+ verticalAlignment = Alignment.CenterVertically,
+ horizontalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ Text(
+ text = text,
+ style = MaterialTheme.typography.bodySmall,
+ modifier = Modifier.weight(1f),
+ )
+ if (actionLabel != null && onAction != null) {
+ TextButton(onClick = onAction, enabled = actionEnabled) { Text(actionLabel) }
+ }
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt
new file mode 100644
index 00000000..c20f233c
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/components/States.kt
@@ -0,0 +1,75 @@
+package net.awan.pipelines.ui.components
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun LoadingState(message: String = "Loading…", modifier: Modifier = Modifier) {
+ Column(
+ modifier = modifier.fillMaxSize().semantics { contentDescription = message },
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.Center,
+ ) {
+ CircularProgressIndicator()
+ Text(message, style = MaterialTheme.typography.bodyMedium, modifier = Modifier.padding(top = 12.dp))
+ }
+}
+
+@Composable
+fun ErrorState(message: String, onRetry: (() -> Unit)? = null, modifier: Modifier = Modifier) {
+ Column(
+ modifier = modifier.fillMaxSize().padding(24.dp),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.Center,
+ ) {
+ Text(
+ text = message,
+ color = MaterialTheme.colorScheme.error,
+ textAlign = TextAlign.Center,
+ style = MaterialTheme.typography.bodyLarge,
+ )
+ if (onRetry != null) {
+ Button(onClick = onRetry, modifier = Modifier.padding(top = 16.dp)) { Text("Retry") }
+ }
+ }
+}
+
+@Composable
+fun EmptyState(message: String, modifier: Modifier = Modifier) {
+ Column(
+ modifier = modifier.fillMaxSize().padding(24.dp),
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = Arrangement.Center,
+ ) {
+ Text(
+ text = message,
+ textAlign = TextAlign.Center,
+ style = MaterialTheme.typography.bodyLarge,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ )
+ }
+}
+
+/** Renders a labelled key/value row used across detail screens. */
+@Composable
+fun KeyValueRow(label: String, value: String, modifier: Modifier = Modifier) {
+ if (value.isBlank()) return
+ Column(modifier = modifier.fillMaxWidth().padding(vertical = 4.dp)) {
+ Text(label, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.primary)
+ Text(value, style = MaterialTheme.typography.bodyMedium)
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt
new file mode 100644
index 00000000..7cfc40f0
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt
@@ -0,0 +1,401 @@
+package net.awan.pipelines.ui.graph
+
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTransformGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Size
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Path
+import androidx.compose.ui.graphics.drawscope.DrawScope
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.graphics.drawscope.withTransform
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.TextMeasurer
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.drawText
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.rememberTextMeasurer
+import androidx.compose.ui.unit.IntSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlin.math.abs
+import net.awan.pipelines.data.protocol.Graph
+import net.awan.pipelines.data.protocol.GraphEdge
+import net.awan.pipelines.data.protocol.GraphRoute
+import net.awan.pipelines.data.protocol.GraphSemantics
+import net.awan.pipelines.data.protocol.Protocol
+import net.awan.pipelines.data.protocol.RunGraphState
+import net.awan.pipelines.data.protocol.edges
+
+private data class NodeLayout(
+ val key: String,
+ val label: String,
+ val x: Float,
+ val y: Float,
+ val width: Float,
+ val height: Float,
+ val terminal: Boolean,
+)
+
+private data class EdgeLayout(
+ val edge: GraphEdge,
+ val from: Offset,
+ val to: Offset,
+ val backEdge: Boolean,
+ val sourceRank: Int,
+ val targetRank: Int,
+)
+
+private data class GraphLayout(
+ val nodes: List,
+ val edges: List,
+ val width: Float,
+ val height: Float,
+)
+
+/**
+ * Renders a workflow [Graph] as a pannable, zoomable node-and-arrow diagram.
+ *
+ * Node/edge/outcome semantics come from [GraphSemantics] and [edges], mirroring
+ * internal/tui/graph.go: content-sized stage nodes, labelled outcome edges with
+ * the `error*` fallback marker, `#success`/`#failure` terminals and loop routes.
+ * When [runState] is supplied, executed stages/routes are highlighted and the
+ * rest dimmed; when it is null the full definition is shown.
+ */
+@Composable
+fun WorkflowGraph(
+ graph: Graph,
+ modifier: Modifier = Modifier,
+ runState: RunGraphState? = null,
+ selectedStage: String? = null,
+) {
+ val density = LocalDensity.current
+ val textMeasurer = rememberTextMeasurer()
+ val layout = remember(graph, density) {
+ with(density) { layoutGraph(graph, this) }
+ }
+ val description = remember(graph, runState) { graphDescription(graph, runState) }
+
+ val scheme = MaterialTheme.colorScheme
+ val colors = remember(scheme) {
+ GraphColors(
+ success = scheme.tertiary,
+ error = scheme.error,
+ accent = listOf(scheme.primary, scheme.secondary, scheme.primaryContainer, scheme.secondaryContainer),
+ nodeFill = scheme.surfaceVariant,
+ nodeFillActive = scheme.primaryContainer,
+ nodeBorder = scheme.outline,
+ nodeText = scheme.onSurface,
+ terminalFill = scheme.secondaryContainer,
+ )
+ }
+
+ var scale by remember { mutableFloatStateOf(1f) }
+ var offset by remember { mutableStateOf(Offset.Zero) }
+ var canvasSize by remember { mutableStateOf(IntSize.Zero) }
+ var centered by remember { mutableStateOf(false) }
+
+ Box(
+ modifier = modifier
+ .background(MaterialTheme.colorScheme.surface)
+ .semantics { contentDescription = description }
+ .onSizeChanged { size ->
+ canvasSize = size
+ if (!centered && layout.width > 0f && layout.height > 0f) {
+ offset = Offset(
+ x = (size.width - layout.width * scale) / 2f,
+ y = (size.height - layout.height * scale) / 2f,
+ ).coerceAtLeast(0f)
+ centered = true
+ }
+ }
+ .pointerInput(Unit) {
+ detectTransformGestures { _, pan, zoom, _ ->
+ scale = (scale * zoom).coerceIn(MIN_SCALE, MAX_SCALE)
+ offset += pan
+ }
+ },
+ ) {
+ Canvas(Modifier.fillMaxSize()) {
+ if (graph.stages.isEmpty()) return@Canvas
+ withTransform({
+ translate(offset.x, offset.y)
+ scale(scale, scale, pivot = Offset.Zero)
+ }) {
+ drawEdges(layout, colors, runState, textMeasurer)
+ drawNodes(layout, colors, runState, selectedStage, textMeasurer)
+ }
+ }
+ }
+}
+
+private fun Offset.coerceAtLeast(minimum: Float): Offset =
+ Offset(x.coerceAtLeast(minimum), y.coerceAtLeast(minimum))
+
+private class GraphColors(
+ val success: Color,
+ val error: Color,
+ val accent: List,
+ val nodeFill: Color,
+ val nodeFillActive: Color,
+ val nodeBorder: Color,
+ val nodeText: Color,
+ val terminalFill: Color,
+)
+
+private fun layoutGraph(graph: Graph, density: androidx.compose.ui.unit.Density): GraphLayout {
+ if (graph.stages.isEmpty()) return GraphLayout(emptyList(), emptyList(), 0f, 0f)
+
+ val nodeWidth = with(density) { 132.dp.toPx() }
+ val nodeHeight = with(density) { 56.dp.toPx() }
+ val hGap = with(density) { 88.dp.toPx() }
+ val vGap = with(density) { 28.dp.toPx() }
+ val pad = with(density) { 32.dp.toPx() }
+
+ val ranks = rankStages(graph)
+ val maxRank = ranks.values.maxOrNull() ?: 0
+ val terminalRank = maxRank + 1
+ val columns = HashMap>()
+ for (stage in graph.stages) {
+ val rank = ranks[stage.key] ?: 0
+ columns.getOrPut(rank) { mutableListOf() } += stage.key
+ }
+ val terminalKeys = mutableListOf()
+ if (graph.stages.any { stage -> stage.edges.values.any { Protocol.isTerminal(it) || it == "#" } }) {
+ terminalKeys += Protocol.SUCCESS_END
+ terminalKeys += Protocol.FAILURE_END
+ }
+
+ val columnHeights = HashMap()
+ for ((rank, keys) in columns) {
+ columnHeights[rank] = keys.size * nodeHeight + (keys.size - 1).coerceAtLeast(0) * vGap
+ }
+ columnHeights[terminalRank] = terminalKeys.size * nodeHeight + (terminalKeys.size - 1).coerceAtLeast(0) * vGap
+ val tallest = columnHeights.values.maxOrNull() ?: nodeHeight
+
+ val positions = HashMap()
+ val sortedRanks = columns.keys.sorted()
+ for ((columnIndex, rank) in sortedRanks.withIndex()) {
+ val keys = columns.getValue(rank)
+ val columnHeight = columnHeights.getValue(rank)
+ var y = (tallest - columnHeight) / 2f
+ val x = pad + columnIndex * (nodeWidth + hGap)
+ for (key in keys) {
+ positions[key] = NodeLayout(
+ key = key,
+ label = GraphSemantics.nodeLabel(key),
+ x = x,
+ y = y,
+ width = nodeWidth,
+ height = nodeHeight,
+ terminal = false,
+ )
+ y += nodeHeight + vGap
+ }
+ }
+ terminalKeys.forEachIndexed { index, key ->
+ val columnHeight = columnHeights.getValue(terminalRank)
+ val x = pad + sortedRanks.size * (nodeWidth + hGap)
+ val y = (tallest - columnHeight) / 2f + index * (nodeHeight + vGap)
+ positions[key] = NodeLayout(
+ key = key,
+ label = GraphSemantics.nodeLabel(key),
+ x = x,
+ y = y,
+ width = nodeWidth,
+ height = nodeHeight,
+ terminal = true,
+ )
+ }
+
+ val edgeLayouts = graph.edges().mapNotNull { edge ->
+ val source = positions[edge.source] ?: return@mapNotNull null
+ val target = positions[edge.target] ?: return@mapNotNull null
+ val sourceRank = ranks[edge.source] ?: 0
+ val targetRank = if (Protocol.isTerminal(edge.target)) terminalRank else (ranks[edge.target] ?: 0)
+ EdgeLayout(
+ edge = edge,
+ from = Offset(source.x + source.width, source.y + source.height / 2f),
+ to = Offset(target.x, target.y + target.height / 2f),
+ backEdge = targetRank <= sourceRank,
+ sourceRank = sourceRank,
+ targetRank = targetRank,
+ )
+ }
+
+ val width = pad * 2 + (sortedRanks.size + 1) * nodeWidth + sortedRanks.size * hGap
+ val height = pad * 2 + tallest
+ return GraphLayout(positions.values.toList(), edgeLayouts, width, height)
+}
+
+/** Bellman-Ford relaxation of the longest path from the entry stage, loops capped. */
+private fun rankStages(graph: Graph): Map {
+ val ranks = HashMap()
+ val entry = graph.stages.firstOrNull()?.key ?: return ranks
+ for (stage in graph.stages) ranks[stage.key] = 0
+ var changed = true
+ var guard = 0
+ while (changed && guard <= graph.stages.size) {
+ changed = false
+ guard++
+ for (stage in graph.stages) {
+ for (target in stage.edges.values) {
+ if (Protocol.isTerminal(target) || target == "#") continue
+ val next = ranks[stage.key]!! + 1
+ if (next > (ranks[target] ?: 0)) {
+ ranks[target] = next
+ changed = true
+ }
+ }
+ }
+ }
+ if (!ranks.containsKey(entry)) ranks[entry] = 0
+ return ranks
+}
+
+private fun DrawScope.drawEdges(
+ layout: GraphLayout,
+ colors: GraphColors,
+ runState: RunGraphState?,
+ textMeasurer: TextMeasurer,
+) {
+ for (edge in layout.edges) {
+ val route = GraphRoute(edge.edge.source, edge.edge.outcome, edge.edge.target)
+ val executed = runState == null || route in runState.takenRoutes
+ val color = outcomeColor(edge.edge, colors)
+ val alpha = if (executed) 1f else 0.25f
+ val path = Path()
+ path.moveTo(edge.from.x, edge.from.y)
+ if (edge.backEdge) {
+ val dip = maxOf(edge.from.y, edge.to.y) + 64f
+ path.cubicTo(edge.from.x + 24f, dip, edge.to.x - 24f, dip, edge.to.x, edge.to.y)
+ } else {
+ val midX = (edge.from.x + edge.to.x) / 2f
+ path.cubicTo(midX, edge.from.y, midX, edge.to.y, edge.to.x, edge.to.y)
+ }
+ drawPath(path, color = color.copy(alpha = alpha), style = Stroke(width = 3f))
+ drawArrowHead(edge.from, edge.to, color.copy(alpha = alpha))
+
+ val label = edge.edge.label
+ val measured = textMeasurer.measure(label, TextStyle(fontSize = 11.sp, color = color.copy(alpha = alpha)))
+ drawText(
+ textMeasurer = textMeasurer,
+ text = label,
+ topLeft = Offset(edge.from.x + 8f, edge.from.y - measured.size.height - 4f),
+ style = TextStyle(fontSize = 11.sp, color = color.copy(alpha = alpha)),
+ )
+ }
+}
+
+private fun DrawScope.drawArrowHead(from: Offset, to: Offset, color: Color) {
+ val angle = kotlin.math.atan2((to.y - from.y).toDouble(), (to.x - from.x).toDouble())
+ val size = 12f
+ val left = Offset(
+ x = to.x - size * kotlin.math.cos(angle - 0.5).toFloat(),
+ y = to.y - size * kotlin.math.sin(angle - 0.5).toFloat(),
+ )
+ val right = Offset(
+ x = to.x - size * kotlin.math.cos(angle + 0.5).toFloat(),
+ y = to.y - size * kotlin.math.sin(angle + 0.5).toFloat(),
+ )
+ val head = Path().apply {
+ moveTo(to.x, to.y)
+ lineTo(left.x, left.y)
+ lineTo(right.x, right.y)
+ close()
+ }
+ drawPath(head, color)
+}
+
+private fun DrawScope.drawNodes(
+ layout: GraphLayout,
+ colors: GraphColors,
+ runState: RunGraphState?,
+ selectedStage: String?,
+ textMeasurer: TextMeasurer,
+) {
+ for (node in layout.nodes) {
+ val executed = runState == null || node.key in runState.visitedStages
+ val selected = node.key == selectedStage
+ val alpha = if (executed) 1f else 0.3f
+ val fill = when {
+ node.terminal -> colors.terminalFill
+ selected -> colors.nodeFillActive
+ else -> colors.nodeFill
+ }.copy(alpha = alpha)
+ val border = when {
+ node.terminal -> colors.success
+ else -> colors.nodeBorder
+ }.copy(alpha = alpha)
+ val topLeft = Offset(node.x, node.y)
+ drawRoundRect(
+ color = fill,
+ topLeft = topLeft,
+ size = Size(node.width, node.height),
+ cornerRadius = androidx.compose.ui.geometry.CornerRadius(14f, 14f),
+ )
+ drawRoundRect(
+ color = border,
+ topLeft = topLeft,
+ size = Size(node.width, node.height),
+ cornerRadius = androidx.compose.ui.geometry.CornerRadius(14f, 14f),
+ style = Stroke(width = if (selected) 4f else 2f),
+ )
+ val label = "[" + node.label + "]"
+ val measured = textMeasurer.measure(
+ label,
+ TextStyle(fontSize = 13.sp, fontWeight = FontWeight.Medium, color = colors.nodeText.copy(alpha = alpha)),
+ )
+ drawText(
+ textMeasurer = textMeasurer,
+ text = label,
+ topLeft = Offset(
+ node.x + (node.width - measured.size.width) / 2f,
+ node.y + (node.height - measured.size.height) / 2f,
+ ),
+ style = TextStyle(fontSize = 13.sp, fontWeight = FontWeight.Medium, color = colors.nodeText.copy(alpha = alpha)),
+ )
+ }
+}
+
+private fun outcomeColor(edge: GraphEdge, colors: GraphColors): Color = when (edge.outcome) {
+ "error" -> colors.error
+ "success" -> colors.success
+ else -> colors.accent[abs(edge.outcome.hashCode()) % colors.accent.size]
+}
+
+/** A screen-reader description so meaning is never conveyed by colour alone. */
+private fun graphDescription(graph: Graph, runState: RunGraphState?): String {
+ if (graph.stages.isEmpty()) return "Empty workflow graph"
+ val builder = StringBuilder("Workflow graph with ${graph.stages.size} stages. ")
+ for (stage in graph.stages) {
+ val executed = runState == null || stage.key in runState.visitedStages
+ builder.append("Stage ${stage.key}")
+ if (runState != null) builder.append(if (executed) ", executed" else ", not executed")
+ builder.append(". ")
+ for (outcome in GraphSemantics.outcomes(stage)) {
+ val target = Protocol.resolveTarget(outcome, stage.edges[outcome] ?: continue)
+ val label = GraphSemantics.edgeLabel(stage, outcome)
+ builder.append("Outcome $label goes to ${GraphSemantics.nodeLabel(target)}. ")
+ }
+ }
+ return builder.toString()
+}
+
+private const val MIN_SCALE = 0.3f
+private const val MAX_SCALE = 3f
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt
new file mode 100644
index 00000000..d390ee46
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineDetailScreen.kt
@@ -0,0 +1,218 @@
+package net.awan.pipelines.ui.screens
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import net.awan.pipelines.data.ErrorMessages
+import net.awan.pipelines.data.protocol.PipelineDetail
+import net.awan.pipelines.ui.AppViewModel
+import net.awan.pipelines.ui.components.ErrorState
+import net.awan.pipelines.ui.components.KeyValueRow
+import net.awan.pipelines.ui.components.LoadingState
+import net.awan.pipelines.ui.graph.WorkflowGraph
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun PipelineDetailScreen(
+ vm: AppViewModel,
+ pipelineId: Long,
+ version: Int,
+ onBack: () -> Unit,
+ onOpenRun: (Long) -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ val state by vm.pipelineDetail.collectAsStateWithLifecycle()
+ var showStart by remember { mutableStateOf(false) }
+
+ LaunchedEffect(pipelineId, version) { vm.loadPipeline(pipelineId, version) }
+
+ val detail = state.data?.takeIf { it.id == pipelineId }
+
+ Scaffold(
+ modifier = modifier,
+ topBar = {
+ TopAppBar(
+ title = { Text(detail?.name ?: "Pipeline") },
+ navigationIcon = {
+ IconButton(onClick = onBack) {
+ Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Back")
+ }
+ },
+ actions = {
+ IconButton(onClick = { vm.loadPipeline(pipelineId, version) }) {
+ Icon(Icons.Default.Refresh, contentDescription = "Refresh pipeline")
+ }
+ IconButton(onClick = { showStart = true }, enabled = detail != null) {
+ Icon(Icons.Default.PlayArrow, contentDescription = "Start run")
+ }
+ },
+ )
+ },
+ ) { padding ->
+ when {
+ detail == null && state.error != null -> ErrorState(
+ state.error!!,
+ onRetry = { vm.loadPipeline(pipelineId, version) },
+ modifier = Modifier.padding(padding),
+ )
+ detail == null -> LoadingState("Loading pipeline…", Modifier.padding(padding))
+ else -> PipelineDetailContent(detail, Modifier.padding(padding))
+ }
+ }
+
+ if (showStart && detail != null) {
+ StartRunDialog(
+ vm = vm,
+ detail = detail,
+ onDismiss = { showStart = false },
+ onStarted = { runId ->
+ showStart = false
+ onOpenRun(runId)
+ },
+ )
+ }
+}
+
+@Composable
+private fun PipelineDetailContent(detail: PipelineDetail, modifier: Modifier = Modifier) {
+ Column(
+ modifier = modifier
+ .fillMaxSize()
+ .verticalScroll(rememberScrollState())
+ .padding(16.dp),
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ Text("${detail.name}", style = MaterialTheme.typography.headlineSmall)
+ Text(
+ "id ${detail.id} · v${detail.version} · ${detail.graph.stages.size} stages",
+ style = MaterialTheme.typography.bodyMedium,
+ )
+ KeyValueRow("Content hash", detail.contentHash)
+ KeyValueRow("Latest version", if (detail.latestVersion > 0) "v${detail.latestVersion}" else "")
+ KeyValueRow("Version created", detail.versionCreatedAt)
+ KeyValueRow("Pipeline created", detail.createdAt)
+ KeyValueRow("Pipeline updated", detail.updatedAt)
+
+ if (detail.versions.isNotEmpty()) {
+ Text("Versions", style = MaterialTheme.typography.titleMedium)
+ detail.versions.forEach { v ->
+ Card(Modifier.fillMaxWidth()) {
+ Row(Modifier.padding(12.dp), horizontalArrangement = Arrangement.spacedBy(12.dp)) {
+ Text("v${v.version}", style = MaterialTheme.typography.titleSmall)
+ Text("${v.stages} stages", style = MaterialTheme.typography.bodySmall)
+ Text(v.createdAt, style = MaterialTheme.typography.bodySmall)
+ }
+ }
+ }
+ }
+
+ Text("Workflow graph", style = MaterialTheme.typography.titleMedium)
+ Text(
+ "Pinch to zoom, drag to pan. Edges are labelled with their outcome; error* is the implicit fallback.",
+ style = MaterialTheme.typography.bodySmall,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ )
+ Box(Modifier.fillMaxWidth().height(360.dp)) {
+ WorkflowGraph(graph = detail.graph, modifier = Modifier.fillMaxSize())
+ }
+
+ if (detail.source.isNotBlank()) {
+ Text("Source", style = MaterialTheme.typography.titleMedium)
+ Card(Modifier.fillMaxWidth()) {
+ Text(
+ text = detail.source,
+ fontFamily = FontFamily.Monospace,
+ style = MaterialTheme.typography.bodySmall,
+ modifier = Modifier.padding(12.dp),
+ )
+ }
+ }
+ }
+}
+
+@Composable
+private fun StartRunDialog(
+ vm: AppViewModel,
+ detail: PipelineDetail,
+ onDismiss: () -> Unit,
+ onStarted: (Long) -> Unit,
+) {
+ var prompt by remember { mutableStateOf("") }
+ var submitting by remember { mutableStateOf(false) }
+ var error by remember { mutableStateOf(null) }
+ val workspace by vm.configuredWorkspace.collectAsStateWithLifecycle()
+
+ AlertDialog(
+ onDismissRequest = { if (!submitting) onDismiss() },
+ title = { Text("Start run: ${detail.name} v${detail.version}") },
+ text = {
+ Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+ OutlinedTextField(
+ value = prompt,
+ onValueChange = { prompt = it },
+ label = { Text("Prompt (required)") },
+ enabled = !submitting,
+ minLines = 2,
+ modifier = Modifier.fillMaxWidth(),
+ )
+ Text(
+ "Workspace: ${workspace.ifBlank { "(not set — configure it in Settings)" }}",
+ style = MaterialTheme.typography.bodySmall,
+ )
+ if (error != null) {
+ Text(error!!, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+ }
+ }
+ },
+ confirmButton = {
+ Button(
+ enabled = !submitting && prompt.isNotBlank() && workspace.isNotBlank(),
+ onClick = {
+ submitting = true
+ error = null
+ vm.startRun(detail.id, detail.version, prompt) { result ->
+ submitting = false
+ result.onSuccess { onStarted(it.id) }
+ .onFailure { error = ErrorMessages.describe(it) }
+ }
+ },
+ ) { Text(if (submitting) "Starting…" else "Start") }
+ },
+ dismissButton = {
+ TextButton(onClick = onDismiss, enabled = !submitting) { Text("Cancel") }
+ },
+ )
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt
new file mode 100644
index 00000000..0ba3f1b3
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/PipelineListScreen.kt
@@ -0,0 +1,118 @@
+package net.awan.pipelines.ui.screens
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material3.Card
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import net.awan.pipelines.data.protocol.PipelineSummary
+import net.awan.pipelines.ui.AppViewModel
+import net.awan.pipelines.ui.components.EmptyState
+import net.awan.pipelines.ui.components.ErrorState
+import net.awan.pipelines.ui.components.LoadingState
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun PipelineListScreen(
+ vm: AppViewModel,
+ onOpen: (id: Long, version: Int) -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ val state by vm.pipelines.collectAsStateWithLifecycle()
+ var query by remember { mutableStateOf("") }
+
+ LaunchedEffect(Unit) { vm.refreshPipelines() }
+
+ Scaffold(
+ modifier = modifier,
+ topBar = {
+ TopAppBar(
+ title = { Text("Pipelines") },
+ actions = {
+ IconButton(onClick = vm::refreshPipelines) {
+ Icon(Icons.Default.Refresh, contentDescription = "Refresh pipelines")
+ }
+ },
+ )
+ },
+ ) { padding ->
+ Column(Modifier.fillMaxSize().padding(padding)) {
+ OutlinedTextField(
+ value = query,
+ onValueChange = { query = it },
+ label = { Text("Search pipelines") },
+ leadingIcon = { Icon(Icons.Default.Search, contentDescription = null) },
+ singleLine = true,
+ modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp),
+ )
+ when {
+ state.loading && state.data == null -> LoadingState("Loading pipelines…")
+ state.error != null && state.data == null -> ErrorState(state.error!!, onRetry = vm::refreshPipelines)
+ else -> {
+ val items = (state.data ?: emptyList())
+ .filter { it.name.contains(query, ignoreCase = true) }
+ if (items.isEmpty()) {
+ EmptyState(
+ if (query.isBlank()) "No pipelines are defined on this server."
+ else "No pipelines match \"$query\".",
+ )
+ } else {
+ LazyColumn(
+ modifier = Modifier.fillMaxSize(),
+ contentPadding = androidx.compose.foundation.layout.PaddingValues(16.dp),
+ verticalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ items(items, key = { it.id }) { pipeline ->
+ PipelineRow(pipeline) { onOpen(pipeline.id, pipeline.version) }
+ }
+ }
+ }
+ }
+ }
+ if (state.error != null && state.data != null) {
+ Text(
+ text = state.error!!,
+ color = MaterialTheme.colorScheme.error,
+ modifier = Modifier.padding(16.dp),
+ )
+ }
+ }
+ }
+}
+
+@Composable
+private fun PipelineRow(pipeline: PipelineSummary, onClick: () -> Unit) {
+ Card(modifier = Modifier.fillMaxWidth().clickable(onClick = onClick)) {
+ Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+ Text(pipeline.name, style = MaterialTheme.typography.titleMedium)
+ Text("id ${pipeline.id} · v${pipeline.version} · ${pipeline.stages} stages", style = MaterialTheme.typography.bodySmall)
+ if (pipeline.updatedAt.isNotBlank()) {
+ Text("updated ${pipeline.updatedAt}", style = MaterialTheme.typography.bodySmall)
+ }
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt
new file mode 100644
index 00000000..bded395d
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt
@@ -0,0 +1,374 @@
+package net.awan.pipelines.ui.screens
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.Cancel
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material.icons.filled.Replay
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import kotlinx.coroutines.delay
+import net.awan.pipelines.data.ErrorMessages
+import net.awan.pipelines.data.protocol.FileChange
+import net.awan.pipelines.data.protocol.NotificationReceipt
+import net.awan.pipelines.data.protocol.RunDetail
+import net.awan.pipelines.data.protocol.RunGraphState
+import net.awan.pipelines.data.protocol.RunStep
+import net.awan.pipelines.data.protocol.SessionEvidence
+import net.awan.pipelines.ui.AppViewModel
+import net.awan.pipelines.ui.LoadState
+import net.awan.pipelines.ui.components.ErrorState
+import net.awan.pipelines.ui.components.KeyValueRow
+import net.awan.pipelines.ui.components.LoadingState
+import net.awan.pipelines.ui.displayMap
+import net.awan.pipelines.ui.formatDuration
+import net.awan.pipelines.ui.graph.WorkflowGraph
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun RunDetailScreen(
+ vm: AppViewModel,
+ runId: Long,
+ onBack: () -> Unit,
+ modifier: Modifier = Modifier,
+) {
+ val state by vm.runDetail.collectAsStateWithLifecycle()
+ val evidenceState by vm.evidence.collectAsStateWithLifecycle()
+ var confirmCancel by remember { mutableStateOf(false) }
+ var confirmRetry by remember { mutableStateOf(false) }
+ var actionError by remember { mutableStateOf(null) }
+
+ LaunchedEffect(runId) {
+ // Scope evidence to this run: drop the previous run's records, then fetch
+ // this run's evidence once (on demand; never part of the 1s poll).
+ vm.resetEvidence()
+ vm.loadRun(runId)
+ vm.loadEvidence(runId)
+ }
+
+ val run = state.data?.takeIf { it.id == runId }
+ val executing = run?.executing == true
+
+ // Bounded polling: only while the run is executing, stopped on terminal status.
+ LaunchedEffect(runId, executing) {
+ if (executing) {
+ while (true) {
+ delay(POLL_INTERVAL_MILLIS)
+ vm.loadRun(runId, silent = true)
+ }
+ }
+ }
+
+ Scaffold(
+ modifier = modifier,
+ topBar = {
+ TopAppBar(
+ title = { Text(run?.let { "Run ${it.id}" } ?: "Run") },
+ navigationIcon = {
+ IconButton(onClick = onBack) {
+ Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Back")
+ }
+ },
+ actions = {
+ IconButton(onClick = { vm.loadRun(runId) }) {
+ Icon(Icons.Default.Refresh, contentDescription = "Refresh run")
+ }
+ if (executing) {
+ IconButton(onClick = { confirmCancel = true }) {
+ Icon(Icons.Default.Cancel, contentDescription = "Cancel run")
+ }
+ }
+ if (run != null && !executing && run.status == "failed") {
+ IconButton(onClick = { confirmRetry = true }) {
+ Icon(Icons.Default.Replay, contentDescription = "Retry run")
+ }
+ }
+ },
+ )
+ },
+ ) { padding ->
+ when {
+ run == null && state.error != null -> ErrorState(
+ state.error!!,
+ onRetry = { vm.loadRun(runId) },
+ modifier = Modifier.padding(padding),
+ )
+ run == null -> LoadingState("Loading run…", Modifier.padding(padding))
+ else -> RunDetailContent(
+ run = run,
+ onLoadEvidence = { vm.loadEvidence(runId) },
+ evidenceState = evidenceState,
+ modifier = Modifier.padding(padding),
+ )
+ }
+ }
+
+ if (actionError != null) {
+ AlertDialog(
+ onDismissRequest = { actionError = null },
+ title = { Text("Action failed") },
+ text = { Text(actionError!!) },
+ confirmButton = { TextButton(onClick = { actionError = null }) { Text("OK") } },
+ )
+ }
+
+ if (confirmCancel) {
+ ConfirmDialog(
+ title = "Cancel run $runId?",
+ message = "This asks the server to stop the active run.",
+ confirmLabel = "Cancel run",
+ onConfirm = {
+ confirmCancel = false
+ vm.cancelRun(runId) { result ->
+ result.onFailure { actionError = ErrorMessages.describe(it) }
+ vm.loadRun(runId, silent = true)
+ }
+ },
+ onDismiss = { confirmCancel = false },
+ )
+ }
+
+ if (confirmRetry) {
+ ConfirmDialog(
+ title = "Retry run $runId?",
+ message = "Only failed runs can be retried. The server starts a new run from the same input.",
+ confirmLabel = "Retry",
+ onConfirm = {
+ confirmRetry = false
+ vm.retryRun(runId) { result ->
+ result.onFailure { actionError = ErrorMessages.describe(it) }
+ vm.loadRun(runId, silent = true)
+ }
+ },
+ onDismiss = { confirmRetry = false },
+ )
+ }
+}
+
+@Composable
+private fun ConfirmDialog(
+ title: String,
+ message: String,
+ confirmLabel: String,
+ onConfirm: () -> Unit,
+ onDismiss: () -> Unit,
+) {
+ AlertDialog(
+ onDismissRequest = onDismiss,
+ title = { Text(title) },
+ text = { Text(message) },
+ confirmButton = { Button(onClick = onConfirm) { Text(confirmLabel) } },
+ dismissButton = { TextButton(onClick = onDismiss) { Text("Keep") } },
+ )
+}
+
+@Composable
+private fun RunDetailContent(
+ run: RunDetail,
+ onLoadEvidence: () -> Unit,
+ evidenceState: LoadState>,
+ modifier: Modifier = Modifier,
+) {
+ val runState = remember(run.id, run.steps) { RunGraphState.from(run) }
+ Column(
+ modifier = modifier
+ .fillMaxSize()
+ .verticalScroll(rememberScrollState())
+ .padding(16.dp),
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ Text(run.name, style = MaterialTheme.typography.headlineSmall)
+ Text(
+ buildString {
+ append("run ${run.id} · ${run.status.ifBlank { "unknown" }}")
+ if (run.outcome.isNotBlank()) append(" · outcome ${run.outcome}")
+ if (run.executing) append(" · executing")
+ append(" · ${run.steps.size} recorded visits")
+ },
+ style = MaterialTheme.typography.bodyMedium,
+ )
+ KeyValueRow("Pipeline", "id ${run.pipelineId} · v${run.version}")
+ KeyValueRow("Workspace", run.workspace)
+ KeyValueRow("Content hash", run.contentHash)
+ KeyValueRow("Started", run.createdAt)
+ KeyValueRow("Finished", run.finishedAt)
+ KeyValueRow("Duration", formatDuration(run.createdAt, run.finishedAt) ?: "")
+ if (run.diagnostic.isNotBlank()) {
+ Text(run.diagnostic, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodyMedium)
+ }
+
+ if (run.graph.stages.isNotEmpty()) {
+ Text("Run graph", style = MaterialTheme.typography.titleMedium)
+ Text(
+ "Executed stages and routes are highlighted; the rest are dimmed. Pinch to zoom, drag to pan.",
+ style = MaterialTheme.typography.bodySmall,
+ color = MaterialTheme.colorScheme.onSurfaceVariant,
+ )
+ Box(Modifier.fillMaxWidth().height(340.dp)) {
+ WorkflowGraph(
+ graph = run.graph,
+ modifier = Modifier.fillMaxSize(),
+ runState = runState,
+ selectedStage = runState.currentStage,
+ )
+ }
+ } else {
+ Text("This server did not include the run graph.", style = MaterialTheme.typography.bodySmall)
+ }
+
+ val input = run.input.displayMap()
+ if (input.isNotBlank()) {
+ Text("Input", style = MaterialTheme.typography.titleMedium)
+ Card(Modifier.fillMaxWidth()) {
+ Text(input, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall, modifier = Modifier.padding(12.dp))
+ }
+ }
+ val output = run.output.displayMap()
+ if (output.isNotBlank()) {
+ Text("Output", style = MaterialTheme.typography.titleMedium)
+ Card(Modifier.fillMaxWidth()) {
+ Text(output, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall, modifier = Modifier.padding(12.dp))
+ }
+ }
+
+ Text("Session evidence", style = MaterialTheme.typography.titleMedium)
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ OutlinedButton(onClick = onLoadEvidence, enabled = !evidenceState.loading) {
+ Text(if (evidenceState.loading) "Loading…" else "Reload session evidence")
+ }
+ }
+ when {
+ evidenceState.loading && evidenceState.data == null ->
+ Text("Loading session evidence…", style = MaterialTheme.typography.bodySmall)
+ evidenceState.error != null ->
+ Text(evidenceState.error!!, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+ evidenceState.loaded && evidenceState.data.isNullOrEmpty() ->
+ Text("No session evidence recorded.", style = MaterialTheme.typography.bodySmall)
+ else -> evidenceState.data.orEmpty().forEach { EvidenceCard(it) }
+ }
+
+ Text("Steps", style = MaterialTheme.typography.titleMedium)
+ if (run.steps.isEmpty()) {
+ Text("No steps recorded.", style = MaterialTheme.typography.bodySmall)
+ } else {
+ run.steps.forEach { StepCard(it) }
+ }
+ }
+}
+
+@Composable
+private fun StepCard(step: RunStep) {
+ Card(Modifier.fillMaxWidth()) {
+ Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ Text("${step.sequence}. ${step.stage}", style = MaterialTheme.typography.titleSmall)
+ Text(step.status, style = MaterialTheme.typography.bodySmall)
+ if (step.outcome.isNotBlank()) Text("outcome ${step.outcome}", style = MaterialTheme.typography.bodySmall)
+ if (step.agentActive) Text("agent active", style = MaterialTheme.typography.bodySmall)
+ }
+ if (step.target.isNotBlank()) Text("target ${step.target}", style = MaterialTheme.typography.bodySmall)
+ val duration = formatDuration(step.startedAt, step.finishedAt)
+ if (duration != null) Text("took $duration", style = MaterialTheme.typography.bodySmall)
+ if (step.sessionId.isNotBlank()) Text("session ${step.sessionId}", style = MaterialTheme.typography.bodySmall)
+ if (step.diagnostic.isNotBlank()) {
+ Text(step.diagnostic, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+ }
+ step.control?.let { control ->
+ Text(
+ "visit ${control.visit}/${control.maxVisits}" +
+ (if (control.limitReached) " · limit reached" else "") +
+ (control.modelTarget?.let { " · model $it" } ?: ""),
+ style = MaterialTheme.typography.bodySmall,
+ )
+ }
+ val input = step.input.displayMap()
+ if (input.isNotBlank()) Text("input:\n$input", fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall)
+ val output = step.output.displayMap()
+ if (output.isNotBlank()) Text("output:\n$output", fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall)
+ step.fileChanges?.let { changes ->
+ Text(
+ "file changes: ${changes.status}" +
+ (if (changes.files.isNotEmpty()) " (${changes.files.size})" else "") +
+ (if (changes.skipped > 0) " · ${changes.skipped} skipped" else ""),
+ style = MaterialTheme.typography.bodySmall,
+ )
+ changes.files.take(MAX_LISTED_FILES).forEach { file -> FileChangeRow(file) }
+ }
+ step.notifications.orEmpty().forEach { notification -> NotificationRow(notification) }
+ if (step.transcript.isNotBlank()) {
+ Text("transcript", style = MaterialTheme.typography.labelMedium)
+ Text(step.transcript, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall)
+ }
+ }
+ }
+}
+
+@Composable
+private fun FileChangeRow(file: FileChange) {
+ Text(
+ "· ${file.kind} ${file.path}" +
+ (if (file.binary) " (binary)" else "") +
+ (if (file.truncated) " (truncated)" else ""),
+ style = MaterialTheme.typography.bodySmall,
+ )
+}
+
+@Composable
+private fun NotificationRow(receipt: NotificationReceipt) {
+ Text(
+ "notification ${receipt.status} → ${receipt.destination}" +
+ (receipt.diagnostic?.let { " · $it" } ?: ""),
+ style = MaterialTheme.typography.bodySmall,
+ )
+}
+
+@Composable
+private fun EvidenceCard(evidence: SessionEvidence) {
+ Card(Modifier.fillMaxWidth()) {
+ Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+ Text("Evidence ${evidence.sequence}", style = MaterialTheme.typography.titleSmall)
+ if (evidence.sessionId.isNotBlank()) Text("session ${evidence.sessionId}", style = MaterialTheme.typography.bodySmall)
+ if (evidence.backend.isNotBlank()) Text("backend ${evidence.backend}", style = MaterialTheme.typography.bodySmall)
+ if (evidence.directory.isNotBlank()) Text("directory ${evidence.directory}", style = MaterialTheme.typography.bodySmall)
+ if (!evidence.diagnostic.isNullOrBlank()) {
+ Text(evidence.diagnostic, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodySmall)
+ }
+ if (!evidence.data.isNullOrBlank()) {
+ Text(evidence.data, fontFamily = FontFamily.Monospace, style = MaterialTheme.typography.bodySmall)
+ }
+ }
+ }
+}
+
+private const val POLL_INTERVAL_MILLIS = 1_000L
+private const val MAX_LISTED_FILES = 20
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt
new file mode 100644
index 00000000..636942d2
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt
@@ -0,0 +1,143 @@
+package net.awan.pipelines.ui.screens
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.Card
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import net.awan.pipelines.data.protocol.RunSummary
+import net.awan.pipelines.data.protocol.UsageStats
+import net.awan.pipelines.ui.AppViewModel
+import net.awan.pipelines.ui.components.EmptyState
+import net.awan.pipelines.ui.components.ErrorState
+import net.awan.pipelines.ui.components.LoadingState
+import net.awan.pipelines.ui.formatDuration
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun RunHistoryScreen(
+ vm: AppViewModel,
+ onOpenRun: (Long) -> Unit,
+ modifier: Modifier = Modifier,
+ filterPipelineId: Long? = null,
+) {
+ val state by vm.runs.collectAsStateWithLifecycle()
+ LaunchedEffect(Unit) { vm.refreshRuns() }
+
+ Scaffold(
+ modifier = modifier,
+ topBar = {
+ TopAppBar(
+ title = { Text(if (filterPipelineId == null) "Runs" else "Runs for this pipeline") },
+ actions = {
+ IconButton(onClick = vm::refreshRuns) {
+ Icon(Icons.Default.Refresh, contentDescription = "Refresh runs")
+ }
+ },
+ )
+ },
+ ) { padding ->
+ when {
+ state.loading && state.data == null -> LoadingState("Loading runs…", Modifier.padding(padding))
+ state.error != null && state.data == null -> ErrorState(
+ state.error!!,
+ onRetry = vm::refreshRuns,
+ modifier = Modifier.padding(padding),
+ )
+ else -> {
+ val history = state.data
+ val runs = history?.runs.orEmpty()
+ .filter { filterPipelineId == null || it.pipelineId == filterPipelineId }
+ Column(Modifier.fillMaxSize().padding(padding)) {
+ history?.usage?.let { UsageCard(it) }
+ if (runs.isEmpty()) {
+ EmptyState("No runs have been recorded yet.")
+ } else {
+ LazyColumn(
+ modifier = Modifier.fillMaxSize(),
+ contentPadding = PaddingValues(16.dp),
+ verticalArrangement = Arrangement.spacedBy(8.dp),
+ ) {
+ items(runs, key = { it.id }) { run -> RunRow(run) { onOpenRun(run.id) } }
+ }
+ }
+ if (state.error != null) {
+ Text(state.error!!, color = MaterialTheme.colorScheme.error, modifier = Modifier.padding(16.dp))
+ }
+ }
+ }
+ }
+ }
+}
+
+@Composable
+private fun UsageCard(usage: UsageStats) {
+ Card(Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp)) {
+ Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+ Text("Usage", style = MaterialTheme.typography.titleMedium)
+ Text(
+ "total ${usage.total} · succeeded ${usage.succeeded} · failed ${usage.failed} · " +
+ "canceled ${usage.canceled} · interrupted ${usage.interrupted} · active ${usage.active}",
+ style = MaterialTheme.typography.bodySmall,
+ )
+ if (usage.averageSeconds > 0) {
+ Text("average ${"%.1f".format(usage.averageSeconds)}s", style = MaterialTheme.typography.bodySmall)
+ }
+ }
+ }
+}
+
+@Composable
+private fun RunRow(run: RunSummary, onClick: () -> Unit) {
+ Card(Modifier.fillMaxWidth().clickable(onClick = onClick)) {
+ Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(2.dp)) {
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ Text(run.name, style = MaterialTheme.typography.titleMedium)
+ Text("v${run.version}", style = MaterialTheme.typography.bodySmall)
+ }
+ Text(
+ buildString {
+ append("run ${run.id} · ${run.status.ifBlank { "unknown" }}")
+ if (run.outcome.isNotBlank()) append(" · outcome ${run.outcome}")
+ if (run.executing) append(" · executing")
+ if (run.currentStage.isNotBlank()) append(" · stage ${run.currentStage}")
+ append(" · ${run.completedSteps} steps")
+ },
+ style = MaterialTheme.typography.bodySmall,
+ )
+ val duration = formatDuration(run.createdAt, run.finishedAt)
+ val timing = buildString {
+ append("started ${run.createdAt}")
+ if (duration != null) append(" · took $duration")
+ }
+ if (run.createdAt.isNotBlank()) Text(timing, style = MaterialTheme.typography.bodySmall)
+ if (run.diagnostic.isNotBlank()) {
+ Text(run.diagnostic, style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.error)
+ }
+ if (!run.resultPreview.isNullOrBlank()) {
+ Text(run.resultPreview, style = MaterialTheme.typography.bodySmall)
+ }
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/SettingsScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/SettingsScreen.kt
new file mode 100644
index 00000000..62b88560
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/SettingsScreen.kt
@@ -0,0 +1,141 @@
+package net.awan.pipelines.ui.screens
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import net.awan.pipelines.data.transport.ConnectionState
+import net.awan.pipelines.ui.AppViewModel
+
+@Composable
+fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier) {
+ val serverUrl by vm.serverUrlDraft.collectAsStateWithLifecycle()
+ val workspace by vm.workspaceDraft.collectAsStateWithLifecycle()
+ val urlError by vm.urlError.collectAsStateWithLifecycle()
+ val state by vm.connectionState.collectAsStateWithLifecycle()
+ val build by vm.serverBuild.collectAsStateWithLifecycle()
+ val serverTime by vm.serverTime.collectAsStateWithLifecycle()
+ val configuredWorkspace by vm.configuredWorkspace.collectAsStateWithLifecycle()
+ val workspaceError by vm.workspaceError.collectAsStateWithLifecycle()
+
+ Column(
+ modifier = modifier
+ .fillMaxSize()
+ .verticalScroll(rememberScrollState())
+ .padding(16.dp),
+ verticalArrangement = Arrangement.spacedBy(12.dp),
+ ) {
+ Text("Connection", style = MaterialTheme.typography.headlineSmall)
+
+ OutlinedTextField(
+ value = serverUrl,
+ onValueChange = vm::updateServerUrlDraft,
+ label = { Text("Server URL") },
+ placeholder = { Text("ws://192.168.1.20:8081/connect") },
+ singleLine = true,
+ isError = urlError != null,
+ keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Uri),
+ supportingText = {
+ Text(urlError ?: "ws:// on a trusted LAN/VPN, or wss:// through a proxy/VPN. No authentication is used.")
+ },
+ modifier = Modifier.fillMaxWidth(),
+ )
+
+ Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+ Button(onClick = vm::connect) { Text("Connect") }
+ if (state is ConnectionState.Connected || state is ConnectionState.Connecting) {
+ OutlinedButton(onClick = vm::disconnect) { Text("Disconnect") }
+ } else {
+ OutlinedButton(onClick = vm::reconnect) { Text("Reconnect") }
+ }
+ }
+
+ ConnectionStatusCard(state, build?.version, build?.commit, serverTime)
+
+ Card(colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.errorContainer)) {
+ Text(
+ text = "Trusted LAN/VPN only. The Pipelines API has no authentication and is not " +
+ "internet-safe. Do not expose it to untrusted networks, and never enter provider " +
+ "credentials here \u2014 the app stores none.",
+ style = MaterialTheme.typography.bodyMedium,
+ color = MaterialTheme.colorScheme.onErrorContainer,
+ modifier = Modifier.padding(16.dp),
+ )
+ }
+
+ Text("Workspace", style = MaterialTheme.typography.headlineSmall)
+
+ OutlinedTextField(
+ value = workspace,
+ onValueChange = vm::updateWorkspaceDraft,
+ label = { Text("Workspace path (on the server)") },
+ placeholder = { Text("/Users/you/repos/pipelines") },
+ singleLine = true,
+ isError = workspaceError != null,
+ supportingText = {
+ Text(
+ workspaceError
+ ?: "An absolute directory that already exists on the execution server. For Docker, " +
+ "mount the host directory at the same absolute path with its owner's UID/GID. " +
+ "This is not the phone's storage.",
+ )
+ },
+ modifier = Modifier.fillMaxWidth(),
+ )
+ Button(onClick = vm::saveWorkspace, enabled = workspaceError == null) { Text("Save workspace") }
+ Text("Saved workspace: ${configuredWorkspace.ifBlank { "(none)" }}")
+ }
+}
+
+@Composable
+private fun ConnectionStatusCard(
+ state: ConnectionState,
+ version: String?,
+ commit: String?,
+ serverTime: String?,
+) {
+ Card(modifier = Modifier.fillMaxWidth()) {
+ Column(Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+ when (state) {
+ is ConnectionState.Idle -> Text("Not connected", style = MaterialTheme.typography.titleMedium)
+ is ConnectionState.Connecting -> {
+ Row(verticalAlignment = androidx.compose.ui.Alignment.CenterVertically) {
+ CircularProgressIndicator(Modifier.padding(end = 12.dp))
+ Text("Connecting (attempt ${state.attempt})\u2026")
+ }
+ }
+ is ConnectionState.Connected -> {
+ Text("Connected", style = MaterialTheme.typography.titleMedium, color = MaterialTheme.colorScheme.primary)
+ if (version != null) {
+ Text("Server build ${version}${if (!commit.isNullOrBlank()) " ($commit)" else ""}")
+ }
+ if (serverTime != null) Text("Server time $serverTime")
+ }
+ is ConnectionState.Disconnected -> {
+ Text("Disconnected", style = MaterialTheme.typography.titleMedium, color = MaterialTheme.colorScheme.error)
+ Text(state.message)
+ if (state.retrying) Text("Retrying with backoff\u2026")
+ }
+ }
+ }
+ }
+}
diff --git a/android/app/src/main/java/net/awan/pipelines/ui/theme/Theme.kt b/android/app/src/main/java/net/awan/pipelines/ui/theme/Theme.kt
new file mode 100644
index 00000000..51253138
--- /dev/null
+++ b/android/app/src/main/java/net/awan/pipelines/ui/theme/Theme.kt
@@ -0,0 +1,29 @@
+package net.awan.pipelines.ui.theme
+
+import android.os.Build
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.dynamicDarkColorScheme
+import androidx.compose.material3.dynamicLightColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.platform.LocalContext
+
+/** Material 3 theming with optional dynamic color and dark-mode support. */
+@Composable
+fun PipelinesTheme(
+ darkTheme: Boolean = isSystemInDarkTheme(),
+ dynamicColor: Boolean = true,
+ content: @Composable () -> Unit,
+) {
+ val context = LocalContext.current
+ val colorScheme = when {
+ dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
+ if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
+ }
+ darkTheme -> darkColorScheme()
+ else -> lightColorScheme()
+ }
+ MaterialTheme(colorScheme = colorScheme, content = content)
+}
diff --git a/android/app/src/main/res/drawable/ic_launcher.xml b/android/app/src/main/res/drawable/ic_launcher.xml
new file mode 100644
index 00000000..d972eadb
--- /dev/null
+++ b/android/app/src/main/res/drawable/ic_launcher.xml
@@ -0,0 +1,15 @@
+
+
+
+
+
diff --git a/android/app/src/main/res/values-night/themes.xml b/android/app/src/main/res/values-night/themes.xml
new file mode 100644
index 00000000..0f0070e6
--- /dev/null
+++ b/android/app/src/main/res/values-night/themes.xml
@@ -0,0 +1,6 @@
+
+
+
+
diff --git a/android/app/src/main/res/values/strings.xml b/android/app/src/main/res/values/strings.xml
new file mode 100644
index 00000000..bf4d70a4
--- /dev/null
+++ b/android/app/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+
+ Pipelines
+
diff --git a/android/app/src/main/res/values/themes.xml b/android/app/src/main/res/values/themes.xml
new file mode 100644
index 00000000..41abc6a9
--- /dev/null
+++ b/android/app/src/main/res/values/themes.xml
@@ -0,0 +1,6 @@
+
+
+
+
diff --git a/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt b/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt
new file mode 100644
index 00000000..0222fc6f
--- /dev/null
+++ b/android/app/src/test/java/net/awan/pipelines/data/protocol/GraphSemanticsTest.kt
@@ -0,0 +1,81 @@
+package net.awan.pipelines.data.protocol
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class GraphSemanticsTest {
+
+ private fun stage(key: String, edges: Map, fallback: Boolean = false) =
+ Stage(key = key, edges = edges, fallbackError = fallback)
+
+ @Test
+ fun outcomeOrderIsSuccessThenOthersThenError() {
+ val s = stage("a", mapOf("error" to "#failure", "retry" to "b", "success" to "#success"))
+ assertEquals(listOf("success", "retry", "error"), GraphSemantics.outcomes(s))
+ }
+
+ @Test
+ fun fallbackErrorIsMarked() {
+ val s = stage("a", mapOf("error" to "#failure"), fallback = true)
+ assertEquals("error*", GraphSemantics.edgeLabel(s, "error"))
+ assertEquals("success", GraphSemantics.edgeLabel(stage("b", mapOf("success" to "#success")), "success"))
+ }
+
+ @Test
+ fun resolvesHashShorthandToTerminal() {
+ assertEquals("#success", Protocol.resolveTarget("success", "#"))
+ assertEquals("#failure", Protocol.resolveTarget("error", "#"))
+ assertEquals("next", Protocol.resolveTarget("success", "next"))
+ assertTrue(Protocol.isTerminal("#success"))
+ assertFalse(Protocol.isTerminal("next"))
+ }
+
+ @Test
+ fun edgesUseStableIdsAndResolvedTargets() {
+ val graph = Graph(
+ stages = listOf(
+ stage("a", mapOf("success" to "b", "error" to "#")),
+ stage("b", mapOf("success" to "#success", "error" to "#"), fallback = true),
+ ),
+ )
+ val edges = graph.edges()
+ assertEquals(4, edges.size)
+ assertEquals(1, edges[0].id)
+ assertEquals("a", edges[0].source)
+ assertEquals("b", edges[0].target)
+ assertEquals("#failure", edges[1].target)
+ assertEquals("error", edges[1].outcome)
+ assertEquals("error*", edges.last().label)
+ assertEquals("#failure", edges.last().target)
+ assertEquals("success", edges[2].label)
+ assertEquals("#success", edges[2].target)
+ }
+
+ @Test
+ fun compactThresholdMatchesTui() {
+ val stages = (1..201).map { stage("s$it", mapOf("success" to "#success")) }
+ assertTrue(GraphSemantics.compactGraph(Graph(stages = stages)))
+ assertFalse(GraphSemantics.compactGraph(Graph(stages = stages.take(10))))
+ }
+
+ @Test
+ fun runGraphStateTracksVisitedStagesAndRoutes() {
+ val run = RunDetail(
+ id = 1,
+ name = "demo",
+ version = 1,
+ status = "failed",
+ currentStage = "b",
+ steps = listOf(
+ RunStep(sequence = 1, stage = "a", outcome = "error", target = "#failure"),
+ RunStep(sequence = 2, stage = "b", outcome = "success", target = "#success"),
+ ),
+ )
+ val state = RunGraphState.from(run)
+ assertEquals(setOf("a", "b", "#failure", "#success"), state.visitedStages)
+ assertTrue(GraphRoute("a", "error", "#failure") in state.takenRoutes)
+ assertEquals("b", state.currentStage)
+ }
+}
diff --git a/android/app/src/test/java/net/awan/pipelines/data/protocol/ProtocolModelTest.kt b/android/app/src/test/java/net/awan/pipelines/data/protocol/ProtocolModelTest.kt
new file mode 100644
index 00000000..90c5e395
--- /dev/null
+++ b/android/app/src/test/java/net/awan/pipelines/data/protocol/ProtocolModelTest.kt
@@ -0,0 +1,219 @@
+package net.awan.pipelines.data.protocol
+
+import kotlinx.serialization.json.JsonPrimitive
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ProtocolModelTest {
+
+ @Test
+ fun parsesEnvelopeWithUnknownFieldsAndNestedDetail() {
+ val json = """
+ {
+ "type": "pipeline",
+ "id": "cli-3",
+ "future_field": {"nested": true},
+ "detail": {
+ "id": 7,
+ "name": "demo",
+ "version": 2,
+ "stages": 3,
+ "latest_version": 2,
+ "content_hash": "abc",
+ "source": "# stage one",
+ "graph": {"stages": [{"key": "one", "edges": {"success": "#success"}, "fallback_error": true}]},
+ "versions": [{"version": 1, "stages": 2, "created_at": "2026-01-01T00:00:00Z"}]
+ }
+ }
+ """.trimIndent()
+ val message = PipelinesJson.decodeFromString(Message.serializer(), json)
+ assertEquals(Protocol.PIPELINE, message.type)
+ assertEquals("cli-3", message.id)
+ val detail = message.detail!!
+ assertEquals(7L, detail.id)
+ assertEquals("demo", detail.name)
+ assertEquals(2, detail.latestVersion)
+ assertEquals(1, detail.versions.size)
+ assertEquals("#success", detail.graph.stages.first().edges["success"])
+ assertTrue(detail.graph.stages.first().fallbackError)
+ }
+
+ @Test
+ fun runDetailWithNullOutputDoesNotCrash() {
+ val json = """
+ {
+ "type": "run",
+ "run_detail": {
+ "id": 11,
+ "pipeline_id": 7,
+ "name": "demo",
+ "version": 2,
+ "status": "failed",
+ "executing": false,
+ "steps": [
+ {"sequence": 1, "stage": "one", "status": "failed", "outcome": "error", "target": "#failure", "output": null}
+ ]
+ }
+ }
+ """.trimIndent()
+ val message = PipelinesJson.decodeFromString(Message.serializer(), json)
+ val run = message.runDetail!!
+ assertEquals(11L, run.id)
+ assertEquals(1, run.steps.size)
+ assertNull(run.output)
+ assertEquals("#failure", run.steps.first().target)
+ }
+
+ @Test
+ fun runRequestRoundTripsRequestKeyAndPrompt() {
+ val request = Message(
+ type = Protocol.RUN_PIPELINE,
+ id = "android-1",
+ pipelineId = 7,
+ version = 2,
+ requestKey = "android-key",
+ workspace = "/work",
+ input = mapOf("prompt" to JsonPrimitive("do it")),
+ )
+ val encoded = PipelinesJson.encodeToString(Message.serializer(), request)
+ val decoded = PipelinesJson.decodeFromString(Message.serializer(), encoded)
+ assertEquals(Protocol.RUN_PIPELINE, decoded.type)
+ assertEquals("android-key", decoded.requestKey)
+ assertEquals(7L, decoded.pipelineId)
+ assertEquals(2, decoded.version)
+ assertEquals("/work", decoded.workspace)
+ assertEquals("do it", decoded.input?.get("prompt")?.let { (it as JsonPrimitive).content })
+ }
+
+ @Test
+ fun cancelRunRequestKeepsRunId() {
+ val request = Message(type = Protocol.CANCEL_RUN, id = "android-2", runId = 11)
+ val encoded = PipelinesJson.encodeToString(Message.serializer(), request)
+ val decoded = PipelinesJson.decodeFromString(Message.serializer(), encoded)
+ assertEquals(Protocol.CANCEL_RUN, decoded.type)
+ assertEquals(11L, decoded.runId)
+ }
+
+ @Test
+ fun pipelineDetailPopulatesInheritedAndWireNameFields() {
+ val json = """
+ {
+ "type": "pipeline",
+ "detail": {
+ "id": 7,
+ "name": "demo",
+ "version": 2,
+ "stages": 3,
+ "created_at": "2026-01-01T00:00:00Z",
+ "updated_at": "2026-01-02T00:00:00Z",
+ "latest_version": 4,
+ "version_created_at": "2026-01-02T00:00:00Z",
+ "content_hash": "abc123",
+ "source": "# stage one",
+ "graph": {"stages": []},
+ "versions": [{"version": 1, "stages": 2, "created_at": "2026-01-01T00:00:00Z"}]
+ }
+ }
+ """.trimIndent()
+ val message = PipelinesJson.decodeFromString(Message.serializer(), json)
+ val detail = message.detail!!
+ assertEquals(7L, detail.id)
+ assertEquals("demo", detail.name)
+ assertEquals(2, detail.version)
+ assertEquals(3, detail.stages)
+ assertEquals("2026-01-01T00:00:00Z", detail.createdAt)
+ assertEquals("2026-01-02T00:00:00Z", detail.updatedAt)
+ assertEquals(4, detail.latestVersion)
+ assertEquals("2026-01-02T00:00:00Z", detail.versionCreatedAt)
+ assertEquals("abc123", detail.contentHash)
+ }
+
+ @Test
+ fun runDetailPopulatesInheritedAndWireNameFields() {
+ val json = """
+ {
+ "type": "run",
+ "run_detail": {
+ "id": 11,
+ "pipeline_id": 7,
+ "name": "demo",
+ "version": 2,
+ "content_hash": "abc",
+ "status": "failed",
+ "executing": false,
+ "outcome": "error",
+ "current_stage": "one",
+ "created_at": "2026-01-01T00:00:00Z",
+ "finished_at": "2026-01-01T00:01:00Z",
+ "diagnostic": "boom",
+ "result_preview": "partial",
+ "completed_steps": 2,
+ "retry_of": 3,
+ "workspace": "/work",
+ "steps": []
+ }
+ }
+ """.trimIndent()
+ val message = PipelinesJson.decodeFromString(Message.serializer(), json)
+ val run = message.runDetail!!
+ assertEquals(11L, run.id)
+ assertEquals(7L, run.pipelineId)
+ assertEquals("abc", run.contentHash)
+ assertEquals("failed", run.status)
+ assertEquals("one", run.currentStage)
+ assertEquals("2026-01-01T00:00:00Z", run.createdAt)
+ assertEquals("2026-01-01T00:01:00Z", run.finishedAt)
+ assertEquals("partial", run.resultPreview)
+ assertEquals(2, run.completedSteps)
+ assertEquals(3L, run.retryOf)
+ assertEquals("/work", run.workspace)
+ }
+
+ @Test
+ fun usageStatsAndPipelineUsagePopulateInheritedCounts() {
+ val json = """
+ {
+ "type": "runs",
+ "usage": {
+ "total": 5,
+ "succeeded": 3,
+ "failed": 1,
+ "canceled": 1,
+ "interrupted": 0,
+ "active": 0,
+ "average_seconds": 12.5,
+ "pipelines": [
+ {
+ "pipeline_id": 7,
+ "name": "demo",
+ "total": 2,
+ "succeeded": 2,
+ "failed": 0,
+ "canceled": 0,
+ "interrupted": 0,
+ "active": 0,
+ "average_seconds": 3.5
+ }
+ ],
+ "days": [{"date": "2026-01-01", "runs": 2}]
+ },
+ "runs": []
+ }
+ """.trimIndent()
+ val message = PipelinesJson.decodeFromString(Message.serializer(), json)
+ val usage = message.usage!!
+ assertEquals(5, usage.total)
+ assertEquals(3, usage.succeeded)
+ assertEquals(1, usage.failed)
+ assertEquals(12.5, usage.averageSeconds, 0.0)
+ assertEquals(1, usage.days.size)
+ val pipeline = usage.pipelines.single()
+ assertEquals(7L, pipeline.pipelineId)
+ assertEquals("demo", pipeline.name)
+ assertEquals(2, pipeline.total)
+ assertEquals(2, pipeline.succeeded)
+ assertEquals(3.5, pipeline.averageSeconds, 0.0)
+ }
+}
diff --git a/android/app/src/test/java/net/awan/pipelines/data/transport/ServerUrlTest.kt b/android/app/src/test/java/net/awan/pipelines/data/transport/ServerUrlTest.kt
new file mode 100644
index 00000000..5d6a5d67
--- /dev/null
+++ b/android/app/src/test/java/net/awan/pipelines/data/transport/ServerUrlTest.kt
@@ -0,0 +1,64 @@
+package net.awan.pipelines.data.transport
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class ServerUrlTest {
+
+ @Test
+ fun acceptsWsWithExplicitPort() {
+ val result = ServerUrl.validate("ws://192.168.1.20:8081/connect")
+ assertTrue(result.valid)
+ assertEquals("ws://192.168.1.20:8081/connect", result.wsUrl)
+ assertEquals("http://192.168.1.20:8081/connect", result.httpUrl)
+ assertEquals("192.168.1.20", result.host)
+ assertEquals(8081, result.port)
+ assertFalse(result.secure)
+ }
+
+ @Test
+ fun defaultsPathToConnect() {
+ val result = ServerUrl.validate("wss://pipelines.example/vpn")
+ assertTrue(result.valid)
+ assertEquals("wss://pipelines.example/vpn", result.wsUrl)
+ assertTrue(result.secure)
+
+ val noPath = ServerUrl.validate("ws://host:8080")
+ assertTrue(noPath.valid)
+ assertEquals("ws://host:8080/connect", noPath.wsUrl)
+ }
+
+ @Test
+ fun rejectsUnsupportedScheme() {
+ val result = ServerUrl.validate("http://192.168.1.20:8081/connect")
+ assertFalse(result.valid)
+ assertEquals(ServerUrl.ErrorKind.UNSUPPORTED_SCHEME, result.kind)
+ }
+
+ @Test
+ fun rejectsMissingHost() {
+ val result = ServerUrl.validate("ws:///connect")
+ assertFalse(result.valid)
+ assertEquals(ServerUrl.ErrorKind.MISSING_HOST, result.kind)
+ }
+
+ @Test
+ fun rejectsUserInfoAndFragment() {
+ assertEquals(
+ ServerUrl.ErrorKind.USER_INFO,
+ ServerUrl.validate("ws://user:pass@host:8080/connect").kind,
+ )
+ assertEquals(
+ ServerUrl.ErrorKind.FRAGMENT,
+ ServerUrl.validate("ws://host:8080/connect#frag").kind,
+ )
+ }
+
+ @Test
+ fun rejectsEmptyAndSchemeLessInput() {
+ assertEquals(ServerUrl.ErrorKind.EMPTY, ServerUrl.validate(" ").kind)
+ assertEquals(ServerUrl.ErrorKind.UNSUPPORTED_SCHEME, ServerUrl.validate("host:8080/connect").kind)
+ }
+}
diff --git a/android/build.gradle.kts b/android/build.gradle.kts
new file mode 100644
index 00000000..91e716b5
--- /dev/null
+++ b/android/build.gradle.kts
@@ -0,0 +1,7 @@
+// Top-level build file. Plugins are declared here (apply false) and applied per module.
+plugins {
+ alias(libs.plugins.android.application) apply false
+ alias(libs.plugins.kotlin.android) apply false
+ alias(libs.plugins.kotlin.compose) apply false
+ alias(libs.plugins.kotlin.serialization) apply false
+}
diff --git a/android/gradle.properties b/android/gradle.properties
new file mode 100644
index 00000000..83bc8427
--- /dev/null
+++ b/android/gradle.properties
@@ -0,0 +1,9 @@
+# Project-wide Gradle settings.
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+org.gradle.parallel=true
+org.gradle.caching=true
+
+# AndroidX / Kotlin
+android.useAndroidX=true
+android.nonTransitiveRClass=true
+kotlin.code.style=official
diff --git a/android/gradle/libs.versions.toml b/android/gradle/libs.versions.toml
new file mode 100644
index 00000000..c1d8f4df
--- /dev/null
+++ b/android/gradle/libs.versions.toml
@@ -0,0 +1,37 @@
+[versions]
+agp = "8.7.2"
+kotlin = "2.0.21"
+coreKtx = "1.13.1"
+activityCompose = "1.9.3"
+composeBom = "2024.10.00"
+navigationCompose = "2.8.4"
+lifecycle = "2.8.7"
+coroutines = "1.9.0"
+serialization = "1.7.3"
+okhttp = "4.12.0"
+junit = "4.13.2"
+
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activityCompose" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
+androidx-compose-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-compose-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
+androidx-compose-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+androidx-compose-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-compose-material3 = { group = "androidx.compose.material3", name = "material3" }
+androidx-compose-material-icons-extended = { group = "androidx.compose.material", name = "material-icons-extended" }
+androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigationCompose" }
+androidx-lifecycle-runtime-compose = { group = "androidx.lifecycle", name = "lifecycle-runtime-compose", version.ref = "lifecycle" }
+androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
+androidx-lifecycle-viewmodel-ktx = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-ktx", version.ref = "lifecycle" }
+kotlinx-coroutines-android = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-android", version.ref = "coroutines" }
+kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "serialization" }
+okhttp = { group = "com.squareup.okhttp3", name = "okhttp", version.ref = "okhttp" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+kotlin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
diff --git a/android/gradle/wrapper/gradle-wrapper.properties b/android/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 00000000..5305830e
--- /dev/null
+++ b/android/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,11 @@
+## NOTE: the wrapper JAR (gradle/wrapper/gradle-wrapper.jar) is a generated binary
+## and is intentionally not committed. Generate a working wrapper on a machine with
+## Gradle installed: `cd android && gradle wrapper --gradle-version 8.9`.
+## Until then, build with a locally installed Gradle 8.9+: `gradle :app:assembleDebug`.
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/android/settings.gradle.kts b/android/settings.gradle.kts
new file mode 100644
index 00000000..00716c6c
--- /dev/null
+++ b/android/settings.gradle.kts
@@ -0,0 +1,24 @@
+pluginManagement {
+ repositories {
+ google {
+ content {
+ includeGroupByRegex("com\\.android.*")
+ includeGroupByRegex("com\\.google.*")
+ includeGroupByRegex("androidx.*")
+ }
+ }
+ mavenCentral()
+ gradlePluginPortal()
+ }
+}
+
+dependencyResolutionManagement {
+ repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+ repositories {
+ google()
+ mavenCentral()
+ }
+}
+
+rootProject.name = "PipelinesAndroid"
+include(":app")