Merge main into chat-close: combine the shared chat room with the server-side close

The item adds chat_close/chat_reopen to the brokered chat protocol and the
operator-session registry's closed state. main replaced the per-session claim
model with shared chat rooms (chat_subscribe, a prompt queue, one broker stream
fanned out to every watcher). This merges the two.

Resolved conflicts:
- internal/protocol/chat.go, internal/protocol/message.go: kept both additions -
  ChatClose/ChatReopen and main's ChatSubscribe/ChatQueued.
- internal/server/chat_sessions.go: kept the closed fields on a listed session;
  dropped the `Busy` assignment, because main no longer marks a session Busy (any
  number of clients may watch and write one).
- internal/server/chat_claims.go: main deleted the claim model, so the file goes;
  close's "is a turn running" check is now `chatHub.turnInFlight` in
  internal/server/chat_room.go, reading the room's `running` flag. That is the
  same question the old claim answered, against main's model.
- internal/server/chat_close.go: calls turnInFlight instead of the removed
  `active`.
- android AppViewModel.kt, ChatFormat.kt, ChatListPane.kt, Message.kt: kept both
  sides - main's search state, queued-prompt handling, `Busy`-free status label
  and row/menu shape, plus the item's close/reopen actions, closed chip and
  section, close confirmation and "Hide on this device" rename.

Also in this merge: main's new convention (AGENTS.md) that an item does not edit
a shared document; the item's stale-document record for this change lives in
docs/notes/chat-close.md, and docs/cli.md, android/README.md and
internal/author/skill/references/operations.md are left to the docs-fold writer.

Checks after resolving: gofmt clean, go build ./... and go vet ./... clean, the
Go module passes, and the app's :app:assembleDebug and :app:testDebugUnitTest
pass (--offline --no-daemon).
This commit is contained in:
2026-10-18 00:19:23 +01:00
75 changed files with 4520 additions and 769 deletions
+8
View File
@@ -3,6 +3,14 @@
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<!--
POST_NOTIFICATIONS is requested at runtime on Android 13+ (API 33), the
first time a run actually needs the operator or the attention surface is
opened, and asked at most once: a refusal degrades to the in-app Needs you
surface rather than nagging. Runs that need the operator post into the one
"Runs that need you" channel from the app's own process.
-->
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
<application
android:allowBackup="true"
@@ -11,18 +11,21 @@ import androidx.compose.runtime.setValue
import androidx.lifecycle.viewmodel.compose.viewModel
import net.awan.pipelines.ui.AppViewModel
import net.awan.pipelines.ui.PipelinesApp
import net.awan.pipelines.ui.runIdFromDeepLink
import net.awan.pipelines.ui.runLinkFromDeepLink
import net.awan.pipelines.ui.theme.PipelinesTheme
class MainActivity : ComponentActivity() {
// The run a deep link asks to open — the notification's `pipelines://run/<id>`
// click action. It is read from the launch or update intent and cleared once
// PipelinesApp has opened it, so a recomposition never re-navigates.
// click action — and what inside it to open (a waiting run's `decide` action
// opens its decision sheet). Both are read from the launch or update intent
// and cleared once PipelinesApp has opened them, so a recomposition never
// re-navigates.
private var deepLinkedRunId by mutableStateOf<Long?>(null)
private var deepLinkedAction by mutableStateOf<String?>(null)
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
deepLinkedRunId = runIdFromDeepLink(intent?.data?.toString())
applyDeepLink(intent)
enableEdgeToEdge()
val app = application as PipelinesApplication
setContent {
@@ -31,7 +34,11 @@ class MainActivity : ComponentActivity() {
PipelinesApp(
vm = vm,
initialRunId = deepLinkedRunId,
onInitialRunHandled = { deepLinkedRunId = null },
initialRunAction = deepLinkedAction,
onInitialRunHandled = {
deepLinkedRunId = null
deepLinkedAction = null
},
)
}
}
@@ -41,6 +48,12 @@ class MainActivity : ComponentActivity() {
override fun onNewIntent(intent: Intent) {
super.onNewIntent(intent)
setIntent(intent)
deepLinkedRunId = runIdFromDeepLink(intent.data?.toString())
applyDeepLink(intent)
}
private fun applyDeepLink(intent: Intent?) {
val link = runLinkFromDeepLink(intent?.data?.toString())
deepLinkedRunId = link?.runId
deepLinkedAction = link?.action
}
}
@@ -7,6 +7,7 @@ import kotlinx.coroutines.SupervisorJob
import net.awan.pipelines.data.PipelinesRepository
import net.awan.pipelines.data.SettingsRepository
import net.awan.pipelines.data.transport.PipelinesClient
import net.awan.pipelines.notify.RunNotifier
/**
* Holds the single long-lived repository, WebSocket client and application
@@ -21,4 +22,16 @@ class PipelinesApplication : Application() {
val client: PipelinesClient by lazy { PipelinesClient(scope = applicationScope) }
val repository: PipelinesRepository by lazy { PipelinesRepository(client, settings) }
/**
* Posts the app's own Android notifications for runs that need the operator.
* Its channel is created once, before anything can post, so a notification is
* never dropped for a missing channel.
*/
val runNotifier: RunNotifier by lazy { RunNotifier(this) }
override fun onCreate() {
super.onCreate()
runNotifier.ensureChannel()
}
}
@@ -1,5 +1,6 @@
package net.awan.pipelines.data
import android.os.Build
import java.util.UUID
import java.util.concurrent.ConcurrentHashMap
import kotlinx.coroutines.flow.SharedFlow
@@ -27,6 +28,17 @@ import net.awan.pipelines.data.transport.PipelinesClient
import net.awan.pipelines.data.transport.ProtocolException
import net.awan.pipelines.data.transport.ServerUrl
/**
* The default label this device reports: its model name, so other clients can
* attribute a message to "Pixel 9 Pro XL". A build without a usable model (or a
* local unit test where the framework stub has none) falls back to a generic
* label rather than sending a blank one.
*/
private fun defaultClientLabel(): String {
val model = runCatching { Build.MODEL }.getOrNull()?.trim().orEmpty()
return model.ifBlank { "Android device" }
}
/** Run history plus the server's aggregate usage statistics. */
data class RunHistory(val runs: List<RunSummary>, val usage: UsageStats?)
@@ -38,6 +50,13 @@ data class RunHistory(val runs: List<RunSummary>, val usage: UsageStats?)
class PipelinesRepository(
private val client: PipelinesClient,
private val settings: SettingsRepository,
/**
* The label this device sends with its prompts and approval answers, so every
* other client can attribute a user message to the device that sent it and see
* which device answered an approval. Defaults to the device model; injectable
* so a unit test does not depend on the build.
*/
val clientLabel: String = defaultClientLabel(),
) {
val connectionState = client.state
@@ -155,13 +174,13 @@ class PipelinesRepository(
/**
* Sends one omni-search query over the shared transport and returns the raw
* reply envelope. The server command is still landing, so the reply is
* classified by its envelope type: [Protocol.SEARCH_RESULTS] is the accepted
* search, and any other type is an unexpected reply the caller reports rather
* than parsing. The typed result payload is added with the results item.
* reply envelope. [kind] narrows the server-side scan to one SearchKind (see
* SearchKindFilter); a blank kind searches every kind. The reply is classified
* by its envelope type: [Protocol.SEARCH_RESULTS] is the accepted search, and
* any other type is an unexpected reply the caller reports rather than parsing.
*/
suspend fun search(query: String): Message =
client.call(Message(type = Protocol.SEARCH, search = SearchRequest(query = query.trim())))
suspend fun search(query: String, kind: String = ""): Message =
client.call(Message(type = Protocol.SEARCH, search = SearchRequest(query = query.trim(), kind = kind)))
/** Fetches an artifact's bytes (image preview) over the shared HTTP client. */
suspend fun fetchArtifactBytes(url: String): ByteArray = client.fetchBytes(url)
@@ -241,9 +260,9 @@ class PipelinesRepository(
// directly and never holds its credentials. ----
/**
* Lists the sessions this server owns, with the `busy` flag the phone renders
* read-only. The server already returns operator sessions only, so the app
* never filters this list by ownership.
* Lists the sessions this server owns. The server already returns operator
* sessions only, so the app never filters this list by ownership; a session is
* never marked read-only.
*/
suspend fun chatSessions(): List<ChatSession> =
client.call(Message(type = Protocol.CHAT_SESSIONS)).chatSessions ?: emptyList()
@@ -284,15 +303,29 @@ class PipelinesRepository(
}
/**
* Sends one prompt with its attached file URIs; the server echoes an ack and
* then pushes chat_event frames. The attachments travel only here, with the
* prompt the operator actually sent — never on their own.
* Attaches this connection to [sessionId]'s shared live stream, so it sees
* every frame any client's turn produces — the other devices' prompts and the
* turn's streaming output — and can answer a shared approval. Best-effort: an
* older server that does not know `chat_subscribe` simply answers an error
* frame, which the caller ignores while history still loads.
*/
suspend fun chatPrompt(sessionId: String, text: String, files: List<String> = emptyList()) {
suspend fun chatSubscribe(sessionId: String) {
if (sessionId.isBlank()) return
client.call(ChatProtocol.subscribeRequest(sessionId))
}
/**
* Sends one prompt with its attached file URIs; the server echoes an ack and
* then pushes chat_event frames. The prompt carries this device's label so the
* other clients can attribute it. The attachments travel only here, with the
* prompt the operator actually sent — never on their own. Returns true when the
* server queued the prompt behind an in-flight turn.
*/
suspend fun chatPrompt(sessionId: String, text: String, files: List<String> = emptyList()): Boolean {
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
val trimmed = text.trim()
if (trimmed.isEmpty()) throw ProtocolException("Enter a message before sending.")
client.call(ChatProtocol.promptRequest(sessionId, trimmed, files))
return client.call(ChatProtocol.promptRequest(sessionId, trimmed, files, clientLabel)).chatQueued
}
suspend fun chatInterrupt(sessionId: String) {
@@ -324,7 +357,7 @@ class PipelinesRepository(
if (sessionId.isBlank() || requestId.isBlank()) {
throw ProtocolException("A pending permission request is required.")
}
client.call(ChatProtocol.replyRequest(sessionId, requestId, decision, message))
client.call(ChatProtocol.replyRequest(sessionId, requestId, decision, message, clientLabel))
}
private fun requireConfigured() {
@@ -71,6 +71,20 @@ class SettingsRepository(context: Context) {
private val _attention = MutableStateFlow(prefs.getString(KEY_ATTENTION, "").orEmpty())
val attention: StateFlow<String> = _attention.asStateFlow()
// Whether the operator has already been asked for POST_NOTIFICATIONS. Asked
// once and remembered, so the rationale and the system dialog never nag: the
// app degrades to its in-app attention surface instead.
private val _notificationPermissionAsked =
MutableStateFlow(prefs.getBoolean(KEY_NOTIFICATION_PERMISSION_ASKED, false))
val notificationPermissionAsked: StateFlow<Boolean> = _notificationPermissionAsked.asStateFlow()
// The omni-search kind narrowing (a server kind, "" = every kind) and the
// search order, stored as their stable values and resolved by the UI.
private val _searchFilterKind = MutableStateFlow(prefs.getString(KEY_SEARCH_FILTER_KIND, "").orEmpty())
val searchFilterKind: StateFlow<String> = _searchFilterKind.asStateFlow()
private val _searchSort = MutableStateFlow(prefs.getString(KEY_SEARCH_SORT, "").orEmpty())
val searchSort: StateFlow<String> = _searchSort.asStateFlow()
fun setServerUrl(value: String) {
val trimmed = value.trim()
_serverUrl.value = trimmed
@@ -141,6 +155,23 @@ class SettingsRepository(context: Context) {
prefs.edit().putString(KEY_ATTENTION, value).apply()
}
/** Records that the runtime notification permission has been asked for (or declined). */
fun setNotificationPermissionAsked(asked: Boolean) {
if (asked == _notificationPermissionAsked.value) return
_notificationPermissionAsked.value = asked
prefs.edit().putBoolean(KEY_NOTIFICATION_PERMISSION_ASKED, asked).apply()
}
fun setSearchFilterKind(value: String) {
_searchFilterKind.value = value
prefs.edit().putString(KEY_SEARCH_FILTER_KIND, value).apply()
}
fun setSearchSort(value: String) {
_searchSort.value = value
prefs.edit().putString(KEY_SEARCH_SORT, value).apply()
}
/** True only when the user has explicitly supplied both required values. */
fun isConfigured(): Boolean = _serverUrl.value.isNotBlank() && _workspace.value.isNotBlank()
@@ -158,5 +189,8 @@ class SettingsRepository(context: Context) {
const val KEY_CHAT_OVERRIDES = "chat_overrides"
const val KEY_CHAT_SEEN = "chat_seen"
const val KEY_ATTENTION = "attention"
const val KEY_NOTIFICATION_PERMISSION_ASKED = "notification_permission_asked"
const val KEY_SEARCH_FILTER_KIND = "search_filter_kind"
const val KEY_SEARCH_SORT = "search_sort"
}
}
@@ -30,8 +30,8 @@ data class ChatSession(
@SerialName("created_at") val createdAt: Long = 0,
@SerialName("updated_at") val updatedAt: Long = 0,
// Another client holds the session, or the server itself owns it as an active
// run: the phone shows it read-only instead of letting two clients write the
// same conversation.
// run. Kept for wire compatibility; the server no longer sets it, and a
// session is never read-only for a client.
val busy: Boolean = false,
// The operator finished with this session: the server recorded it as closed,
// so every client sees the same state. The session, its transcript and its
@@ -75,6 +75,10 @@ data class ChatPromptRequest(
val model: String = "",
val agent: String = "",
val files: List<String> = emptyList(),
// The sending device's human-readable label (a device name), so every other
// client can attribute the message; the server sanitises it and falls back to
// a generic label when it is blank.
val client: String = "",
)
/** One stored turn: a user turn is a single text part, an assistant turn holds text/reasoning/tool parts. */
@@ -86,6 +90,9 @@ data class ChatMessage(
val model: String = "",
val agent: String = "",
@SerialName("created_at") val createdAt: Long = 0,
// The sending device's label on a user turn the server echoed, so a resumed
// transcript still says who sent the message. Empty on an assistant turn.
val client: String = "",
val parts: List<ChatPart> = emptyList(),
)
@@ -158,6 +165,9 @@ data class ChatEventFrame(
val part: ChatPart? = null,
val step: ChatStep? = null,
val usage: ChatUsage? = null,
// The sending device's label on a `user` frame (another client's prompt), so
// the transcript can say who sent it. Empty on the agent's own frames.
val client: String = "",
)
@Serializable
@@ -194,6 +204,9 @@ data class ChatPermissionFrame(
val message: String = "",
val resolved: Boolean = false,
val decision: String = "",
// The label of the client whose answer resolved the request, so every other
// client can show which device answered.
@SerialName("resolved_by") val resolvedBy: String = "",
)
@Serializable
@@ -209,6 +222,8 @@ data class ChatReplyRequest(
@SerialName("request_id") val requestId: String = "",
val decision: String = "",
val message: String = "",
// The answering device's label, recorded with the resolution.
val client: String = "",
)
/** Chat part/kind/state/reply constants, mirroring `internal/protocol/chat.go`. */
@@ -227,6 +242,13 @@ object ChatProtocol {
const val EVENT_STEP = "step"
const val EVENT_USAGE = "usage"
/**
* A prompt another client sent, echoed live to this client so it appears in
* the transcript attributed to the sending device. The sender never receives
* its own frame (it already has the message locally).
*/
const val EVENT_USER = "user"
const val STEP_STARTED = "started"
const val STEP_ENDED = "ended"
@@ -261,10 +283,21 @@ object ChatProtocol {
* shape a text-only prompt has always sent). Built here (not inline in the
* repository) so production and its unit test share the one wire shape.
*/
fun promptRequest(sessionId: String, text: String, files: List<String> = emptyList()): Message =
fun promptRequest(sessionId: String, text: String, files: List<String> = emptyList(), client: String = ""): Message =
Message(
type = Protocol.CHAT_PROMPT,
chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files),
chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files, client = client),
)
/**
* The `chat_subscribe` frame that attaches this connection to [sessionId]'s
* shared live stream, so the client sees every frame any client's turn
* produces. Built here so production and its unit test share the one shape.
*/
fun subscribeRequest(sessionId: String): Message =
Message(
type = Protocol.CHAT_SUBSCRIBE,
chatSubscribe = ChatQuery(sessionId = sessionId),
)
/**
@@ -299,7 +332,7 @@ object ChatProtocol {
* inline in the repository) so the approval card's actions and their unit
* test share the one wire shape.
*/
fun replyRequest(sessionId: String, requestId: String, decision: String, message: String = ""): Message =
fun replyRequest(sessionId: String, requestId: String, decision: String, message: String = "", client: String = ""): Message =
Message(
type = Protocol.CHAT_REPLY,
chatReply = ChatReplyRequest(
@@ -307,6 +340,7 @@ object ChatProtocol {
requestId = requestId,
decision = decision,
message = message,
client = client,
),
)
}
@@ -73,6 +73,9 @@ object Protocol {
// chat_interrupt; chat_close also carries a ChatCloseResult on the response.
const val CHAT_CLOSE = "chat_close"
const val CHAT_REOPEN = "chat_reopen"
// Attaches this connection to one session's shared live stream, so every
// client watching a session receives every frame any client's turn produces.
const val CHAT_SUBSCRIBE = "chat_subscribe"
// The operator's directory choices for a new chat (home first, then the
// directories of previous operator sessions, most recently used first).
const val CHAT_DIRECTORIES = "chat_directories"
@@ -681,6 +684,11 @@ data class Message(
@SerialName("chat_create") val chatCreate: ChatCreateRequest? = null,
@SerialName("chat_query") val chatQuery: ChatQuery? = null,
@SerialName("chat_prompt") val chatPrompt: ChatPromptRequest? = null,
// A chat_prompt response with this set was accepted into the session's queue
// because a turn is already in flight; the composer shows queued/steering
// instead of blocking input.
@SerialName("chat_queued") val chatQueued: Boolean = false,
@SerialName("chat_subscribe") val chatSubscribe: ChatQuery? = null,
@SerialName("chat_messages") val chatMessages: List<ChatMessage>? = null,
@SerialName("chat_event") val chatEvent: ChatEventFrame? = null,
@SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null,
@@ -0,0 +1,249 @@
package net.awan.pipelines.notify
import net.awan.pipelines.ui.AttentionEntry
import net.awan.pipelines.ui.AttentionKind
import net.awan.pipelines.ui.RUN_DEEP_LINK_ACTION_DECIDE
import net.awan.pipelines.ui.RUN_DEEP_LINK_ACTION_PARAM
import net.awan.pipelines.ui.RUN_DEEP_LINK_PREFIX
/**
* The one place the app decides what becomes an Android notification.
*
* The operator's rule is the same on every surface: only a run waiting for a
* decision and a run that failed ask for a person. A successful run, a running
* run or a cancelled one raises nothing, so the system tray can never fill with
* work that is not actionable. The mapping reads the attention model's kinds
* (see `ui/Attention.kt`), so the tray and the in-app surface can never disagree
* about what needs the operator.
*
* Everything here is pure — no Android types, no `Context`, no clock — so the
* mapping, the coalescing and clearing rules, the permission paths and the tap
* destination are all unit-tested on the JVM without a device.
*/
/** The two run events that raise a notification. */
enum class RunAlertKind { Decision, Failed }
/**
* Where the app's notifications actually go. The ViewModel depends on this, not
* on Android, so the run-watch logic stays free of `Context` and the concrete
* poster ([RunNotifier]) is the only Android part.
*/
interface RunAlertSink {
/** Whether a notification can be shown right now (permission granted, not silenced). */
fun notificationsAllowed(): Boolean
/** Moves the tray to exactly the alerts the attention list currently raises. */
fun sync(alerts: List<RunAlert>)
/** Clears one run's notifications because the operator reached it. */
fun arrived(runId: Long)
}
/** A sink that shows nothing: the default until the Android poster is wired in. */
object NoRunAlerts : RunAlertSink {
override fun notificationsAllowed(): Boolean = false
override fun sync(alerts: List<RunAlert>) = Unit
override fun arrived(runId: Long) = Unit
}
/** Where a notification's tap lands inside the app. */
enum class AlertTapTarget { DecisionSheet, Run }
/** One run that needs the operator, as the tray shows it. */
data class RunAlert(
val runId: Long,
val kind: RunAlertKind,
val title: String,
val text: String,
) {
/** The stable identity of one run+event-kind alert; the unit of dedupe. */
val key: String get() = alertKey(runId, kind)
}
/** The identity of one run+kind alert: exactly one notification, never repeated. */
internal fun alertKey(runId: Long, kind: RunAlertKind): String = "$runId:${kind.name}"
/**
* The alert kind an attention kind maps to. The attention model already holds
* only what needs a person — a waiting run ([AttentionKind.Decision]) and a
* failed run ([AttentionKind.Failed]) — so every entry raises exactly one
* notification and nothing else can.
*/
fun alertKindOf(kind: AttentionKind): RunAlertKind = when (kind) {
AttentionKind.Decision -> RunAlertKind.Decision
AttentionKind.Failed -> RunAlertKind.Failed
}
/** The short headline a notification shows for one kind. */
internal fun alertTitle(kind: RunAlertKind): String = when (kind) {
RunAlertKind.Decision -> "A run needs your decision"
RunAlertKind.Failed -> "A run failed"
}
/** The line naming the run: its label, then the pipeline it belongs to. */
internal fun alertText(entry: AttentionEntry): String =
if (entry.pipeline.isBlank() || entry.pipeline == entry.label) {
entry.label
} else {
"${entry.label} · ${entry.pipeline}"
}
/**
* The alerts the current attention list raises, in the surface's own order
* (decision, then failure). The attention list already holds only what needs a
* person, so nothing that needs nobody can reach the tray.
*/
fun runAlerts(entries: List<AttentionEntry>): List<RunAlert> = entries.map { entry ->
val kind = alertKindOf(entry.kind)
RunAlert(runId = entry.runId, kind = kind, title = alertTitle(kind), text = alertText(entry))
}
/**
* The one summary a coalesced group shows: how many runs need the operator and
* what each is. Present only when more than one alert is pending, so a single
* run never gets a redundant wrapper and several are one grouped notification
* rather than a pile.
*/
data class AlertSummary(
val count: Int,
val title: String,
val text: String,
val lines: List<String>,
)
/** The grouped summary for [alerts], or null when at most one is pending. */
fun alertSummary(alerts: List<RunAlert>): AlertSummary? {
if (alerts.size < 2) return null
val waiting = alerts.count { it.kind == RunAlertKind.Decision }
val failed = alerts.count { it.kind == RunAlertKind.Failed }
val counts = buildList {
if (waiting > 0) add(if (waiting == 1) "1 waiting for you" else "$waiting waiting for you")
if (failed > 0) add(if (failed == 1) "1 failed" else "$failed failed")
}.joinToString(" · ")
return AlertSummary(
count = alerts.size,
title = "${alerts.size} runs need you",
text = counts,
lines = alerts.map { "${it.title} — ${it.text}" },
)
}
/** The alerts to post and the keys to cancel after one reconciliation. */
data class AlertDelta(val post: List<RunAlert>, val cancel: List<RunAlert>) {
val isEmpty: Boolean get() = post.isEmpty() && cancel.isEmpty()
}
/**
* What the tray is currently showing, keyed by run+kind. It is what makes the
* notifications deduplicated and non-repeating:
*
* - [reconcile] posts only a run+kind that is not already shown, so a run that
* stays failed or waiting is never re-posted (no storm, no duplicate).
* - It cancels exactly the keys that left the desired set, so a resolved,
* answered or dismissed run's notification is cleared.
* - [arrived] cancels one run's notifications when the operator reaches it, but
* keeps its keys, so arriving at a still-waiting run does not make the next
* reconciliation post it again.
*/
class AlertLedger {
private val posted = LinkedHashMap<String, RunAlert>()
/** Keys the operator already reached, kept for dedupe but no longer visible. */
private val hidden = LinkedHashSet<String>()
/** The alerts currently shown, by key. */
val shown: Map<String, RunAlert> get() = posted.toMap()
/** The alerts still on screen: posted and not cleared by the operator arriving. */
fun visible(): List<RunAlert> = posted.values.filter { it.key !in hidden }
/** The post/cancel delta that moves what is shown to exactly [desired]. */
fun reconcile(desired: List<RunAlert>): AlertDelta {
val desiredByKey = desired.associateBy { it.key }
val toPost = desired.filter { it.key !in posted }
val toCancel = posted.values.filter { it.key !in desiredByKey }
toPost.forEach {
posted[it.key] = it
// A new event for a run the operator reached earlier is shown again.
hidden.remove(it.key)
}
toCancel.forEach {
posted.remove(it.key)
hidden.remove(it.key)
}
return AlertDelta(post = toPost, cancel = toCancel)
}
/**
* The alerts to cancel because the operator arrived at [runId]. Their keys
* are kept, so a run that is still waiting is not re-notified on the next
* reconciliation, and they are hidden from the visible set so a grouped
* summary stops counting them; when the run leaves the attention list it is
* removed here.
*/
fun arrived(runId: Long): List<RunAlert> {
val arrived = posted.values.filter { it.runId == runId }
hidden.addAll(arrived.map { it.key })
return arrived
}
/** Forgets everything (used when permission is revoked, so a later grant re-posts). */
fun clear() {
posted.clear()
hidden.clear()
}
}
/**
* Whether the notification permission should be requested now, and why.
*
* The request happens at most once: [granted] means there is nothing to ask,
* [asked] means the operator has already been asked (or refused) and must never
* be nagged again, and [trigger] is the sensible moment (the first time a run
* needs them, or the operator opening the attention surface). Only "not granted,
* never asked, and something actually needs the operator" asks.
*/
data class AlertPermissionPrompt(val request: Boolean, val rationale: String?)
/** The rationale shown once before the system permission dialog. */
const val NOTIFICATION_RATIONALE: String =
"Pipelines can notify you when a run is waiting for your decision or has failed. " +
"Without it, those runs still appear in the in-app Needs you surface."
/** The permission prompt decision for the current state. Pure, so every path is tested. */
fun alertPermissionPrompt(granted: Boolean, asked: Boolean, trigger: Boolean): AlertPermissionPrompt =
when {
granted -> AlertPermissionPrompt(request = false, rationale = null)
asked -> AlertPermissionPrompt(request = false, rationale = null)
!trigger -> AlertPermissionPrompt(request = false, rationale = null)
else -> AlertPermissionPrompt(request = true, rationale = NOTIFICATION_RATIONALE)
}
/** The tap destination one kind opens. */
fun alertTapTarget(kind: RunAlertKind): AlertTapTarget = when (kind) {
RunAlertKind.Decision -> AlertTapTarget.DecisionSheet
RunAlertKind.Failed -> AlertTapTarget.Run
}
/**
* The deep link a notification's tap opens. A waiting run carries the decide
* action so it lands on the decision sheet; a failed run opens the run itself.
* Both resolve through the app's one `pipelines://run/<id>` deep link, which
* only ever opens a run and starts nothing.
*/
fun alertDeepLink(runId: Long, kind: RunAlertKind): String {
val base = "$RUN_DEEP_LINK_PREFIX$runId"
return when (alertTapTarget(kind)) {
AlertTapTarget.DecisionSheet -> "$base?$RUN_DEEP_LINK_ACTION_PARAM=$RUN_DEEP_LINK_ACTION_DECIDE"
AlertTapTarget.Run -> base
}
}
/**
* The notification id for one run+kind: stable for the life of the run, so
* re-posting the same event updates in place instead of stacking a duplicate.
*/
fun alertNotificationId(runId: Long, kind: RunAlertKind): Int =
((runId * 2L + kind.ordinal) and 0x7FFFFFFFL).toInt()
@@ -0,0 +1,187 @@
package net.awan.pipelines.notify
import android.app.Notification
import android.app.NotificationChannel
import android.app.NotificationManager
import android.app.PendingIntent
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import android.os.Build
import androidx.core.app.NotificationCompat
import androidx.core.app.NotificationManagerCompat
import androidx.core.content.ContextCompat
import net.awan.pipelines.MainActivity
import net.awan.pipelines.R
/**
* The app's own Android notifications for runs that need the operator.
*
* It is deliberately thin: every decision — what becomes an alert, when several
* are one grouped summary, when one is cleared, whether the permission should be
* asked — is the pure [RunAlerts] model, unit-tested on the JVM. This class only
* creates the channel and posts/cancels through [NotificationManagerCompat], so
* it holds no rule of its own that a test would have to reach through Android.
*
* Notifications are posted from the app's own process. While the app is
* backgrounded the process (and the run subscription feeding [sync]) is alive, so
* the events still arrive and are shown; the server also publishes the same two
* events to the operator's ntfy topic, which is the out-of-process backstop when
* the app's process is killed.
*/
class RunNotifier(private val context: Context) : RunAlertSink {
private val manager = NotificationManagerCompat.from(context)
private val ledger = AlertLedger()
/** Whether the tray last showed a grouped summary, so a threshold change re-groups. */
private var grouped = false
/** Creates the one channel runs that need the operator post into. Idempotent. */
fun ensureChannel() {
val channel = NotificationChannel(
CHANNEL_ID,
"Runs that need you",
NotificationManager.IMPORTANCE_HIGH,
).apply {
description = "A run waiting for your decision or a run that failed"
}
manager.createNotificationChannel(channel)
}
/**
* Whether a notification can actually be shown right now: the POST_NOTIFICATIONS
* runtime permission on Android 13+, the app's own notification switch before
* that. When false the app degrades to the in-app attention surface and shows
* nothing here, rather than pretending a notification was posted.
*/
override fun notificationsAllowed(): Boolean =
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
ContextCompat.checkSelfPermission(context, POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
} else {
manager.areNotificationsEnabled()
}
/**
* Moves the tray to exactly the alerts the attention list currently raises:
* each run+kind posted once (never repeated while it stays failed or waiting),
* a run that no longer needs the operator cleared, and several pending runs
* coalesced into one grouped summary. Without the permission nothing is posted
* and the ledger is forgotten, so a later grant re-posts rather than assuming.
*/
override fun sync(alerts: List<RunAlert>) {
if (!notificationsAllowed()) {
ledger.clear()
manager.cancelAll()
grouped = false
return
}
val delta = ledger.reconcile(alerts)
delta.cancel.forEach { manager.cancel(alertNotificationId(it.runId, it.kind)) }
render(visible = ledger.visible(), delta = delta)
}
/**
* Clears one run's notifications because the operator reached it, and refreshes
* the grouped summary so it stops counting a run the operator has already
* opened. The ledger keeps the run+kind, so a run that stays waiting is not
* re-notified.
*/
override fun arrived(runId: Long) {
if (!notificationsAllowed()) return
val arrived = ledger.arrived(runId)
if (arrived.isEmpty()) return
arrived.forEach { manager.cancel(alertNotificationId(it.runId, it.kind)) }
render(visible = ledger.visible(), delta = AlertDelta(post = emptyList(), cancel = emptyList()))
}
/**
* Draws the still-visible alerts at the group/summary shape their count needs.
* A move across the one-versus-many boundary re-posts the visible children once
* (only-alert-once keeps it silent); otherwise only genuinely new alerts are
* posted, so nothing is repeated or re-alerted.
*/
private fun render(visible: List<RunAlert>, delta: AlertDelta) {
val groupedNow = visible.size >= 2
val toPost = if (groupedNow != grouped) visible else delta.post
toPost.forEach { manager.notify(alertNotificationId(it.runId, it.kind), buildAlert(it, groupedNow)) }
val summary = if (groupedNow) alertSummary(visible) else null
if (summary != null) manager.notify(SUMMARY_ID, buildSummary(summary)) else manager.cancel(SUMMARY_ID)
grouped = groupedNow
}
private fun buildAlert(alert: RunAlert, grouped: Boolean): Notification {
val builder = NotificationCompat.Builder(context, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle(alert.title)
.setContentText(alert.text)
.setContentIntent(tapIntent(alert))
.setCategory(NotificationCompat.CATEGORY_STATUS)
.setAutoCancel(true)
.setOnlyAlertOnce(true)
.setPriority(NotificationCompat.PRIORITY_HIGH)
if (grouped) {
builder.setGroup(GROUP_KEY)
// Several arriving together alert once, through the summary, instead of
// a burst of per-run sounds.
builder.setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_SUMMARY)
}
return builder.build()
}
private fun buildSummary(summary: AlertSummary): Notification =
NotificationCompat.Builder(context, CHANNEL_ID)
.setSmallIcon(R.drawable.ic_notification)
.setContentTitle(summary.title)
.setContentText(summary.text)
.setStyle(NotificationCompat.InboxStyle().also { style ->
summary.lines.forEach(style::addLine)
})
// The group's own tap opens the app, where the Needs you chip lists
// every run the summary counts; the individual taps open each run.
.setContentIntent(openAppIntent())
.setGroup(GROUP_KEY)
.setGroupSummary(true)
.setCategory(NotificationCompat.CATEGORY_STATUS)
.setAutoCancel(true)
.setOnlyAlertOnce(true)
.setPriority(NotificationCompat.PRIORITY_HIGH)
.build()
/** The tap intent: the run's own deep link, which only ever opens a run. */
private fun tapIntent(alert: RunAlert): PendingIntent {
val intent = Intent(Intent.ACTION_VIEW, Uri.parse(alertDeepLink(alert.runId, alert.kind)), context, MainActivity::class.java)
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
return PendingIntent.getActivity(
context,
alertNotificationId(alert.runId, alert.kind),
intent,
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
)
}
/** Opens the app (where the attention surface lives) without naming a run. */
private fun openAppIntent(): PendingIntent {
val intent = Intent(context, MainActivity::class.java)
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
return PendingIntent.getActivity(
context,
SUMMARY_ID,
intent,
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
)
}
private companion object {
const val CHANNEL_ID = "runs_need_you"
/** The single grouped-summary notification id; children derive from run+kind. */
const val SUMMARY_ID = 1
const val GROUP_KEY = "net.awan.pipelines.RUNS"
/** The POST_NOTIFICATIONS permission name, spelled out to keep the import list lean. */
const val POST_NOTIFICATIONS = "android.permission.POST_NOTIFICATIONS"
}
}
@@ -38,6 +38,9 @@ import net.awan.pipelines.data.protocol.SessionEvidence
import net.awan.pipelines.data.protocol.Template
import net.awan.pipelines.data.transport.ConnectionState
import net.awan.pipelines.data.transport.ServerUrl
import net.awan.pipelines.notify.NoRunAlerts
import net.awan.pipelines.notify.RunAlertSink
import net.awan.pipelines.notify.runAlerts
import net.awan.pipelines.ui.chat.ChatAttachment
import net.awan.pipelines.ui.chat.ChatSessionOverrides
import net.awan.pipelines.ui.chat.ChatSeenState
@@ -61,6 +64,7 @@ data class LoadState<T>(
class AppViewModel(
private val repository: PipelinesRepository,
private val settings: SettingsRepository,
private val alertSink: RunAlertSink = NoRunAlerts,
) : ViewModel() {
val connectionState: StateFlow<ConnectionState> = repository.connectionState
@@ -79,6 +83,10 @@ class AppViewModel(
val pipelineFilterRunStatuses: StateFlow<String> = settings.pipelineFilterRunStatuses
val pipelineFilterName: StateFlow<String> = settings.pipelineFilterName
/** The stored omni-search kind narrowing (a server kind, "" = every kind) and order. */
val searchKind: StateFlow<String> = settings.searchFilterKind
val searchSort: StateFlow<String> = settings.searchSort
private val _serverUrlDraft = MutableStateFlow(settings.serverUrl.value)
val serverUrlDraft: StateFlow<String> = _serverUrlDraft.asStateFlow()
@@ -135,6 +143,20 @@ class AppViewModel(
attentionEntries(runs.data?.runs.orEmpty(), state)
}.stateIn(viewModelScope, SharingStarted.Eagerly, emptyList())
/**
* Whether the app's notifications can actually be shown right now (the
* POST_NOTIFICATIONS permission on Android 13+, the app's switch before that).
* The permission layer reads this to decide whether to ask; the app degrades to
* its in-app attention surface when it is false rather than pretending a
* notification was posted. Refreshed whenever the app returns to the front, so
* a change made in system settings is reflected.
*/
private val _notificationsAllowed = MutableStateFlow(false)
val notificationsAllowed: StateFlow<Boolean> = _notificationsAllowed.asStateFlow()
/** Whether the runtime notification permission has already been asked for (or refused). */
val notificationPermissionAsked: StateFlow<Boolean> = settings.notificationPermissionAsked
// Debounces keystrokes and gates replies so an older query can never land on
// top of a newer one; the pure ordering lives in SearchSequencer.
private val searchSequencer = SearchSequencer()
@@ -209,6 +231,7 @@ class AppViewModel(
observeChatOverrides()
observeChatSeen()
observeAttention()
observeRunAlerts()
}
/**
@@ -543,20 +566,54 @@ class AppViewModel(
}
/**
* Deliberately dismisses one attention entry for good, so a still-waiting or
* still-failed run the operator has chosen to ignore stops asking.
* Feeds the app's Android notifications from the same attention list the
* in-app surface shows: a run waiting for a decision and a failed run each
* become one notification (or, when several need the operator, one grouped
* summary), and a run that leaves the list — resolved, answered or dismissed —
* has its notification cleared. Nothing here decides what matters; it is the
* pure alert model applied.
*/
fun dismissAttention(runId: Long, kind: AttentionKind) {
_attentionState.value = _attentionState.value.dismissed(attentionKey(runId, kind))
private fun observeRunAlerts() {
_notificationsAllowed.value = alertSink.notificationsAllowed()
viewModelScope.launch {
attention.collect { entries -> alertSink.sync(runAlerts(entries)) }
}
}
/** Re-reads whether notifications can be shown; called when the app comes to the front. */
fun refreshNotificationsAllowed() {
val allowed = alertSink.notificationsAllowed()
_notificationsAllowed.value = allowed
// A grant may have happened after the alert was already needed (the
// operator answered the system dialog or changed the setting): re-sync so
// the still-pending run is shown now rather than waiting for the next push.
// The ledger still prevents re-posting anything already shown.
if (allowed) alertSink.sync(runAlerts(attention.value))
}
/** Records that the runtime notification permission has been asked for, so it never nags. */
fun markNotificationPermissionAsked() {
settings.setNotificationPermissionAsked(true)
}
/**
* Records that the operator has looked at the finished runs now on the
* surface, so a run that merely finished since the last look clears on this
* look rather than reappearing. Called when the list is opened.
* The operator has reached [runId]: its notification is cleared, and — because
* the run is still waiting or failed — it is not posted again. Called through
* the one path that opens a run, so a tap, an attention tap and a deep link all
* clear the same way.
*/
fun sawFinishedAttention(ids: Collection<Long>) {
_attentionState.value = _attentionState.value.lookedAtFinished(ids.toSet())
fun arrivedAtRun(runId: Long) {
alertSink.arrived(runId)
}
/**
* Deliberately dismisses one attention entry for good, so a still-waiting or
* still-failed run the operator has chosen to ignore stops asking. The
* notification for it is cleared by the same attention change the app's
* notifications are fed from.
*/
fun dismissAttention(runId: Long, kind: AttentionKind) {
_attentionState.value = _attentionState.value.dismissed(attentionKey(runId, kind))
}
fun updateServerUrlDraft(value: String) {
@@ -632,6 +689,19 @@ class AppViewModel(
fun setPipelineFilterName(value: String) = settings.setPipelineFilterName(value)
/**
* Narrows the search to a server kind (see SearchKindFilter). The kind is a
* request parameter, so a narrowed search re-issues the live query at once
* rather than waiting for the next keystroke.
*/
fun setSearchKind(serverKind: String) {
settings.setSearchFilterKind(serverKind)
rerunSearchImmediately()
}
/** Records the search order; it orders the results already in hand, so no refetch. */
fun setSearchSort(storageKey: String) = settings.setSearchSort(storageKey)
private fun awaitConnected() {
viewModelScope.launch {
val connected = withTimeoutOrNull(CONNECT_TIMEOUT_MILLIS) {
@@ -750,7 +820,13 @@ class AppViewModel(
}
/** Runs the current query immediately (the IME's search action), skipping the debounce. */
fun searchNow() {
fun searchNow() = rerunSearchImmediately()
/**
* Re-issues the live query at once, cancelling any pending debounce: the IME
* search action and a kind-filter change both want the newest request now.
*/
private fun rerunSearchImmediately() {
val query = _search.value.query
if (query.isBlank()) return
val edit = searchSequencer.edit(query)
@@ -768,7 +844,10 @@ class AppViewModel(
private suspend fun runSearch(request: SentSearch) {
_search.value = _search.value.copy(loading = true, error = null)
try {
val reply = repository.search(request.query)
// The active kind filter is a request parameter; resolve it from the
// stored value (a blank/stale one falls back to every kind).
val kind = SearchKindFilter.fromStorage(settings.searchFilterKind.value).serverKind
val reply = repository.search(request.query, kind)
// A reply for a superseded query must never land: the sequencer only
// accepts the newest sent token.
if (!searchSequencer.accepts(request.token)) return
@@ -1025,6 +1104,10 @@ class AppViewModel(
fun loadChatHistory(sessionId: String) {
viewModelScope.launch {
// Watch the session's shared stream so frames from any client's turn
// arrive live. Best-effort: an older server answers an error frame,
// which must not stop the history from loading.
runCatching { repository.chatSubscribe(sessionId) }
chatStore.historyLoading(sessionId)
try {
chatStore.history(sessionId, repository.chatMessages(sessionId, CHAT_HISTORY_LIMIT))
@@ -1054,7 +1137,11 @@ class AppViewModel(
chatStore.running(sessionId, true)
viewModelScope.launch {
try {
repository.chatPrompt(sessionId, text, attachmentFiles(attachments))
val queued = repository.chatPrompt(sessionId, text, attachmentFiles(attachments))
// The server accepted the prompt (queued or sent); a queued prompt
// is one waiting behind an in-flight turn, and the composer says so
// instead of blocking input.
chatStore.setQueued(sessionId, queued)
// Prompting a closed session reopens it on the server; clear the
// closed mark locally too so the list agrees without a re-fetch.
chatStore.sessionReopened(sessionId)
@@ -1065,6 +1152,7 @@ class AppViewModel(
chatStore.failed(sessionId, message)
chatStore.restoreAttachments(sessionId, attachments, message)
chatStore.running(sessionId, false)
chatStore.setQueued(sessionId, false)
}
}
}
@@ -1174,7 +1262,7 @@ class AppViewModel(
private const val CHAT_HISTORY_LIMIT = 200
fun factory(app: PipelinesApplication) = viewModelFactory {
initializer { AppViewModel(app.repository, app.settings) }
initializer { AppViewModel(app.repository, app.settings, app.runNotifier) }
}
}
}
@@ -8,22 +8,21 @@ import net.awan.pipelines.data.protocol.RunSummary
* The one place the app decides what needs the operator and how much it matters.
*
* A run's server status maps to at most one [AttentionKind]: a run parked on a
* person ([AttentionKind.Decision]) is the most important, a failed run
* ([AttentionKind.Failed]) next, and a run that finished since the operator last
* looked ([AttentionKind.Finished]) last. Everything else — queued, running,
* canceled, interrupted — asks nothing and is not listed, so the surface can only
* ever show something that is genuinely actionable.
* person ([AttentionKind.Decision]) is the most important and a failed run
* ([AttentionKind.Failed]) next. Everything else — queued, running, succeeded,
* canceled, interrupted — asks nothing and is not listed, so the surface (and the
* system tray fed from it) can only ever show something that is genuinely
* actionable. A successful run is never announced.
*
* The list is advanced from the run events the server already pushes: the same
* `RunSummary` rows that the runs list is folded from feed [attentionEntries], so
* an entry appears and clears with no refresh and no request of its own.
*/
/** The three things the attention surface ranks, most important first. */
/** The two things the attention surface ranks, most important first. */
enum class AttentionKind(val rank: Int) {
Decision(0),
Failed(1),
Finished(2),
}
/** One entry on the attention surface: what run needs the operator, and why. */
@@ -55,7 +54,6 @@ internal fun attentionKindOf(status: String): AttentionKind? =
when (status.trim().lowercase()) {
"waiting" -> AttentionKind.Decision
"failed" -> AttentionKind.Failed
"succeeded" -> AttentionKind.Finished
else -> null
}
@@ -67,22 +65,19 @@ internal fun attentionKindOf(status: String): AttentionKind? =
internal fun attentionDetail(kind: AttentionKind, run: RunSummary): String = when (kind) {
AttentionKind.Decision -> "Waiting for your decision"
AttentionKind.Failed -> run.diagnostic.trim().ifBlank { "Run failed" }
AttentionKind.Finished -> "Finished"
}
/**
* The ordered attention list. Every run that needs the operator becomes one
* entry, ranked by kind (decision, failed, finished) and then newest-first within
* a kind, so the order is stable and never reshuffles between reads. An entry the
* operator explicitly dismissed never returns, and a finished run the operator
* has already looked at stays gone; a waiting or failed run returns until it is
* resolved or dismissed, because it is still asking.
* entry, ranked by kind (decision, then failure) and then newest-first within a
* kind, so the order is stable and never reshuffles between reads. An entry the
* operator explicitly dismissed never returns, and a waiting or failed run stays
* until it is resolved or dismissed, because it is still asking.
*/
internal fun attentionEntries(runs: List<RunSummary>, state: AttentionState): List<AttentionEntry> =
runs.mapNotNull { run ->
val kind = attentionKindOf(run.status) ?: return@mapNotNull null
if (attentionKey(run.id, kind) in state.dismissed) return@mapNotNull null
if (kind == AttentionKind.Finished && run.id in state.finishedSeen) return@mapNotNull null
AttentionEntry(
runId = run.id,
pipeline = run.name,
@@ -103,25 +98,20 @@ internal fun attentionEntries(runs: List<RunSummary>, state: AttentionState): Li
* stored state:
*
* - [dismissed] is the run+kind keys the operator deliberately dismissed, so a
* still-waiting run stays out of the list after an explicit dismissal.
* - [finishedSeen] is the finished runs the operator has looked at, so the list
* shows a completed run once and clears it on the next look.
* still-waiting or still-failed run stays out of the list after an explicit
* dismissal.
*
* A successful run is never on the surface, so there is nothing to remember as
* "already looked at": the surface only ever holds work that still asks.
*/
@Serializable
data class AttentionState(
val dismissed: Set<String> = emptySet(),
val finishedSeen: Set<Long> = emptySet(),
) {
/** Removes one entry for good, whatever its run goes on to do. */
fun dismissed(key: String): AttentionState =
if (key.isBlank() || key in dismissed) this else copy(dismissed = dismissed + key)
/** Records the finished runs the operator has now looked at. */
fun lookedAtFinished(ids: Set<Long>): AttentionState {
val added = ids.filter { it > 0 && it !in finishedSeen }.toSet()
return if (added.isEmpty()) this else copy(finishedSeen = finishedSeen + added)
}
/** The one-line JSON this value is stored as; never fails on our own value. */
fun encode(): String = PipelinesJson.encodeToString(serializer(), this)
@@ -138,7 +128,45 @@ data class AttentionState(
}
/** The deep-link scheme the run notification's click action opens. */
internal const val RUN_DEEP_LINK_PREFIX = "pipelines://run/"/**
internal const val RUN_DEEP_LINK_PREFIX = "pipelines://run/"
/** The query parameter a run deep link may carry to name what it should open. */
internal const val RUN_DEEP_LINK_ACTION_PARAM = "action"
/** The [RUN_DEEP_LINK_ACTION_PARAM] value that opens a waiting run's decision sheet. */
internal const val RUN_DEEP_LINK_ACTION_DECIDE = "decide"
/**
* What a `pipelines://run/<id>` deep link names: the run, and an optional action
* for what inside it to open (`decide` opens the decision sheet). Null for
* anything that is not a well-formed run link, so a malformed link opens nothing
* rather than a guessed run.
*/
internal data class RunLink(val runId: Long, val action: String?)
/**
* Parses the run id and optional action from a run deep link. The id must be the
* whole path segment, so `pipelines://run/1x` and `pipelines://run/0` parse to
* null instead of being truncated to a real run.
*/
internal fun runLinkFromDeepLink(link: String?): RunLink? {
val value = link?.trim().orEmpty()
if (!value.startsWith(RUN_DEEP_LINK_PREFIX)) return null
val rest = value.removePrefix(RUN_DEEP_LINK_PREFIX)
val path = rest.substringBefore('?')
if (path.isEmpty() || !path.all { it.isDigit() }) return null
val runId = path.toLongOrNull()?.takeIf { it > 0 } ?: return null
val action = rest.substringAfter('?', "")
.split('&')
.mapNotNull { part ->
val pair = part.split('=', limit = 2)
pair.getOrNull(1)?.takeIf { pair[0] == RUN_DEEP_LINK_ACTION_PARAM && it.isNotBlank() }
}
.firstOrNull()
return RunLink(runId, action)
}
/**
* The one-line headline the indicator shows: the single most important thing when
* there is one entry, else the count. Pure, so it can be asserted without a device.
*/
@@ -147,7 +175,6 @@ internal fun attentionHeadline(entries: List<AttentionEntry>): String = when {
entries.size == 1 -> when (entries[0].kind) {
AttentionKind.Decision -> "A run is waiting for you"
AttentionKind.Failed -> "A run failed"
AttentionKind.Finished -> "A run finished"
}
else -> "${entries.size} runs need you"
}
@@ -157,10 +184,4 @@ internal fun attentionHeadline(entries: List<AttentionEntry>): String = when {
* anything else. Pure and total, so a malformed link simply opens nothing rather
* than a guessed run.
*/
internal fun runIdFromDeepLink(link: String?): Long? {
val value = link?.trim().orEmpty()
if (!value.startsWith(RUN_DEEP_LINK_PREFIX)) return null
val rest = value.removePrefix(RUN_DEEP_LINK_PREFIX)
if (rest.isEmpty() || !rest.all { it.isDigit() }) return null
return rest.toLongOrNull()?.takeIf { it > 0 }
}
internal fun runIdFromDeepLink(link: String?): Long? = runLinkFromDeepLink(link)?.runId
@@ -1,6 +1,15 @@
package net.awan.pipelines.ui
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.HelpOutline
import androidx.compose.material.icons.automirrored.filled.Segment
import androidx.compose.material.icons.automirrored.filled.Subject
import androidx.compose.material.icons.filled.AccountTree
import androidx.compose.material.icons.filled.Commit
import androidx.compose.material.icons.filled.History
import androidx.compose.runtime.Immutable
import androidx.compose.ui.graphics.vector.ImageVector
import java.time.OffsetDateTime
import net.awan.pipelines.data.protocol.Protocol
import net.awan.pipelines.data.protocol.RunStep
import net.awan.pipelines.data.protocol.SearchArtifact
@@ -11,22 +20,50 @@ import net.awan.pipelines.data.protocol.SearchResult
import net.awan.pipelines.data.protocol.SearchRun
import net.awan.pipelines.data.protocol.SearchStep
import net.awan.pipelines.data.protocol.SearchVersion
import net.awan.pipelines.ui.graph.artifactIcon
import net.awan.pipelines.ui.graph.artifactKind
import net.awan.pipelines.ui.graph.artifactKindLabel
import net.awan.pipelines.ui.screens.runTimeline
// ---------------------------------------------------------------------------
// Row model: the badge, title and secondary line of one result. Pure (no
// Row model: the glyph, title and secondary line of one result. Pure (no
// Compose, no coroutines), so the mapping for every kind is unit-testable.
// ---------------------------------------------------------------------------
/** The short mixed-list type badge for a result kind. */
fun searchBadge(kind: String): String = when (kind) {
Protocol.SEARCH_KIND_PIPELINE, Protocol.SEARCH_KIND_VERSION -> "pipeline"
Protocol.SEARCH_KIND_RUN -> "run"
Protocol.SEARCH_KIND_STEP -> "step"
Protocol.SEARCH_KIND_ARTIFACT -> "artifact"
// A text ("field") match and an unknown kind both read as a generic match;
// the unknown one is additionally labelled read-only by [searchRow].
else -> "match"
/**
* The glyph that names one result's type at a glance: the result's kind, and for
* an artifact the file type its content resolves to. The artifact mapping is the
* gallery's own ([artifactKind]/[artifactIcon]) rather than a second copy, so the
* two surfaces can never disagree about a file. The payload decides the branch,
* exactly as [searchRow] does, so a known payload with an unknown kind string
* still gets the right glyph and an unrecognised result falls back to a neutral
* mark instead of vanishing.
*/
fun searchResultIcon(hit: SearchResult): ImageVector = when {
hit.pipeline != null -> Icons.Filled.AccountTree
hit.version != null -> Icons.Filled.Commit
hit.run != null -> Icons.Filled.History
hit.step != null -> Icons.AutoMirrored.Filled.Segment
hit.field != null -> Icons.AutoMirrored.Filled.Subject
hit.artifact != null -> artifactIcon(artifactKind(hit.artifact.contentType, hit.artifact.name))
else -> Icons.AutoMirrored.Filled.HelpOutline
}
/**
* The kind in words for a row's accessible description, so a screen reader hears
* what the row is even though the glyph alone carries no text. An artifact is
* named by its own content type ("Image artifact", "JSON artifact"), from the
* same gallery classification [searchResultIcon] uses.
*/
fun searchResultKindLabel(hit: SearchResult): String = when {
hit.pipeline != null -> "Pipeline"
hit.version != null -> "Pipeline version"
hit.run != null -> "Run"
hit.step != null -> "Step"
hit.field != null -> "Field"
hit.artifact != null ->
"${artifactKindLabel(artifactKind(hit.artifact.contentType, hit.artifact.name))} artifact"
else -> "Unrecognised result"
}
/**
@@ -38,13 +75,12 @@ fun searchBadge(kind: String): String = when (kind) {
data class SnippetSpan(val text: String, val matched: Boolean)
/**
* One rendered search row: its type badge, a title and a secondary line. [snippet]
* is non-null only for a text ("field") match and carries the snippet split so the
* matched span is distinguishable without colour.
* One rendered search row: its title and a secondary line. [snippet] is non-null
* only for a text ("field") match and carries the snippet split so the matched
* span is distinguishable without colour.
*/
@Immutable
data class SearchRow(
val badge: String,
val title: String,
val secondary: String,
val snippet: List<SnippetSpan>? = null,
@@ -56,7 +92,6 @@ data class SearchRow(
* renders its stable target (or a placeholder) and a `read-only` note.
*/
fun searchRow(hit: SearchResult, query: String): SearchRow {
val badge = searchBadge(hit.kind)
val pipeline: SearchPipeline? = hit.pipeline
val version: SearchVersion? = hit.version
val run: SearchRun? = hit.run
@@ -65,12 +100,10 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
val artifact: SearchArtifact? = hit.artifact
return when {
pipeline != null -> SearchRow(
badge,
pipeline.name.ifBlank { "pipeline ${pipeline.id}" },
"pipeline ${pipeline.id} · v${pipeline.version} · ${stageCountText(pipeline.stages)}",
)
version != null -> SearchRow(
badge,
"pipeline ${version.pipelineId} · v${version.version}",
listOfNotNull(
version.contentHash.takeIf { it.isNotBlank() }?.let { "content $it" },
@@ -78,7 +111,6 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
).joinToString(" · "),
)
run != null -> SearchRow(
badge,
"run #${run.id}" + run.pipelineName.takeIf { it.isNotBlank() }?.let { " · $it" }.orEmpty(),
listOfNotNull(
run.status.takeIf { it.isNotBlank() },
@@ -87,18 +119,15 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
).joinToString(" · "),
)
step != null -> SearchRow(
badge,
"run #${step.runId} · ${step.stage.ifBlank { "step" }} visit ${step.visit}",
stepSecondary(step),
)
field != null -> SearchRow(
badge,
"run #${field.runId} · step ${field.sequence} · ${field.field.ifBlank { "field" }}",
field.snippet,
snippetSpans(field.snippet, query),
)
artifact != null -> SearchRow(
badge,
artifact.name.ifBlank { "artifact" },
listOfNotNull(
"run #${artifact.runId}",
@@ -108,7 +137,6 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
).joinToString(" · "),
)
else -> SearchRow(
badge,
hit.target.ifBlank { "Unrecognised result" },
if (hit.kind.isBlank()) "read-only" else "kind \"${hit.kind}\" · read-only",
)
@@ -145,6 +173,92 @@ fun snippetSpans(snippet: String, query: String): List<SnippetSpan> {
}
}
// ---------------------------------------------------------------------------
// Narrowing and ordering: the filter/sort control's pure model. Pure (no
// Compose), so the kind narrowing and each order are unit-testable.
// ---------------------------------------------------------------------------
/**
* The kind narrowing the search filter control offers. [serverKind] is exactly the
* server's SearchRequest kind vocabulary (internal/protocol/search.go), sent and
* stored verbatim; [All] is the empty kind.
*
* There is deliberately no "prompts" entry: the server has no such kind (its
* kinds are pipeline, version, run, step, field and artifact), so a filter that
* could only ever match nothing is not offered.
*/
enum class SearchKindFilter(val label: String, val serverKind: String) {
All("All kinds", ""),
Pipelines("Pipelines", Protocol.SEARCH_KIND_PIPELINE),
Runs("Runs", Protocol.SEARCH_KIND_RUN),
Steps("Steps", Protocol.SEARCH_KIND_STEP),
Fields("Fields", Protocol.SEARCH_KIND_FIELD),
Artifacts("Artifacts", Protocol.SEARCH_KIND_ARTIFACT),
Versions("Versions", Protocol.SEARCH_KIND_VERSION);
companion object {
val Default = All
/** Resolves a stored kind, tolerating a blank/stale value by returning [Default]. */
fun fromStorage(value: String?): SearchKindFilter =
entries.firstOrNull { it.serverKind == value } ?: Default
}
}
/**
* The orders the search sort control offers. [Relevance] keeps the server's own
* ranking (score, then recency, then a stable kind/target tie-break). [Newest]
* and [Name] cannot be asked of the server - its search command takes only a
* query, an optional kind and a limit - so they order the results already in
* hand, and the control says so.
*/
enum class SearchSort(val label: String, val storageKey: String) {
Relevance("Relevance", "relevance"),
Newest("Newest first", "newest"),
Name("Name", "name");
companion object {
val Default = Relevance
/** Resolves a stored order, tolerating a blank/stale value by returning [Default]. */
fun fromStorage(value: String?): SearchSort =
entries.firstOrNull { it.storageKey == value } ?: Default
}
}
/** The one-line summary of the active filter and sort the collapsed control shows. */
fun searchControlsSummary(kind: SearchKindFilter, sort: SearchSort): String {
// Only Relevance is the server's own ranking; the other orders run on the
// results in hand, so the summary says so even when the menu is closed.
val reach = if (sort == SearchSort.Relevance) "" else " (in hand)"
return "${kind.label} · ${sort.label}$reach"
}
/**
* Narrows [results] to [filter]'s kind. The filter is also sent to the server
* (SearchRequest.kind), so this only re-narrows the results already in hand,
* keeping the panel honest while a narrowed request loads.
*/
fun filterSearchResults(results: List<SearchResult>, filter: SearchKindFilter): List<SearchResult> =
if (filter == SearchKindFilter.All) results else results.filter { it.kind == filter.serverKind }
/**
* Orders [results] by [sort]. [Relevance] leaves the server's ranking untouched;
* [Newest] and [Name] sort the results in hand (the server has no sort). The
* sorts are stable, so two results that tie keep the server's order rather than
* swapping arbitrarily.
*/
fun sortSearchResults(results: List<SearchResult>, sort: SearchSort): List<SearchResult> = when (sort) {
SearchSort.Relevance -> results
SearchSort.Newest -> results.sortedWith(
compareByDescending<SearchResult> { parseInstant(it.recency.orEmpty()) ?: OffsetDateTime.MIN },
)
SearchSort.Name -> results
.map { it to searchRow(it, "").title }
.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.second })
.map { it.first }
}
// ---------------------------------------------------------------------------
// Navigation: the destination a result resolves to. Pure, so the mapping for
// every kind is unit-testable.
@@ -284,6 +398,22 @@ fun SearchUiState.loaded(response: SearchResponse): SearchUiState =
fun SearchUiState.failed(message: String?): SearchUiState =
copy(loading = false, error = message, loaded = true)
/** Whether the panel shows the explicit, query-naming empty state. */
fun SearchUiState.isEmptyResult(): Boolean =
error == null && !loading && loaded && results.isEmpty() && query.isNotBlank()
/**
* The empty-state line the panel shows when it has no rows to render for [query]
* under [kind], or null when it is showing rows, progress or nothing at all.
* [shown] is the filtered and sorted list actually displayed, so a filter that
* empties the list reports itself ("No runs match …") rather than the generic
* line. Pure, so the empty state is unit-testable without a device.
*/
fun searchPanelEmptyMessage(
state: SearchUiState,
shown: List<SearchResult>,
kind: SearchKindFilter,
): String? = when {
state.error != null -> null
shown.isNotEmpty() -> null
state.loading -> null
state.query.isBlank() -> null
kind == SearchKindFilter.All -> "No matches for \"${state.query}\"."
else -> "No ${kind.label.lowercase()} match \"${state.query}\"."
}
@@ -1,6 +1,9 @@
package net.awan.pipelines.ui
import android.Manifest
import androidx.activity.compose.BackHandler
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
@@ -23,8 +26,11 @@ import androidx.compose.material.icons.automirrored.filled.Chat
import androidx.compose.material.icons.filled.AccountTree
import androidx.compose.material.icons.filled.History
import androidx.compose.material.icons.filled.Settings
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
@@ -39,6 +45,8 @@ import androidx.compose.ui.input.pointer.pointerInput
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.compose.LifecycleEventEffect
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
@@ -46,6 +54,8 @@ import androidx.navigation.compose.currentBackStackEntryAsState
import androidx.navigation.compose.rememberNavController
import net.awan.pipelines.data.protocol.SearchResult
import net.awan.pipelines.data.transport.ConnectionState
import net.awan.pipelines.notify.NOTIFICATION_RATIONALE
import net.awan.pipelines.notify.alertPermissionPrompt
import net.awan.pipelines.ui.chat.ChatScreen
import net.awan.pipelines.ui.components.AttentionIndicator
import net.awan.pipelines.ui.components.AttentionSheet
@@ -91,6 +101,7 @@ internal fun backFrom(selection: PaneSelection): PaneSelection =
fun PipelinesApp(
vm: AppViewModel,
initialRunId: Long? = null,
initialRunAction: String? = null,
onInitialRunHandled: () -> Unit = {},
) {
val navController = rememberNavController()
@@ -118,10 +129,42 @@ fun PipelinesApp(
// run's steps are loaded; the Runs destination applies it then (see below).
var runSearchNav by remember { mutableStateOf<SearchTarget.Run?>(null) }
// A waiting run's decision sheet to open once its detail has loaded. Set by a
// notification's `decide` deep link (the tap lands on the decision, not just
// the run), cleared by the detail once it has opened the sheet.
var decisionRequest by rememberSaveable { mutableStateOf<Long?>(null) }
// Whether the attention list is open. It is not a navigation destination, so
// the operator's current destination and panes are untouched while it shows.
var attentionOpen by rememberSaveable { mutableStateOf(false) }
// The notification permission: asked at most once, at a sensible moment — the
// first time a run actually needs the operator, or the first time the
// attention surface is opened — and never nagged. The rationale is shown
// before the one system dialog; a refusal simply leaves the in-app Needs you
// surface as the only surface, which is exactly what the app did before.
val notificationsAllowed by vm.notificationsAllowed.collectAsStateWithLifecycle()
val permissionAsked by vm.notificationPermissionAsked.collectAsStateWithLifecycle()
var rationaleOpen by rememberSaveable { mutableStateOf(false) }
val permissionLauncher = rememberLauncherForActivityResult(
ActivityResultContracts.RequestPermission(),
) { vm.refreshNotificationsAllowed() }
LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { vm.refreshNotificationsAllowed() }
val needsPerson = attention.isNotEmpty()
LaunchedEffect(notificationsAllowed, permissionAsked, needsPerson, attentionOpen) {
val prompt = alertPermissionPrompt(
granted = notificationsAllowed,
asked = permissionAsked,
trigger = needsPerson || attentionOpen,
)
if (prompt.request) {
// Remember the ask first, so dismissing the rationale is never a nag
// and a recomposition cannot ask twice.
vm.markNotificationPermissionAsked()
rationaleOpen = true
}
}
// The bottom container's morph (destination pill <-> omni-search field) is
// saved state, so a still-open field survives rotation, configuration change
// and process death. Opening never navigates, so the destination the pill had
@@ -136,6 +179,8 @@ fun PipelinesApp(
// the chat list for the conversation.
val conversationOpen by vm.conversationOpen.collectAsStateWithLifecycle()
val pillVisible = destinationPillVisible(currentRoute, conversationOpen)
val searchKind by vm.searchKind.collectAsStateWithLifecycle()
val searchSort by vm.searchSort.collectAsStateWithLifecycle()
/** Back/scrim/close and a selection all dismiss the morph and clear the panel. */
val dismissSearch: () -> Unit = {
@@ -166,31 +211,35 @@ fun PipelinesApp(
// Opening the run a notification or an attention entry names: the Runs
// destination's saved selection points at it, then that destination is shown.
// Reaching it also clears its notification, and a run that is still waiting is
// not re-notified.
val openRunFromAttention: (Long) -> Unit = { runId ->
vm.arrivedAtRun(runId)
runSelection = PaneSelection(pane = MasterPane.Detail, itemId = runId)
navController.navigate("runs") { launchSingleTop = true }
}
// A deep link (or the notification's click action) opens its run once. The
// effect re-runs only when the link changes, and the link is cleared once
// handled, so a rotation re-opens nothing.
LaunchedEffect(initialRunId) {
// handled, so a rotation re-opens nothing. A waiting run's notification also
// asks for the decision sheet, so the tap lands on the decision itself.
LaunchedEffect(initialRunId, initialRunAction) {
if (initialRunId != null) {
if (initialRunAction == RUN_DEEP_LINK_ACTION_DECIDE) decisionRequest = initialRunId
openRunFromAttention(initialRunId)
onInitialRunHandled()
}
}
// Closing the list counts as looking: a run that merely finished since the
// last look clears on this look, while a waiting or failed run stays until it
// is resolved or deliberately dismissed.
// Closing the list counts as looking, but only at what still asks: a waiting
// or failed run stays on the surface until it is resolved or deliberately
// dismissed, so closing never hides work that still needs the operator.
val closeAttentionList: () -> Unit = {
vm.sawFinishedAttention(attention.filter { it.kind == AttentionKind.Finished }.map { it.runId })
attentionOpen = false
}
// Opening an entry deals with it: a failure (like a finished run) is cleared
// by opening it, a waiting run is not, because only its decision clears it.
// Opening an entry deals with it: a failure is cleared by opening it, a
// waiting run is not, because only its decision clears it.
val openAttentionEntry: (AttentionEntry) -> Unit = { entry ->
if (entry.kind != AttentionKind.Decision) {
vm.dismissAttention(entry.runId, entry.kind)
@@ -279,6 +328,8 @@ fun PipelinesApp(
pendingNav = runSearchNav,
onPendingNavResolved = { runSearchNav = null },
listState = runListState,
decisionRequest = decisionRequest,
onDecisionRequestHandled = { decisionRequest = null },
)
}
composable("chat") {
@@ -327,9 +378,13 @@ fun PipelinesApp(
verticalArrangement = Arrangement.Bottom,
horizontalAlignment = Alignment.End,
) {
if (searchState.open && searchState.query.isNotBlank()) {
if (searchState.open) {
SearchResultsPanel(
state = search,
kind = SearchKindFilter.fromStorage(searchKind),
sort = SearchSort.fromStorage(searchSort),
onKind = { vm.setSearchKind(it.serverKind) },
onSort = { vm.setSearchSort(it.storageKey) },
onSelect = onSelectResult,
modifier = Modifier
.fillMaxWidth()
@@ -370,6 +425,27 @@ fun PipelinesApp(
onDismiss = closeAttentionList,
)
}
// The one-time rationale before the system notification dialog. It is
// shown only on the first ask (the permission model decides), so a
// refusal or dismissal leaves the in-app surface alone from then on.
if (rationaleOpen) {
AlertDialog(
onDismissRequest = { rationaleOpen = false },
title = { Text("Notifications") },
text = { Text(NOTIFICATION_RATIONALE) },
confirmButton = {
TextButton(
onClick = {
rationaleOpen = false
permissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
},
) { Text("Allow") }
},
dismissButton = {
TextButton(onClick = { rationaleOpen = false }) { Text("Not now") }
},
)
}
}
}
}
@@ -32,6 +32,8 @@ internal fun RunsDestination(
pendingNav: SearchTarget.Run?,
onPendingNavResolved: () -> Unit,
listState: LazyListState,
decisionRequest: Long? = null,
onDecisionRequestHandled: () -> Unit = {},
) {
val depth = selection.depth
val onBack: () -> Unit = { onSelectionChange(backFrom(selection)) }
@@ -99,6 +101,8 @@ internal fun RunsDestination(
)
},
covered = covered,
requestDecision = decisionRequest == itemId,
onDecisionRequestHandled = onDecisionRequestHandled,
)
}
2 -> rememberPaneContent(
@@ -12,6 +12,7 @@ import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.HorizontalDivider
import androidx.compose.material3.Icon
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Surface
@@ -30,31 +31,47 @@ import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.text.withStyle
import androidx.compose.ui.unit.dp
import net.awan.pipelines.data.protocol.SearchResult
import net.awan.pipelines.ui.components.LabelChip
import net.awan.pipelines.ui.components.FilterCheckItem
import net.awan.pipelines.ui.components.FilterMenu
import net.awan.pipelines.ui.components.SortMenu
import net.awan.pipelines.ui.theme.ICON_LIST_DP
import net.awan.pipelines.ui.theme.SEARCH_PROGRESS_DP
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_M
import net.awan.pipelines.ui.theme.SPACING_S
import net.awan.pipelines.ui.theme.SPACING_XXS
import net.awan.pipelines.ui.theme.SPACING_XL
import net.awan.pipelines.ui.theme.SPACING_XS
import net.awan.pipelines.ui.theme.SPACING_XXS
import net.awan.pipelines.ui.theme.pipelinesText
/**
* The omni-search results panel: one scrolling surface that sits above the search
* field. It renders the last accepted results, and while a newer query loads it
* keeps those results and adds a thin progress bar rather than blanking; a
* failure is reported without discarding what is already shown. Its height is
* bounded by the caller (the window's IME/navigation-bar insets), so it scrolls
* inside the remainder instead of running under the keyboard.
* field. It leads with the filter and sort controls (the same shared menu
* controls the runs list uses), then renders the last accepted results; while a
* newer query loads it keeps those results and adds a thin progress bar rather
* than blanking, and a failure is reported without discarding what is already
* shown. Its height is bounded by the caller (the window's IME/navigation-bar
* insets), so it scrolls inside the remainder instead of running under the
* keyboard.
*/
@Composable
internal fun SearchResultsPanel(
state: SearchUiState,
kind: SearchKindFilter,
sort: SearchSort,
onKind: (SearchKindFilter) -> Unit,
onSort: (SearchSort) -> Unit,
onSelect: (SearchResult) -> Unit,
modifier: Modifier = Modifier,
) {
val scheme = MaterialTheme.colorScheme
val error = state.error
// The filter and sort are applied to the results in hand as well as being sent
// to the server (the kind) or held client-side (the order), so the list always
// matches the active control, even for the moment a narrowed request loads.
val shown = remember(state.results, kind, sort) {
sortSearchResults(filterSearchResults(state.results, kind), sort)
}
Surface(
modifier = modifier,
shape = RoundedCornerShape(SPACING_XL),
@@ -63,6 +80,8 @@ internal fun SearchResultsPanel(
shadowElevation = 6.dp,
) {
Column(Modifier.fillMaxWidth()) {
SearchControls(kind = kind, sort = sort, onKind = onKind, onSort = onSort)
HorizontalDivider(color = scheme.outlineVariant)
// A refresh of an already-populated panel shows progress without
// replacing the results; the first load shows the searching row below.
if (state.loading && state.results.isNotEmpty()) {
@@ -70,14 +89,68 @@ internal fun SearchResultsPanel(
}
when {
error != null -> PanelMessage(error, isError = true)
state.isEmptyResult() -> PanelMessage("No matches for \"${state.query}\".", isError = false)
shown.isNotEmpty() -> SearchResultList(shown, state.query, onSelect)
state.loading && state.results.isEmpty() -> SearchingRow()
state.results.isNotEmpty() -> SearchResultList(state.results, state.query, onSelect)
else -> searchPanelEmptyMessage(state, shown, kind)?.let { PanelMessage(it, isError = false) }
}
}
}
}
/**
* The search surface's filter and sort control, the same shared [FilterMenu] and
* [SortMenu] the runs list uses rather than a new pattern, plus the one-line
* summary of the active choice so the collapsed controls are legible. The kind
* filter narrows server-side; the sort orders the results in hand.
*/
@Composable
private fun SearchControls(
kind: SearchKindFilter,
sort: SearchSort,
onKind: (SearchKindFilter) -> Unit,
onSort: (SearchSort) -> Unit,
) {
Row(
// The top inset leaves room for the filter badge, which is drawn above the
// icon button; without it the badge spills over the panel's rounded edge.
modifier = Modifier
.fillMaxWidth()
.padding(start = SPACING_S, end = SPACING_XS, top = SPACING_S, bottom = SPACING_XS),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
FilterMenu(
activeCount = if (kind == SearchKindFilter.All) 0 else 1,
contentDescription = "Filter results",
resetLabel = "Clear filter",
onReset = { onKind(SearchKindFilter.Default) },
) { dismiss ->
SearchKindFilter.entries.forEach { option ->
FilterCheckItem(option.label, option == kind) {
onKind(option)
dismiss()
}
}
}
SortMenu(
options = SearchSort.entries,
selected = sort,
label = { it.label },
header = "Sort results in hand",
contentDescription = "Sort results in hand",
onSelect = onSort,
onReset = { onSort(SearchSort.Default) },
)
Text(
text = searchControlsSummary(kind, sort),
style = pipelinesText().meta,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f).padding(start = SPACING_S),
)
}
}
@Composable
private fun PanelMessage(message: String, isError: Boolean) {
Text(
@@ -127,10 +200,12 @@ private fun SearchResultList(
}
/**
* One result row: its type badge, a title and a secondary line. A text match's
* secondary line is its snippet with the matched span rendered bold+underlined,
* so the match is distinguishable without relying on colour. A result with no
* navigation target (an unknown kind) is shown read-only and is not clickable.
* One result row: the type glyph (its kind, or an artifact's content type), a
* title and a secondary line. The glyph carries the kind in words as its
* content description, since the mark alone is not readable, and the matched span
* of a text match is rendered bold+underlined, so the match is distinguishable
* without relying on colour. A result with no navigation target (an unknown kind)
* is shown read-only and is not clickable.
*/
@Composable
private fun SearchResultRow(
@@ -151,9 +226,15 @@ private fun SearchResultRow(
},
)
.padding(horizontal = SPACING_L, vertical = SPACING_M),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(SPACING_M),
) {
LabelChip(row.badge, SPACING_S, SPACING_XXS)
Icon(
imageVector = searchResultIcon(hit),
contentDescription = searchResultKindLabel(hit),
tint = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.size(ICON_LIST_DP),
)
Column(
modifier = Modifier.weight(1f),
verticalArrangement = Arrangement.spacedBy(SPACING_XXS),
@@ -51,9 +51,9 @@ internal fun ChatComposer(
}
Surface(color = MaterialTheme.colorScheme.surfaceContainer) {
Column(Modifier.fillMaxWidth().padding(CHAT_GUTTER)) {
if (thread.readOnly) {
if (thread.queued) {
Text(
text = "Another client holds this session; it is read-only here.",
text = "Queued — it will send when the current turn finishes.",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(bottom = CHAT_ITEM_GAP),
@@ -65,14 +65,12 @@ internal fun ChatComposer(
Row(verticalAlignment = Alignment.Bottom, horizontalArrangement = Arrangement.spacedBy(CHAT_COMPOSER_GAP)) {
IconButton(
onClick = { picker.launch(arrayOf("*/*")) },
enabled = !thread.readOnly,
) {
Icon(Icons.Default.AttachFile, contentDescription = "Attach file")
}
OutlinedTextField(
value = thread.draft,
onValueChange = onDraft,
enabled = !thread.readOnly,
placeholder = { Text("Message the agent…") },
minLines = 1,
maxLines = 6,
@@ -213,11 +213,7 @@ internal fun ChatConversationPane(
onRetry = { vm.loadChatHistory(thread.sessionId) },
)
thread.messages.isEmpty() && !thread.running && approval == null -> EmptyState(
message = if (thread.readOnly) {
"This chat is read-only while another client holds the session."
} else {
"This chat has no messages yet. Ask something below."
},
message = "This chat has no messages yet. Ask something below.",
)
else -> ChatTranscript(
thread = thread,
@@ -7,6 +7,7 @@ import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import net.awan.pipelines.data.protocol.ChatPart
import net.awan.pipelines.data.protocol.ChatPermissionFrame
import net.awan.pipelines.data.protocol.ChatMessage
import net.awan.pipelines.data.protocol.ChatProtocol
import net.awan.pipelines.data.protocol.ChatSession
import net.awan.pipelines.data.protocol.ChatToolState
@@ -79,6 +80,126 @@ internal fun formatToolDuration(millis: Long): String = when {
/** The chip label for a tool call: its name, or a placeholder when unnamed. */
internal fun toolLabel(part: ChatPart): String = part.name.ifBlank { "tool" }
/**
* The in-flight tool calls across a conversation's [messages], in transcript
* order, so the conversation's indicator and the session row read the same set
* and its order is stable from frame to frame (a chip is never re-ordered by a
* rebuild). A call drops out the moment it completes or errors, which is what
* clears the indicator, so nothing here ever invents a finish time.
*/
internal fun runningToolCalls(messages: List<ChatMessage>): List<ChatPart> =
messages.flatMap { it.parts }
.filter { it.type == ChatProtocol.PART_TOOL && ChatProtocol.toolRunning(it.state) }
/**
* The input keys, in preference order, that carry a human-facing command or a
* short description of what a tool call is doing. OpenCode's tools put the
* substance in different places (`command` for a shell, `description` for a task,
* a path or pattern for the file/search tools), so the first one present is shown
* rather than the raw arguments.
*/
private val TOOL_DETAIL_KEYS = listOf(
"description", "command", "filePath", "file_path", "path", "pattern", "query", "url",
)
/** How much of a command/description the phone shows before it is elided. */
private const val TOOL_DETAIL_MAX_LENGTH = 72
private val TOOL_DETAIL_WHITESPACE = Regex("\\s+")
/**
* A one-line command or short description for [part], taken from the input the
* part actually carries: the first of [TOOL_DETAIL_KEYS] present, collapsed to a
* single line and elided past [TOOL_DETAIL_MAX_LENGTH]. Null when the input
* carries no such key (a partial-JSON string while the call is still streaming,
* or a tool that reports none), so a caller shows the name alone rather than a
* fabricated summary.
*/
internal fun toolDetail(part: ChatPart): String? {
val obj = part.state?.input as? JsonObject ?: return null
for (key in TOOL_DETAIL_KEYS) {
val value = obj[key] as? JsonPrimitive ?: continue
if (!value.isString) continue
val text = value.content.trim().replace(TOOL_DETAIL_WHITESPACE, " ")
if (text.isBlank()) continue
return if (text.length <= TOOL_DETAIL_MAX_LENGTH) {
text
} else {
text.take(TOOL_DETAIL_MAX_LENGTH - 1).trimEnd() + "…"
}
}
return null
}
/**
* How long a running [part] has been going at [nowMillis]. The protocol's own
* timing wins whenever the part carries it (a running call from stored history
* has `time.ran`, the moment it started); otherwise the elapsed is measured
* locally from [startedAt] — the wall clock at which this client first saw the
* part running. Zero when neither is usable, so a caller never shows a time it
* cannot stand behind.
*/
internal fun runningToolElapsedMillis(part: ChatPart, startedAt: Long, nowMillis: Long): Long {
val protocolStart = part.time?.let { if (it.ran > 0) it.ran else it.created } ?: 0L
val start = if (protocolStart > 0) protocolStart else startedAt
return if (start in 1 until nowMillis) nowMillis - start else 0L
}
/**
* A tool call running longer than this reads as unusually long on the phone and
* is marked, so a genuinely stuck call is visible without a fabricated ETA. One
* minute: long enough that ordinary calls (a build, a search, a command) are not
* flagged, short enough that a hung call stands out while the operator is still
* wondering.
*/
internal const val TOOL_LONG_RUNNING_MILLIS: Long = 60_000L
/** Whether a running call has been going long enough to be marked as unusual. */
internal fun toolLongRunning(elapsedMillis: Long): Boolean = elapsedMillis >= TOOL_LONG_RUNNING_MILLIS
/**
* The running-tool start stamps after a thread's [messages] changed: every tool
* part in flight keeps the stamp it already had, or is stamped with [now] when it
* has just turned running, and a part that is no longer running loses its stamp.
* Kept free of Compose and of [ChatStore] so the bookkeeping and its unit test
* share one rule, and a stamp never moves forward while a call keeps running.
*/
internal fun runningToolStamps(
current: Map<String, Long>,
messages: List<ChatMessage>,
now: Long,
): Map<String, Long> {
val stamps = LinkedHashMap<String, Long>()
messages.forEach { message ->
message.parts.forEach { part ->
if (part.id.isNotEmpty() && part.type == ChatProtocol.PART_TOOL && ChatProtocol.toolRunning(part.state)) {
stamps[part.id] = current[part.id] ?: now
}
}
}
return stamps
}
/**
* The status a session row reports while a turn is in flight: it names the tool
* call it is parked on (or how many, when several run at once) so a working chat
* says what it is doing rather than just `Running`, and a chat only generating
* text still reads as plain `Running` — the two are never confused. A chat with
* nothing running falls back to the ordinary busy/idle label, so a session
* waiting on another client is never shown as idle.
*/
internal fun sessionWorkLabel(busy: Boolean, thread: ChatThread?): String = when {
thread?.running == true -> runningSessionLabel(thread.runningTools)
busy -> "Busy · read-only"
else -> "Idle"
}
private fun runningSessionLabel(tools: List<ChatPart>): String = when (tools.size) {
0 -> "Running"
1 -> "Running ${toolLabel(tools.single())}"
else -> "Running ${tools.size} tools"
}
/**
* A session's short title: the server title, or a truncated id when untitled, so
* a row never renders as a blank line.
@@ -125,26 +246,24 @@ internal fun chatHeaderMeta(thread: ChatThread): String = listOfNotNull(
private const val OPERATOR_TAG_LABEL = "Operator"
/**
* The status a session row shows. A locally-running turn is reported as
* `Running`; otherwise the server's `busy` flag is `Busy · read-only` (another
* client holds it, so the composer is disabled), else `Idle`.
*
* This is the same precedence [ChatThread.readOnly] applies: a turn we started is
* `Running` and writable, never the read-only the server's own `busy` flag alone
* would imply.
* The status a session row shows: `Running` while this client has a turn in
* flight, else `Idle`. A session is never reported `Busy` or read-only because
* another client is watching it — the server fans the stream out and accepts a
* prompt from any client, so the session stays writable everywhere.
*/
internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String =
sessionStatusLabel(session.busy, runningLocally, session.closed)
sessionStatusLabel(runningLocally, session.closed)
/**
* The status of a conversation from its own model flags (see [sessionStatusLabel]).
* A closed session reads `Closed` first: it is finished, whatever the server's
* busy flag or a stale local running mark says.
* The status of a conversation from its own flags (see [sessionStatusLabel]).
* A closed session reads `Closed` first: it is finished, whatever a stale local
* running mark says. A session is never reported `Busy` or read-only because
* another client is watching it — the server fans the stream out and accepts a
* prompt from any client, so the session stays writable everywhere.
*/
internal fun sessionStatusLabel(busy: Boolean, runningLocally: Boolean, closed: Boolean = false): String = when {
internal fun sessionStatusLabel(runningLocally: Boolean, closed: Boolean = false): String = when {
closed -> "Closed"
runningLocally -> "Running"
busy -> "Busy · read-only"
else -> "Idle"
}
@@ -188,7 +307,7 @@ internal data class ConversationHeader(
internal fun conversationHeader(thread: ChatThread): ConversationHeader = ConversationHeader(
title = sessionTitle(ChatSession(id = thread.sessionId, title = thread.title)),
kind = sessionTagLabel(thread.tag),
activity = sessionStatusLabel(thread.busy, thread.running, thread.closed),
activity = sessionStatusLabel(thread.running, thread.closed),
directory = thread.directory,
model = thread.model,
)
@@ -278,8 +278,8 @@ private fun SessionListItem(
val thread = state.thread(session.id)
SessionRow(
session = session,
thread = thread,
open = thread != null,
running = thread?.running == true,
unseen = !session.closed && state.isUnseen(session),
active = state.activeId == session.id,
onClick = { vm.openChatSession(session) },
@@ -314,8 +314,8 @@ private const val NO_DIRECTORY_LABEL = "No directory"
@Composable
private fun SessionRow(
session: ChatSession,
thread: ChatThread?,
open: Boolean,
running: Boolean,
unseen: Boolean,
active: Boolean,
onClick: () -> Unit,
@@ -325,6 +325,7 @@ private fun SessionRow(
onHide: () -> Unit,
) {
val texts = pipelinesText()
val running = thread?.running == true
val activity = sessionActivity(running, unseen)
ListRow(selected = active, onClick = onClick) {
Row(
@@ -358,7 +359,7 @@ private fun SessionRow(
)
}
val meta = buildList {
add(sessionStatusLabel(session, running))
add(sessionWorkLabel(session.busy, thread))
if (session.directory.isNotBlank()) add(session.directory)
if (session.model.isNotBlank()) add(session.model)
}.joinToString(" · ")
@@ -76,6 +76,15 @@ data class ChatThread(
* the turn settles.
*/
val runningSince: Long = 0,
/**
* Wall-clock epoch millis each currently-running tool call was first seen
* running, keyed by the tool part's id. The brokered stream pushes a tool part
* with no timing envelope, so a running call's elapsed time is measured from
* here; a call that settles loses its stamp. Kept on the thread (not in the
* composable) so the elapsed time survives a chat switch, exactly like
* [runningSince] does for the turn.
*/
val toolStartedAt: Map<String, Long> = emptyMap(),
/** The unsent composer text for this chat. */
val draft: String = "",
/**
@@ -100,24 +109,26 @@ data class ChatThread(
* settle in place optimistically and survives a chat switch.
*/
val permissionAnswer: String = "",
/**
* The last prompt this client sent was accepted into the session's queue
* behind an in-flight turn (the server acknowledged it as queued), so the
* composer can say so instead of blocking. Cleared as soon as the turn's
* frames arrive or the thread settles.
*/
val queued: Boolean = false,
) {
/**
* Read-only while another client holds the session: the composer must never
* write to it. A turn we started ourselves keeps the session writable even
* though the server reports it busy (the server owns it as our active run),
* so the one rule here agrees with [sessionStatusLabel]'s `Running` case.
* At least one attachment is flagged; the prompt must not be sent with it.
*/
val readOnly: Boolean get() = busy && !running
/** At least one attachment is flagged; the prompt must not be sent with it. */
val hasAttachmentErrors: Boolean get() = attachments.any { it.error != null }
/**
* Whether the composer's send action is allowed. A message with a flagged
* attachment is never sent: the operator must remove or re-attach it first,
* so the file is never silently dropped.
* Whether the composer's send action is allowed. A session is never read-only:
* another client may watch the same conversation without blocking this one. A
* message with a flagged attachment is never sent, so the file is never
* silently dropped.
*/
val canSend: Boolean get() = !readOnly && draft.isNotBlank() && !hasAttachmentErrors
val canSend: Boolean get() = draft.isNotBlank() && !hasAttachmentErrors
/**
* Non-negative elapsed time of an in-flight turn at [nowMillis], or 0 once it
@@ -126,6 +137,22 @@ data class ChatThread(
*/
fun elapsedMillis(nowMillis: Long): Long =
if (running && runningSince in 1 until nowMillis) nowMillis - runningSince else 0
/**
* The tool calls still in flight for this session, in transcript order, so the
* conversation's in-flight indicator and the session row both read the same
* set. Empty once every call has completed or errored, which is what clears
* the indicator.
*/
val runningTools: List<ChatPart> get() = runningToolCalls(messages)
/**
* How long [part] has been running at [nowMillis]: the protocol's own timing
* when the part carries it, else the local start recorded in [toolStartedAt]
* (see [runningToolElapsedMillis]). Zero when neither is usable.
*/
fun toolElapsedMillis(part: ChatPart, nowMillis: Long): Long =
runningToolElapsedMillis(part, toolStartedAt[part.id] ?: 0L, nowMillis)
}
/**
@@ -644,7 +671,16 @@ class ChatStore(
*/
fun history(sessionId: String, messages: List<ChatMessage>) {
update(sessionId) {
it.copy(messages = messages, loading = false, loaded = true, error = null)
it.copy(
messages = messages,
loading = false,
loaded = true,
error = null,
// A running call the history reports (a turn that started before
// this fetch) is stamped now, the best local measurement there is;
// a call that already settled drops its stamp.
toolStartedAt = runningToolStamps(it.toolStartedAt, messages, now()),
)
}
// A conversation on screen is read as its history arrives: its recency
// watermark advances to the newest message the server reports (its own
@@ -657,6 +693,13 @@ class ChatStore(
fun running(sessionId: String, running: Boolean) = update(sessionId) { setRunning(it, running) }
/**
* Records that the operator's last prompt was accepted into the session's
* queue (true) or sent immediately (false), so the composer can say "Queued"
* while it waits for the in-flight turn without blocking input.
*/
fun setQueued(sessionId: String, queued: Boolean) = update(sessionId) { it.copy(queued = queued) }
/**
* The stream resumed (the socket reconnected): every frame that was feeding an
* in-flight turn is gone, so no thread keeps claiming to run until a fresh
@@ -669,7 +712,9 @@ class ChatStore(
val ids = _state.value.open.map { it.sessionId }
if (ids.isEmpty()) return ids
_state.value = _state.value.copy(
open = _state.value.open.map { if (it.running) it.copy(running = false, runningSince = 0) else it },
open = _state.value.open.map {
if (it.running) it.copy(running = false, runningSince = 0, toolStartedAt = emptyMap()) else it
},
)
return ids
}
@@ -771,7 +816,11 @@ class ChatStore(
if (frame.sessionId.isBlank()) return
ensureThread(frame.sessionId)
markUnread(frame.sessionId)
// Any frame for the session means the turn has moved on, so a prompt we
// had queued is no longer waiting.
update(frame.sessionId) { if (it.queued) it.copy(queued = false) else it }
when (frame.kind) {
ChatProtocol.EVENT_USER -> applyRemoteUser(frame)
ChatProtocol.PART_TEXT, ChatProtocol.PART_REASONING -> applyDelta(frame)
ChatProtocol.PART_TOOL -> applyTool(frame)
ChatProtocol.EVENT_STEP -> {
@@ -782,6 +831,28 @@ class ChatStore(
}
}
/**
* Folds a user turn another client sent into the transcript, in place, once.
* The server never echoes this client's own prompts, so the sender's own
* message is never duplicated; the [ChatMessage.client] label says which
* device sent it.
*/
private fun applyRemoteUser(frame: ChatEventFrame) {
val text = frame.part?.text.orEmpty()
if (frame.messageId.isEmpty() || text.isEmpty()) return
update(frame.sessionId) { thread ->
if (thread.messages.any { it.id == frame.messageId }) return@update thread
val message = ChatMessage(
id = frame.messageId,
sessionId = frame.sessionId,
role = ChatProtocol.ROLE_USER,
client = frame.client,
parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = text)),
)
thread.copy(messages = thread.messages + message)
}
}
/**
* Creates a placeholder thread for a session that is not open, so a frame for
* a background chat is kept instead of dropped. A no-op when it already exists.
@@ -842,7 +913,8 @@ class ChatStore(
val updated = upsert(if (partIndex >= 0) parts[partIndex] else null)
if (partIndex >= 0) parts[partIndex] = updated else parts.add(updated)
messages[resolvedIndex] = message.copy(parts = parts)
setRunning(thread.copy(messages = messages), true)
val stamped = runningToolStamps(thread.toolStartedAt, messages, now())
setRunning(thread.copy(messages = messages, toolStartedAt = stamped), true)
}
}
@@ -855,7 +927,7 @@ class ChatStore(
private fun setRunning(thread: ChatThread, running: Boolean): ChatThread = when {
running && !thread.running -> thread.copy(running = true, runningSince = now())
running -> thread
else -> thread.copy(running = false, runningSince = 0)
else -> thread.copy(running = false, runningSince = 0, toolStartedAt = emptyMap())
}
private fun update(sessionId: String, block: (ChatThread) -> ChatThread) {
@@ -20,6 +20,7 @@ import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.foundation.text.selection.SelectionContainer
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Build
import androidx.compose.material.icons.filled.KeyboardArrowDown
import androidx.compose.material.icons.filled.KeyboardArrowUp
import androidx.compose.material.icons.filled.Psychology
@@ -34,6 +35,7 @@ import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.derivedStateOf
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableLongStateOf
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
@@ -46,6 +48,7 @@ import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.collect
@@ -57,6 +60,7 @@ import net.awan.pipelines.ui.formatDuration
import net.awan.pipelines.ui.theme.CHAT_BUBBLE_MAX_WIDTH_DP
import net.awan.pipelines.ui.theme.CHAT_FOLLOW_THRESHOLD_DP
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
import net.awan.pipelines.ui.theme.ICON_STATUS_DP
import net.awan.pipelines.ui.theme.SPACING_XS
/** The running indicator's elapsed time ticks once a second, never per frame. */
@@ -274,24 +278,90 @@ private fun LazyListState.bottomDistancePx(itemCount: Int): Int? {
/**
* The in-flight turn indicator: a spinner, `Working…` and the turn's live elapsed
* time. The elapsed value is derived from the turn's own start ([ChatThread.elapsedMillis]),
* so it keeps counting across a chat switch, and the tick loop stops the moment
* the turn settles.
* time, then one compact line for each tool call in flight — its name, the
* command or description the part carries, and how long that call has been
* running. The elapsed values are derived from the turn's own start
* ([ChatThread.elapsedMillis]) and each call's own start
* ([ChatThread.toolElapsedMillis]), so they keep counting across a chat switch,
* and the tick loop stops the moment the turn settles. This is what makes the
* otherwise-silent part of a turn legible: the operator can tell `working on X`
* from `waiting on something` instead of watching a bare `Running`.
*/
@Composable
private fun RunningIndicator(thread: ChatThread) {
val elapsedMillis = thread.elapsedMillis(rememberElapsedNow(thread.runningSince))
val now = rememberElapsedNow(thread.runningSince)
val elapsedMillis = thread.elapsedMillis(now)
val tools = thread.runningTools
Column(
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
) {
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
) {
CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
Text("Working…", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
Text(
text = "· ${formatDuration(elapsedMillis / 1_000)}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
// One line per call in flight, in transcript order and keyed by the part,
// so several running at once read together rather than flickering between
// them; a call's line drops out the moment it completes or errors.
tools.forEach { part ->
key(part.id) { RunningToolLine(part, thread.toolElapsedMillis(part, now)) }
}
}
}
/**
* One tool call in flight: its name, the command or short description the part
* carries (when it carries one) and how long it has been running. A call that has
* been running past [TOOL_LONG_RUNNING_MILLIS] is tinted and labelled so a stuck
* call stands out. The elapsed time is the only progress signal; no percentage,
* ETA or progress bar is ever invented.
*/
@Composable
private fun RunningToolLine(part: ChatPart, elapsedMillis: Long) {
val long = toolLongRunning(elapsedMillis)
val tint = if (long) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant
val detail = toolDetail(part)
Row(
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
modifier = Modifier.fillMaxWidth().padding(start = CHAT_GUTTER),
) {
CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
Text("Working…", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
Icon(
Icons.Default.Build,
contentDescription = null,
tint = tint,
modifier = Modifier.size(ICON_STATUS_DP),
)
Text(
text = "· ${formatDuration(elapsedMillis / 1_000)}",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
text = toolLabel(part),
style = MaterialTheme.typography.labelMedium,
color = tint,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = if (detail == null) Modifier.weight(1f) else Modifier,
)
if (detail != null) {
Text(
text = detail,
style = MaterialTheme.typography.labelMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
maxLines = 1,
overflow = TextOverflow.Ellipsis,
modifier = Modifier.weight(1f),
)
}
Text(
text = formatDuration(elapsedMillis / 1_000) + if (long) " · long" else "",
style = MaterialTheme.typography.labelMedium,
color = tint,
)
}
}
@@ -352,6 +422,16 @@ private fun MessageItem(
SelectionContainer {
Column(Modifier.padding(CHAT_GUTTER)) {
if (isUser) {
// A user turn another device sent is attributed to it, so
// the transcript says who sent the message. Our own
// messages carry no label.
if (message.client.isNotBlank()) {
Text(
text = message.client,
style = MaterialTheme.typography.labelSmall,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
UserParts(message.parts)
} else {
AssistantParts(
@@ -47,7 +47,6 @@ import net.awan.pipelines.ui.theme.SPACING_S
internal fun attentionRunState(kind: AttentionKind): RunState = when (kind) {
AttentionKind.Decision -> RunState.Waiting
AttentionKind.Failed -> RunState.Failed
AttentionKind.Finished -> RunState.Succeeded
}
/**
@@ -22,6 +22,7 @@ import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.material3.rememberModalBottomSheetState
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
@@ -65,6 +66,8 @@ fun DecisionPrompt(
decision: PendingDecision?,
onSend: (decision: PendingDecision, option: String, feedback: String, onResult: (Result<RunDetail>) -> Unit) -> Unit,
modifier: Modifier = Modifier,
openRequest: Boolean = false,
onOpenRequestHandled: () -> Unit = {},
) {
val shown = rememberPaneContent(decision)
var open by remember { mutableStateOf(false) }
@@ -72,6 +75,16 @@ fun DecisionPrompt(
var sending by remember { mutableStateOf(false) }
var error by remember { mutableStateOf<String?>(null) }
// A notification's tap asks for the decision itself, not just the run:
// open the sheet once the waiting run's detail has loaded. The request is
// consumed here so a recomposition or a dismissal does not reopen it.
LaunchedEffect(decision?.runId, openRequest) {
if (openRequest && decision != null && !open) {
open = true
onOpenRequestHandled()
}
}
if (decision != null) {
DecisionCard(
decision = decision,
@@ -179,7 +179,7 @@ fun FilterCheckItem(
)
}
/** A small section caption inside a filter menu (Status/Pipeline/Time range). */
/** A small section caption inside a menu (a filter facet or a sort's reach). */
@Composable
fun FilterSectionHeader(label: String) {
Text(
@@ -10,6 +10,7 @@ import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.DirectionsRun
import androidx.compose.material.icons.automirrored.filled.HelpOutline
import androidx.compose.material.icons.filled.Block
import androidx.compose.material.icons.filled.Bolt
import androidx.compose.material.icons.filled.Cancel
import androidx.compose.material.icons.filled.CheckCircle
@@ -17,6 +18,7 @@ import androidx.compose.material.icons.filled.Error
import androidx.compose.material.icons.filled.FrontHand
import androidx.compose.material.icons.filled.PauseCircle
import androidx.compose.material.icons.filled.Schedule
import androidx.compose.material.icons.filled.SkipNext
import androidx.compose.material3.Icon
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
@@ -48,6 +50,8 @@ enum class RunState(val label: String) {
Failed("failed"),
Canceled("canceled"),
Interrupted("interrupted"),
Blocked("blocked"),
Skipped("skipped"),
Active("active"),
Unknown("unknown"),
}
@@ -67,6 +71,8 @@ fun runStateOf(status: String): RunState = when (status.trim().lowercase()) {
"failed", "error" -> RunState.Failed
"canceled", "cancelled" -> RunState.Canceled
"interrupted" -> RunState.Interrupted
"blocked" -> RunState.Blocked
"skipped" -> RunState.Skipped
else -> RunState.Unknown
}
@@ -86,6 +92,8 @@ fun runStateIcon(state: RunState): ImageVector = when (state) {
RunState.Failed -> Icons.Default.Error
RunState.Canceled -> Icons.Default.Cancel
RunState.Interrupted -> Icons.Default.PauseCircle
RunState.Blocked -> Icons.Default.Block
RunState.Skipped -> Icons.Default.SkipNext
RunState.Active -> Icons.Default.Bolt
RunState.Unknown -> Icons.AutoMirrored.Filled.HelpOutline
}
@@ -4,17 +4,20 @@ import androidx.compose.ui.graphics.Color
import net.awan.pipelines.ui.theme.DarkError
/**
* The app-owned run-status palette.
* The app-owned status palette, the single source of truth for the colour of a
* status or stage-outcome word.
*
* Run status is a *different vocabulary* from the graph's stage outcomes
* ([net.awan.pipelines.ui.graph.GraphPalette]): a run that is `running` is not a
* `skipped` stage, and a `succeeded` run is not the amber the theme uses for a
* positive *stage* outcome. Borrowing Material roles therefore put the wrong hue
* on the two states that matter most — `primary` (mint) made a *running* run read
* green and `tertiary` (amber) made a *succeeded* run read yellow.
* Borrowing Material roles put the wrong hue on the two states that matter most —
* `primary` (mint) made a *running* run read green and `tertiary` (amber) made a
* *succeeded* run read yellow — so every entry below is a deliberate, fixed
* colour with an explicit meaning. The stage outcomes that share a word with a
* run state (`success`/`done`→[Succeeded], `error`→[Failed], `blocked`,
* `skipped`, `waiting`) resolve here too, through [runStateOf], so the timeline,
* the graph, the runs list, the stage sheet and the peek all draw one word in one
* colour. Only genuinely graph-only flow outcomes (`approved`, `retry`, …) keep
* their own curated colour in [net.awan.pipelines.ui.graph.GraphPalette].
*
* Every entry below is instead a deliberate, fixed colour with an explicit
* meaning, tuned for the dark Pipelines surface (`DarkSurface 0xFF0E1513`,
* Every entry is tuned for the dark Pipelines surface (`DarkSurface 0xFF0E1513`,
* over which the chip label is drawn). The contrast of each colour against that
* surface is *measured* by `RunStatusPaletteTest`, never judged by eye. Status is
* never colour-only: every entry keeps its own material glyph ([runStateIcon])
@@ -29,6 +32,13 @@ internal object RunStatusPalette {
private val Running =
Entry(Color(0xFF7FB2F0), "blue: in progress; green would read as already finished")
/**
* Waiting for a person (a human decision): a distinct cyan, matching the TUI's
* accent for a paused run, so it is neither the running blue nor a failure.
*/
private val Waiting =
Entry(Color(0xFF8EDFF5), "cyan: paused for a person; distinct from running and from failure")
/** Finished well: the conventional green. Amber/tertiary would read as a warning. */
private val Succeeded =
Entry(Color(0xFF7FE0A8), "green: completed successfully; amber would read as a warning")
@@ -50,11 +60,18 @@ internal object RunStatusPalette {
Entry(Color(0xFF9AA6A2), "neutral grey: waiting, clearly not the in-progress blue")
/**
* Parked on a person: violet, distinct from the in-progress blue, the queued
* grey and the amber operator-stop, so a run needing a decision is unmistakable.
* Parked on a person (a human decision): distinct from the in-progress blue, the
* queued grey and the amber operator-stop, so a run needing a decision is
* unmistakable. Blocked and skipped are stage outcomes rather than run states:
* a stage that could not proceed is orange, and one deliberately not run is a
* quiet grey-blue - neither is a failure.
*/
private val Waiting =
Entry(Color(0xFFC0A3F5), "violet: parked for the operator's decision; not running, not a stop")
private val Blocked =
Entry(Color(0xFFF0A35E), "orange: a blocked stage could not proceed; not the failure red")
/** Skipped: a stage deliberately not run — a cool muted grey-blue, quiet and distinct. */
private val Skipped =
Entry(Color(0xFFA8B8C8), "muted grey-blue: a stage deliberately not run; quiet, not a status")
/** Unknown/blank status: the safe, low-key fallback. */
private val Unknown =
@@ -67,12 +84,14 @@ internal object RunStatusPalette {
*/
fun of(state: RunState): Entry = when (state) {
RunState.Running, RunState.Active -> Running
RunState.Waiting -> Waiting
RunState.Succeeded -> Succeeded
RunState.Failed -> Failed
RunState.Interrupted -> Interrupted
RunState.Canceled -> Canceled
RunState.Queued -> Queued
RunState.Waiting -> Waiting
RunState.Blocked -> Blocked
RunState.Skipped -> Skipped
RunState.Unknown -> Unknown
}
}
@@ -25,7 +25,9 @@ import androidx.compose.ui.Modifier
* icon and works at both window widths (it is not width-dependent geometry).
*
* [selected] draws a leading check on its row, so the active choice is conveyed
* by a glyph as well as by text, never by colour alone.
* by a glyph as well as by text, never by colour alone. An optional [header]
* captions the menu, e.g. to say that an order applies to the results in hand
* rather than server-side.
*/
@Composable
fun <T> SortMenu(
@@ -36,6 +38,7 @@ fun <T> SortMenu(
onSelect: (T) -> Unit,
onReset: () -> Unit,
modifier: Modifier = Modifier,
header: String? = null,
) {
var expanded by remember { mutableStateOf(false) }
Box(modifier) {
@@ -43,6 +46,7 @@ fun <T> SortMenu(
Icon(Icons.AutoMirrored.Filled.Sort, contentDescription = contentDescription)
}
DropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
header?.let { FilterSectionHeader(it) }
options.forEach { option ->
DropdownMenuItem(
text = { Text(label(option)) },
@@ -82,6 +82,26 @@ internal fun artifactIcon(kind: ArtifactKind): ImageVector = when (kind) {
ArtifactKind.Other -> Icons.AutoMirrored.Filled.InsertDriveFile
}
/**
* The word that names [kind] where a surface shows the type glyph but must also
* say the type in prose (a screen reader cannot read an icon). It is the same
* classification [artifactIcon] draws from, so the glyph and the word never
* disagree. Pure, so the mapping is unit-tested.
*/
internal fun artifactKindLabel(kind: ArtifactKind): String = when (kind) {
ArtifactKind.Image -> "Image"
ArtifactKind.Video -> "Video"
ArtifactKind.Audio -> "Audio"
ArtifactKind.Pdf -> "PDF"
ArtifactKind.Json -> "JSON"
ArtifactKind.Archive -> "Archive"
ArtifactKind.Spreadsheet -> "Spreadsheet"
ArtifactKind.Log -> "Log"
ArtifactKind.Code -> "Code"
ArtifactKind.Document -> "Document"
ArtifactKind.Other -> "File"
}
private val ARCHIVE_EXTENSIONS =
setOf("zip", "tar", "gz", "tgz", "bz2", "xz", "rar", "7z", "jar", "war")
@@ -8,9 +8,15 @@ import kotlin.math.min
import kotlin.math.pow
/**
* The curated graph colour palette.
* The curated palette for the graph-only flow outcomes.
*
* Every distinct outcome gets its own deliberate entry (no `hashCode() % 4`
* A stage outcome that is also a run state (`success`/`done`/`error`/`blocked`/
* `skipped`/`waiting`) is coloured from the one owned status palette
* ([net.awan.pipelines.ui.components.RunStatusPalette], through [outcomeColor]),
* so the graph, the timeline and the runs list never disagree. This palette
* covers only the words with no status meaning — the loop/choice outcomes a
* pipeline defines (`rejected`, `exhausted`, `retry`, `approved`, `fast`,
* `missing`) — giving each its own deliberate entry (no `hashCode() % 4`
* collisions): the mapping is pure and deterministic, so a given outcome name is
* the same colour across runs and recompositions, and an unknown/new name gets a
* stable reserved fallback colour instead of silently borrowing a known one.
@@ -19,46 +25,35 @@ import kotlin.math.pow
* over which the outcome label is drawn on a ~0.92-alpha chip). Every entry is
* bright enough to be legible both as a 3px edge stroke and as the small 11sp
* label text: contrast is *measured* by [GraphPaletteTest], not asserted by eye.
*
* The two terminal outcomes stay theme roles in [GraphColors] (`error`→error,
* `success`→tertiary) so their meaning is preserved; everything else uses
* [colors].
*/
internal object GraphPalette {
/**
* The fixed palette. Deliberately fixed (rather than scheme-derived) so an
* outcome is the same colour on every device; the two terminal roles above
* remain scheme roles.
* outcome is the same colour on every device.
*/
val colors: List<Color> = listOf(
Color(0xFF8FE0A0), // 0 blocked - green
Color(0xFFF5A3A3), // 1 rejected - red
Color(0xFF8FB4F5), // 2 skipped - blue
Color(0xFFF5B37A), // 3 exhausted - orange
Color(0xFF7FD4E8), // 4 retry - cyan
Color(0xFFC0A3F5), // 5 approved - violet
Color(0xFFF0E07A), // 6 fast - yellow
Color(0xFFF5A3D0), // 7 missing - pink
Color(0xFFD6B08C), // 8 done - sand
Color(0xFFF5A3A3), // 0 rejected - red
Color(0xFFF5B37A), // 1 exhausted - orange
Color(0xFF7FD4E8), // 2 retry - cyan
Color(0xFFC0A3F5), // 3 approved - violet
Color(0xFFF0E07A), // 4 fast - yellow
Color(0xFFF5A3D0), // 5 missing - pink
// Reserved fallback region for names not in [KNOWN], kept distinct from
// the known entries so an unknown outcome never borrows a known colour.
Color(0xFFD8C98A), // 9 fallback - khaki
Color(0xFF9FD8C0), // 10 fallback - sea
Color(0xFFD8A8C0), // 11 fallback - dusty rose
Color(0xFFD8C98A), // 6 fallback - khaki
Color(0xFF9FD8C0), // 7 fallback - sea
Color(0xFFD8A8C0), // 8 fallback - dusty rose
)
/** The known outcome names and their fixed palette index, in display order. */
/** The known graph-only outcome names and their fixed palette index, in display order. */
private val KNOWN: Map<String, Int> = linkedMapOf(
"blocked" to 0,
"rejected" to 1,
"skipped" to 2,
"exhausted" to 3,
"retry" to 4,
"approved" to 5,
"fast" to 6,
"missing" to 7,
"done" to 8,
"rejected" to 0,
"exhausted" to 1,
"retry" to 2,
"approved" to 3,
"fast" to 4,
"missing" to 5,
)
/** First palette index reserved for names that are not in [KNOWN]. */
@@ -67,8 +62,9 @@ internal object GraphPalette {
/**
* The palette index for [outcome]. Pure and deterministic for every input
* (including blank): known names get their curated slot, everything else a
* stable slot inside the reserved fallback region. `success`/`error` resolve
* to the theme roles in [outcomeColor] but still return a stable index here.
* stable slot inside the reserved fallback region. A word that resolves to a
* run state is coloured from the status palette by [outcomeColor] and does not
* reach this palette.
*/
fun outcomeColorIndex(outcome: String): Int {
KNOWN[outcome]?.let { return it }
@@ -85,8 +85,11 @@ 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
import net.awan.pipelines.ui.components.RunState
import net.awan.pipelines.ui.components.hostResumed
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.components.runStateColor
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.formatDuration
import net.awan.pipelines.ui.secondsSince
import net.awan.pipelines.ui.theme.GRAPH_ACTIVE_HALO_GAP
@@ -534,44 +537,51 @@ internal class GraphColors(
/**
* The graph's colours for [scheme], built in one place so every surface that must
* agree with the graph (the graph itself and the timeline's step-outcome chips)
* uses the same palette. The two terminal roles stay scheme roles so their
* meaning is kept; every other outcome uses the one curated, legible
* [GraphPalette] for both a stroke and its label text.
* uses the same palette. The two terminal roles take the one owned run-status
* colour (success green, failure red) so they can never disagree with the runs
* list; every other status word is coloured by the status palette in
* [outcomeColor], and the remaining graph-only flow outcomes use the one curated,
* legible [GraphPalette] for both a stroke and its label text.
*
* Node and label surfaces are *tonal*: a raised surface tone ([scheme]'s
* `surfaceContainerHigh`/`surfaceContainerHighest`) blended with a subtle tint of
* the node's semantic colour (see [tonalFill]) rather than a flat fill, so a node
* reads as raised card, not a terminal cell.
*/
internal fun graphColors(scheme: ColorScheme): GraphColors = GraphColors(
// The two terminal roles stay scheme roles so their meaning is kept.
success = scheme.tertiary,
error = scheme.error,
// Every other outcome uses the one curated, legible palette for both its
// stroke and its label text, so a curve and its label always agree.
palette = GraphPalette.colors,
// Node fills differ by kind (see [GraphNodeKind]): model (neutral), ntfy
// (amber), other/custom (green), and the two terminals (success/error). Each
// is a tonal surface carrying a subtle tint of that kind's semantic hue.
nodeFill = tonalFill(scheme.surfaceContainerHigh, scheme.onSurfaceVariant, NEUTRAL_TINT),
nodeNtfyFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, KIND_TINT),
nodeCustomFill = tonalFill(scheme.surfaceContainerHigh, scheme.primary, KIND_TINT),
// A selected node inverts (light fill / dark text) plus a stronger border, so
// selection reads in either appearance and never relies on colour.
nodeFillActive = scheme.inverseSurface,
nodeTextActive = scheme.inverseOnSurface,
// The stage border is deliberately soft (a low-contrast outline variant), not
// the hard original outline; terminals carry their outcome hue instead.
nodeBorder = scheme.outlineVariant,
nodeBorderActive = scheme.primary,
nodeText = scheme.onSurface,
terminalFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, TERMINAL_TINT),
terminalErrorFill = tonalFill(scheme.surfaceContainerHigh, scheme.error, TERMINAL_TINT),
// Edge outcome labels sit on a tonal chip (drawn as a rounded rect) rather than
// raw text over the canvas.
labelBackground = scheme.surfaceContainerHighest,
labelText = scheme.onSurfaceVariant,
)
internal fun graphColors(scheme: ColorScheme): GraphColors {
// The two terminal outcomes take the shared run-status colours so the graph
// and the runs list can never disagree about success/failure.
val success = runStateColor(RunState.Succeeded)
val error = runStateColor(RunState.Failed)
return GraphColors(
success = success,
error = error,
// Every other graph-only outcome uses the one curated, legible palette for
// both its stroke and its label text, so a curve and its label always agree.
palette = GraphPalette.colors,
// Node fills differ by kind (see [GraphNodeKind]): model (neutral), ntfy
// (amber), other/custom (green), and the two terminals (success/error). Each
// is a tonal surface carrying a subtle tint of that kind's semantic hue.
nodeFill = tonalFill(scheme.surfaceContainerHigh, scheme.onSurfaceVariant, NEUTRAL_TINT),
nodeNtfyFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, KIND_TINT),
nodeCustomFill = tonalFill(scheme.surfaceContainerHigh, scheme.primary, KIND_TINT),
// A selected node inverts (light fill / dark text) plus a stronger border, so
// selection reads in either appearance and never relies on colour.
nodeFillActive = scheme.inverseSurface,
nodeTextActive = scheme.inverseOnSurface,
// The stage border is deliberately soft (a low-contrast outline variant), not
// the hard original outline; terminals carry their outcome hue instead.
nodeBorder = scheme.outlineVariant,
nodeBorderActive = scheme.primary,
nodeText = scheme.onSurface,
terminalFill = tonalFill(scheme.surfaceContainerHigh, success, TERMINAL_TINT),
terminalErrorFill = tonalFill(scheme.surfaceContainerHigh, error, TERMINAL_TINT),
// Edge outcome labels sit on a tonal chip (drawn as a rounded rect) rather than
// raw text over the canvas.
labelBackground = scheme.surfaceContainerHighest,
labelText = scheme.onSurfaceVariant,
)
}
/**
* [surface] blended with a [fraction] (0..1) of [accent], so a node/label fill
@@ -1602,17 +1612,19 @@ private fun DrawScope.drawActiveHalo(
}
/**
* The colour for an outcome: the theme error role for `error`, a clearly
* positive theme colour for `success`, and the curated [GraphPalette] entry for
* everything else. One colour is used for both the edge stroke and its label
* text (the palette is legible on the surface), so a curve and its label always
* agree. `success`/`error` are the terminal roles and are never colour-only
* signals (their labels name them). Pure and deterministic.
* The colour for an outcome or stage status, from the one owned source: a word
* that is a run state (`success`/`done`/`error`/`blocked`/`skipped`/`waiting`/
* `running`/…) takes the shared status colour the operator already learned from
* the runs list, so the same word is the same colour in the timeline, the graph,
* the stage sheet and the peek; a graph-only flow outcome (`approved`, `retry`, …)
* takes its curated [GraphPalette] entry. One colour serves both the edge stroke
* and its label text (the palette is legible on the surface), so a curve and its
* label always agree. Pure and deterministic.
*/
internal fun outcomeColor(outcome: String, colors: GraphColors): Color = when (outcome) {
"error" -> colors.error
"success" -> colors.success
else -> colors.palette[GraphPalette.outcomeColorIndex(outcome)]
internal fun outcomeColor(outcome: String, colors: GraphColors): Color {
val state = runStateOf(outcome)
if (state != RunState.Unknown) return runStateColor(state)
return colors.palette[GraphPalette.outcomeColorIndex(outcome)]
}
/**
@@ -46,13 +46,15 @@ enum class RunPresence(val label: String, val storageKey: String) {
/**
* The statuses a run filter can select. The server's own run vocabulary
* (internal/pipeline/runs.go: queued/running/succeeded/failed/canceled/
* interrupted); the app-only `active` usage bucket and the `unknown` fallback
* are deliberately not offered, so a status filter always names a real state.
* (internal/pipeline/runs.go: queued/running/waiting/succeeded/failed/canceled/
* interrupted); the app-only `active` usage bucket, the stage-outcome words
* (`blocked`/`skipped`) and the `unknown` fallback are deliberately not offered,
* so a status filter always names a real run state.
*/
internal val RUN_STATUS_FILTERS: List<RunState> = listOf(
RunState.Queued,
RunState.Running,
RunState.Waiting,
RunState.Succeeded,
RunState.Failed,
RunState.Canceled,
@@ -67,6 +67,8 @@ fun RunDetailScreen(
modifier: Modifier = Modifier,
wide: Boolean = false,
covered: Boolean = false,
requestDecision: Boolean = false,
onDecisionRequestHandled: () -> Unit = {},
) {
val state by vm.runDetail.collectAsStateWithLifecycle()
val runsState by vm.runs.collectAsStateWithLifecycle()
@@ -83,6 +85,9 @@ fun RunDetailScreen(
val selectionState = rememberArtifactSelection(runId)
LaunchedEffect(runId) {
// Reaching a run clears its notification, whichever path opened it (the
// notification's own tap, the attention list, the runs list or a search).
vm.arrivedAtRun(runId)
// Scope evidence to this run: drop the previous run's records, then fetch
// this run's evidence once (on demand; live pushes carry no evidence).
vm.resetEvidence()
@@ -210,6 +215,8 @@ fun RunDetailScreen(
vm.decideRun(pending.runId, pending.stageKey, option, feedback, onResult)
},
modifier = Modifier.padding(horizontal = SPACING_L, vertical = SPACING_S),
openRequest = requestDecision,
onOpenRequestHandled = onDecisionRequestHandled,
)
StateCrossfade(
phase = detailLoadPhase(state.error, hasData = run != null),
@@ -585,8 +585,10 @@ private fun RunRow(
Text(
run.diagnostic,
style = text.meta,
// The one status colour for a failure, never a scheme role that
// could drift from the chip above it.
color = if (state == RunState.Failed) {
MaterialTheme.colorScheme.error
runStateColor(RunState.Failed)
} else {
MaterialTheme.colorScheme.onSurfaceVariant
},
@@ -0,0 +1,15 @@
<?xml version="1.0" encoding="utf-8"?>
<!--
The monochrome status-bar glyph for "a run needs you": three attention bars
with a raised exclamation-free silhouette, so the small icon reads at 24dp
instead of shrinking the full-colour launcher art.
-->
<vector xmlns:android="http://schemas.android.com/apk/res/android"
android:width="24dp"
android:height="24dp"
android:viewportWidth="24"
android:viewportHeight="24">
<path
android:fillColor="#FFFFFFFF"
android:pathData="M4,18h3v-6h-3z M10.5,18h3v-10h-3z M17,18h3v-14h-3z" />
</vector>