diff --git a/AGENTS.md b/AGENTS.md index 297b99d5..cc40fd17 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1,8 +1,21 @@ # Pipelines maintenance -When changing user-facing behavior or learning a confirmed runtime limitation, -update the relevant packaged OpenCode skill reference in -`internal/author/skill/references/` in the same change. Keep `SKILL.md` a concise, +## Consent (hard rule) + +The operator owns this system. No change to it happens without their explicit consent in the +current conversation: new pipelines or versions, definition and stage-prompt edits, +orchestration scripts, briefs and the conventions they carry, the packaged skill and templates, +deploys, installs and deletions. Read-only investigation and reporting need no consent. Ask +first and name exactly what would change; a request for a fix is not consent for a particular +mechanism. + +When a change alters user-facing behavior, or you learn a confirmed runtime +limitation, record the stale documentation instead of editing the shared document in +the same change: leave a per-item note at `docs/notes/.md` naming what changed and +which packaged OpenCode skill reference in `internal/author/skill/references/`, README +or topic doc is now stale and what should change there. The manual-only `docs-fold` +pipeline folds `docs/notes/` into the shared docs and references; an item never edits a +shared document itself. Keep `SKILL.md` a concise, task-directed index: preserve ask-first authoring and never preload every reference. Separate current capabilities, dated verification evidence, deployment state and unimplemented ideas. Do not turn mocked or structural checks into live claims. @@ -12,7 +25,9 @@ Run the author package tests: they check embedding, reference links, installatio upgrades and protection of user modifications. Never hand-edit an installed copy as the source of truth; refresh it with the current-source `pipelines skill install` only when installation is requested. Do not deploy runtime changes merely because -the skill is updated. Keep README/topic docs and the packaged reference consistent. +the skill is updated. Keep the shared docs and packaged references consistent through +the single `docs-fold` writer rather than editing them per item: leave a +`docs/notes/.md` note. ## Maintenance workflow diff --git a/android/README.md b/android/README.md index cfc094e9..39189cc4 100644 --- a/android/README.md +++ b/android/README.md @@ -253,7 +253,12 @@ stops it. Nothing is removed, and the visit tabs still switch the selected visit. - Steps render as a timeline in run detail: a leading status glyph connected to the next step by an outcome-coloured line (kept aligned with the step title), - the stage with its sequence and an outcome chip. A step's metadata is a set of + the stage with its sequence and an outcome chip. A step's colour comes from the + one status source, so a word that is a run state (`success`/`error`/`blocked`/ + `skipped`/`waiting`/…) is the same colour the runs list draws; only a graph-only + flow outcome (`approved`, `retry`, …) keeps its curated graph colour. A visit's + *outcome* is still distinguished from the run's *status* by the chip's own label + and the row's state glyph, never by a second colour. A step's metadata is a set of aligned label/value rows (`KeyValueRow`) — paired side by side in two columns on a wide window and stacked in one column on a narrow one — with a single consistent vertical rhythm (one bottom gap per step, no doubled gap when a step @@ -267,7 +272,8 @@ stops it. via `formatDuration`, and colour-coded succeeded/failed/canceled/interrupted/ active counts). Each card shows the pipeline name with a version chip, a colour-coded status chip with a distinct icon per state - (running/queued/succeeded/failed/canceled/interrupted/active/unknown), a meta + (running/waiting/queued/succeeded/failed/canceled/interrupted/active/unknown), + a meta row (run id, start time, duration) and the diagnostic only when non-blank, clamped to two lines. The raw `resultPreview` is no longer printed, and progress is shown honestly (completed visits + current stage, with an @@ -2703,6 +2709,10 @@ command targeted `emulator-5556`; lane A's `emulator-5554` was not used). call the shared `graphColors(scheme)` factory (extracted from `WorkflowGraph`, which uses it too) and `outcomeColor`, so a step chip agrees with the graph. The run header and runs-list cards keep the run-status palette. + *(Superseded 17 Oct 2026: the graph's terminal roles and the Timeline chip now + also take the one run-status colour, so "the graph outcome palette is unchanged" + no longer holds — see "One status colour everywhere" below. `RunStatusPalette` + stays the single status source.)* - **Shared helper.** `ui/components/RunStatus.kt` gained `ColoredChip(label, colour, icon, …)` — the single pill layout now used by both `StatusChip` (run status) and the Timeline's outcome chip, instead of a second copy. @@ -2785,6 +2795,50 @@ tree (JDK 17 from Homebrew `openjdk@17`, Gradle 8.11.1, `--offline`): `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, `Content-Length: 18009527`, and a streamed `GET | shasum -a 256` matched. +## One status colour everywhere (17 Oct 2026) + +A successful stage in the Timeline read amber, because a visit's chip was coloured +from the graph's outcome palette while every other surface used the run-status +palette, so the same word meant two colours. `android/` only; nothing in the +Pipelines server, its Go source, the Docker/compose files or the installer was +touched, no dependency was added beyond the already-declared +`material-icons-extended`, and no run was started from the app. + +- **One source of truth.** `ui/components/RunStatusPalette.kt`, with `RunState` / + `runStateOf` / `runStateColor` / `runStateIcon` in `ui/components/RunStatus.kt`, + owns a status colour. `RunState` gained the server's own `Waiting`/`Blocked`/ + `Skipped` words (`waiting` corroborated by `internal/tui/run_progress.go`), each + with a deliberate palette entry, a distinct material glyph + (`HourglassEmpty`/`Block`/`SkipNext`) and a label, so status is never colour + alone. +- **The graph and timeline route through it.** `graphColors(scheme)` sets + `success`/`error` from `runStateColor(Succeeded/Failed)`, and `outcomeColor` + returns the shared status colour for any word that resolves to a `RunState`, + falling back to `GraphPalette` only for the graph-only flow outcomes + (`rejected`, `exhausted`, `retry`, `approved`, `fast`, `missing`; `blocked`/ + `skipped`/`done` were removed from the graph palette). The Timeline's + `TimelineRow` uses the same factory, so a successful visit is green and a failure + red. A visit's *outcome* stays distinct from the run's *status* by the chip's own + label and the row's state glyph, never a second colour. The runs list's failure + diagnostic uses `runStateColor(Failed)` rather than a scheme role that could + drift from the chip above it, and the list's status filter gained `waiting`. +- **Tests.** `GraphPaletteTest` asserts every status word's graph colour equals the + runs-list colour and that the graph-only outcomes stay distinct and borrow no + status colour; `ui/graph/StatusColorConsistencyTest` asserts the timeline maps + through the same source and that every state maps to exactly one colour, the one + deliberate alias being Running/Active. + +Evidence obtained on this tree (macOS, JDK 17 from Homebrew `openjdk@17`, Gradle +8.11.1, `ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`, +`--no-daemon`): + +- `gradle :app:testDebugUnitTest --rerun-tasks` → **516 tests, 0 failures, 0 + errors, 0 skipped** (including the new `StatusColorConsistencyTest`, 2 cases, and + the extended `GraphPaletteTest`, 12 cases, and `RunStatusTest`, 3 cases). +- **APK publish.** The run's debug APK is + `…/artifacts/282/1/pipelines-debug-wip-d13f359.apk` (18,486,624 bytes, sha256 + `b11481889b2894efb5fb6b17bcb62af819fe4b6ffb0196f5e27834b4736a5e1c`). + ## Last-run facts on every pipeline row (16 Oct 2026) `android/` only. No server field was added: the whole run history already arrives @@ -4370,6 +4424,92 @@ and a selection navigating (the visual review owns the device, per the brief's device policy); the panel's pure logic is exercised by the unit tests and the compile only. +## Search type icons, a kind filter and sorting (17 Oct 2026) + +The omni-search results panel replaces each row's text type badge with a glyph and +gains the runs list's filter and sort controls. `android/` only; no new dependency +(the glyphs and the `FilterList`/`Sort` menu icons are from the already-declared +`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched, +no run started from the app, and the operator's phone was never used. + +- **Type glyph per result.** `OmniSearchResults.searchResultIcon` maps a hit to a + glyph: pipeline → the app's pipeline icon (`AccountTree`), run → `History`, + version → `Commit`, step → `Segment`, field → `Subject` (text lines, distinct + from the gallery's `Description` document glyph), and an unknown kind → + `HelpOutline`. An artifact reuses the gallery's own + classification (`artifactKind`/`artifactIcon` in `ui/graph/ArtifactType.kt`) + rather than a second mapping, so a search artifact and a gallery tile never + disagree. The glyph replaces the `LabelChip` badge (the chip is removed); the + payload decides the branch exactly as `searchRow` does. +- **Kind in words.** The glyph's `contentDescription` is `searchResultKindLabel` + ("Pipeline", "Run", "Pipeline version", "Step", "Field", or " + artifact", e.g. "PDF artifact" via the new `artifactKindLabel`), so a screen + reader hears the type the icon alone cannot carry. The row and the filter use + the same kind vocabulary ("Fields"). +- **Kind filter, narrowing server-side.** `SearchKindFilter` lists the filter + options - All kinds, Pipelines, Runs, Steps, Fields, Artifacts, Versions - and + each carries the server's own `SearchRequest.kind` value, sent verbatim + (`PipelinesRepository.search(query, kind)`). There is deliberately no "Prompts" + option: the server's search kinds are pipeline/version/run/step/field/artifact + only (`internal/protocol/search.go`), so a prompts filter could never match and + would visibly do nothing. +- **Sort, honest about its reach.** `SearchSort` offers Relevance (the server's + own score/recency/tie-break order, left untouched), Newest first (by `recency`) + and Name (by the displayed title). The server's search command takes no sort, so + Newest and Name order the results already in hand; the sort menu carries a + "Sort results in hand" caption, the collapsed summary appends " (in hand)" for + those two orders, and the icon's description reads "Sort results in hand". A + server-side sort would need a `sort` field on `SearchRequest`/the search + command. +- **Shared controls, remembered choice.** The panel header uses the same + `FilterMenu` and `SortMenu` the runs list uses (no new pattern), plus a one-line + `searchControlsSummary` ("All kinds · Relevance") so the collapsed controls show + the active choice. The header row carries a top inset so the filter's count badge + stays inside the panel's rounded surface. The kind and order persist as `search_filter_kind`/ + `search_sort` in `SettingsRepository`, so they survive a query change, the + results streaming in, and a restart. +- **Tests.** `OmniSearchResultsTest` now covers the glyph per kind and per + artifact content type (checked against the gallery's + `artifactIcon(artifactKind(...))`), the kind-in-words label, the kind filter + narrowing a mixed list, the Relevance/Newest/Name ordering including a recency + tie and a title tie, the in-hand summary suffix, the filter-aware empty-state + line (`searchPanelEmptyMessage`, which replaced the panel's now-orphaned + `isEmptyResult` and names the active kind filter), and the stored-value + fallbacks; `ArtifactTypeTest` covers `artifactKindLabel`. + +Evidence (macOS, JDK 17 from Homebrew `openjdk@17`, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1 from the wrapper +cache, every command `--no-daemon --offline --console=plain`; this build includes +the visual-review fixes: the header's badge inset, the visible in-hand sort +caption/summary, and the consistent "Field" vocabulary with a distinct glyph): + +- `gradle :app:testDebugUnitTest --rerun` → `BUILD SUCCESSFUL`; the 47 result XMLs + aggregate to **433 tests, 0 failures, 0 errors, 0 skipped** + (`OmniSearchResultsTest` 28, `ArtifactTypeTest` 7). +- `gradle :app:assembleDebug` → `BUILD SUCCESSFUL`; + `app/build/outputs/apk/debug/app-debug.apk` is **18,715,466 bytes**, sha256 + `f4cee0d4949ac587601f01a96733b3d865431bd5376ac6d7d182222a40999bf5`. +- **APK publish.** Copied to + `~/.local/share/pipelines/data/artifacts/231/4/pipelines-debug-wip-f31f150.apk` + (`f31f150` = `git rev-parse --short HEAD`). The LAN URL + `http://10.0.0.75:8080/artifacts/231/4/pipelines-debug-wip-f31f150.apk` returned + `HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, + `Content-Length: 18715466`, and the downloaded bytes' sha256 + `f4cee0d4949ac587601f01a96733b3d865431bd5376ac6d7d182222a40999bf5` matched the + local file. +- `gradle :app:lintDebug` fails on two pre-existing `NewApi` errors + (`res/values{,-night}/themes.xml`: `windowLightNavigationBar` requires API 27, + min is 26), unrelated to and not introduced by this change; the report names no + file touched by this change. +- No packaged template and no packaged authoring skill reference + (`internal/author/skill/references/*`, `internal/author/install.go`'s inventory) + documents the app's search panel - the only "omni search" reference describes + the TUI - so none needed updating. + +Not verified in this pass: device frames of the panel and the open controls (the +visual review owns the device, per the brief's device policy); the pure logic is +exercised by the unit tests and the compile only. + ## Chat destination and multiple conversations (16 Oct 2026) The first Chat slice: the destination, the server session list and several diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml index 57e587d9..454751cc 100644 --- a/android/app/src/main/AndroidManifest.xml +++ b/android/app/src/main/AndroidManifest.xml @@ -3,6 +3,14 @@ + + ` - // 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(null) + private var deepLinkedAction by mutableStateOf(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 } } diff --git a/android/app/src/main/java/net/awan/pipelines/PipelinesApplication.kt b/android/app/src/main/java/net/awan/pipelines/PipelinesApplication.kt index ffc183d2..8d36876e 100644 --- a/android/app/src/main/java/net/awan/pipelines/PipelinesApplication.kt +++ b/android/app/src/main/java/net/awan/pipelines/PipelinesApplication.kt @@ -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() + } } diff --git a/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt index a565f4d6..1479576f 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt @@ -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, val usage: UsageStats?) @@ -38,6 +50,13 @@ data class RunHistory(val runs: List, 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 = 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 = 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 = 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() { diff --git a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt index 5510581e..49164171 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/SettingsRepository.kt @@ -71,6 +71,20 @@ class SettingsRepository(context: Context) { private val _attention = MutableStateFlow(prefs.getString(KEY_ATTENTION, "").orEmpty()) val attention: StateFlow = _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 = _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 = _searchFilterKind.asStateFlow() + + private val _searchSort = MutableStateFlow(prefs.getString(KEY_SEARCH_SORT, "").orEmpty()) + val searchSort: StateFlow = _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" } } diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt index dcaa5b6a..04fbbd94 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt @@ -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 = 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 = 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 = emptyList()): Message = + fun promptRequest(sessionId: String, text: String, files: List = 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, ), ) } diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt index 8b738fcd..c6d3c088 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt @@ -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? = null, @SerialName("chat_event") val chatEvent: ChatEventFrame? = null, @SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null, diff --git a/android/app/src/main/java/net/awan/pipelines/notify/RunAlerts.kt b/android/app/src/main/java/net/awan/pipelines/notify/RunAlerts.kt new file mode 100644 index 00000000..4eb495d8 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/notify/RunAlerts.kt @@ -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) + + /** 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) = 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): List = 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, +) + +/** The grouped summary for [alerts], or null when at most one is pending. */ +fun alertSummary(alerts: List): 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, val cancel: List) { + 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() + + /** Keys the operator already reached, kept for dedupe but no longer visible. */ + private val hidden = LinkedHashSet() + + /** The alerts currently shown, by key. */ + val shown: Map get() = posted.toMap() + + /** The alerts still on screen: posted and not cleared by the operator arriving. */ + fun visible(): List = posted.values.filter { it.key !in hidden } + + /** The post/cancel delta that moves what is shown to exactly [desired]. */ + fun reconcile(desired: List): 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 { + 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/` 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() diff --git a/android/app/src/main/java/net/awan/pipelines/notify/RunNotifier.kt b/android/app/src/main/java/net/awan/pipelines/notify/RunNotifier.kt new file mode 100644 index 00000000..1c06f434 --- /dev/null +++ b/android/app/src/main/java/net/awan/pipelines/notify/RunNotifier.kt @@ -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) { + 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, 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" + } +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index e312f3de..cd508a0d 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -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( class AppViewModel( private val repository: PipelinesRepository, private val settings: SettingsRepository, + private val alertSink: RunAlertSink = NoRunAlerts, ) : ViewModel() { val connectionState: StateFlow = repository.connectionState @@ -79,6 +83,10 @@ class AppViewModel( val pipelineFilterRunStatuses: StateFlow = settings.pipelineFilterRunStatuses val pipelineFilterName: StateFlow = settings.pipelineFilterName + /** The stored omni-search kind narrowing (a server kind, "" = every kind) and order. */ + val searchKind: StateFlow = settings.searchFilterKind + val searchSort: StateFlow = settings.searchSort + private val _serverUrlDraft = MutableStateFlow(settings.serverUrl.value) val serverUrlDraft: StateFlow = _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 = _notificationsAllowed.asStateFlow() + + /** Whether the runtime notification permission has already been asked for (or refused). */ + val notificationPermissionAsked: StateFlow = 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) { - _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) } } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt b/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt index 05255645..4e2b1d6d 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/Attention.kt @@ -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, state: AttentionState): List = 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, 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 = emptySet(), - val finishedSeen: Set = 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): 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/` 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): 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): 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 diff --git a/android/app/src/main/java/net/awan/pipelines/ui/OmniSearchResults.kt b/android/app/src/main/java/net/awan/pipelines/ui/OmniSearchResults.kt index 2533772c..2bbc9553 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/OmniSearchResults.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/OmniSearchResults.kt @@ -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? = 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 { } } +// --------------------------------------------------------------------------- +// 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, filter: SearchKindFilter): List = + 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, sort: SearchSort): List = when (sort) { + SearchSort.Relevance -> results + SearchSort.Newest -> results.sortedWith( + compareByDescending { 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, + 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}\"." +} diff --git a/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt index 6c53ed37..da010126 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/PipelinesApp.kt @@ -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(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(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") } + }, + ) + } } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/RunsDestination.kt b/android/app/src/main/java/net/awan/pipelines/ui/RunsDestination.kt index b74a1e1f..0fa97a1b 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/RunsDestination.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/RunsDestination.kt @@ -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( diff --git a/android/app/src/main/java/net/awan/pipelines/ui/SearchResultsPanel.kt b/android/app/src/main/java/net/awan/pipelines/ui/SearchResultsPanel.kt index 4190d851..3e97dbef 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/SearchResultsPanel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/SearchResultsPanel.kt @@ -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), diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt index f67967f1..4c6e21b6 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt @@ -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, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt index 7d51f576..c01ee5a7 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt @@ -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, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt index e4a8e196..efa83de4 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt @@ -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): List = + 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, + messages: List, + now: Long, +): Map { + val stamps = LinkedHashMap() + 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): 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, ) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListPane.kt index 4b9ab629..a360c36f 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatListPane.kt @@ -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(" · ") diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt index e81d3a38..53dd4dfc 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt @@ -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 = 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 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) { 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) { diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt index ddb3f115..d9a653f9 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt @@ -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( diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt index d88b3add..8ca63a3e 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/AttentionSurface.kt @@ -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 } /** diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/DecisionPrompt.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/DecisionPrompt.kt index 89d8a647..a47c7a97 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/DecisionPrompt.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/DecisionPrompt.kt @@ -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) -> 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(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, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt index e3d60ca4..ddf2e7a5 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/FilterMenu.kt @@ -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( diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt index 4b3d54fd..85024c7b 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatus.kt @@ -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 } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt index 418d4760..f660c374 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/RunStatusPalette.kt @@ -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 } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt b/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt index 9f3b5436..47f3ff2d 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/components/SortMenu.kt @@ -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 SortMenu( @@ -36,6 +38,7 @@ fun 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 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)) }, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactType.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactType.kt index 15037562..76b89093 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactType.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/ArtifactType.kt @@ -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") diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt index b15bfca8..4afd4710 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt @@ -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 = 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 = 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 } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 3218791a..22525fee 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -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)] } /** diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt index 8b3d6ddc..b40cba04 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/ListFilter.kt @@ -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 = listOf( RunState.Queued, RunState.Running, + RunState.Waiting, RunState.Succeeded, RunState.Failed, RunState.Canceled, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index 6e4997f1..d817c800 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -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), diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt index ffd14a14..4303de82 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunHistoryScreen.kt @@ -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 }, diff --git a/android/app/src/main/res/drawable/ic_notification.xml b/android/app/src/main/res/drawable/ic_notification.xml new file mode 100644 index 00000000..838bbfe3 --- /dev/null +++ b/android/app/src/main/res/drawable/ic_notification.xml @@ -0,0 +1,15 @@ + + + + + diff --git a/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt b/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt index f6590287..626990f7 100644 --- a/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt @@ -45,6 +45,45 @@ class ChatProtocolTest { assertTrue(!sessions[1].busy) } + @Test + fun chatMultiClientFieldsRoundTrip() { + // The client label the prompt carries, the queued acknowledgement, the + // subscribe request and the shared-answer fields of a permission frame. + val prompt = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_prompt","chat_prompt":{"session_id":"ses_1","text":"hi","client":"Pixel 9 Pro XL"}}""", + ) + assertEquals("Pixel 9 Pro XL", prompt.chatPrompt!!.client) + + val ack = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_prompt","id":"a1","chat_queued":true}""", + ) + assertTrue(ack.chatQueued) + + val subscribe = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_subscribe","chat_subscribe":{"session_id":"ses_1"}}""", + ) + assertEquals(Protocol.CHAT_SUBSCRIBE, subscribe.type) + assertEquals("ses_1", subscribe.chatSubscribe!!.sessionId) + + val userFrame = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_event","chat_event":{"session_id":"ses_1","message_id":"usr_1","kind":"user","client":"Pixel 10 Pro Fold","part":{"type":"text","text":"from the fold"}}}""", + ) + assertEquals(ChatProtocol.EVENT_USER, userFrame.chatEvent!!.kind) + assertEquals("Pixel 10 Pro Fold", userFrame.chatEvent!!.client) + + val resolved = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_permission","chat_permission":{"session_id":"ses_1","request_id":"req_1","resolved":true,"decision":"once","resolved_by":"Pixel 9"}}""", + ) + assertTrue(resolved.chatPermission!!.resolved) + assertEquals("once", resolved.chatPermission!!.decision) + assertEquals("Pixel 9", resolved.chatPermission!!.resolvedBy) + } + @Test fun chatMessagesParseTextReasoningAndToolParts() { val json = """ diff --git a/android/app/src/test/java/net/awan/pipelines/notify/RunAlertsTest.kt b/android/app/src/test/java/net/awan/pipelines/notify/RunAlertsTest.kt new file mode 100644 index 00000000..a95cb3b1 --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/notify/RunAlertsTest.kt @@ -0,0 +1,249 @@ +package net.awan.pipelines.notify + +import net.awan.pipelines.data.protocol.RunSummary +import net.awan.pipelines.ui.AttentionEntry +import net.awan.pipelines.ui.AttentionKind +import net.awan.pipelines.ui.AttentionState +import net.awan.pipelines.ui.RUN_DEEP_LINK_ACTION_DECIDE +import net.awan.pipelines.ui.attentionEntries +import net.awan.pipelines.ui.runLinkFromDeepLink +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * The notification model's pure rules: the event-to-notification mapping + * (waiting and failed only), the permission paths (granted, refused, + * not-yet-asked), coalescing into one summary, the dedupe/clear ledger, and the + * tap destination. No Android types are involved, so every path is asserted + * without a device. + */ +class RunAlertsTest { + + private fun entry( + runId: Long, + kind: AttentionKind, + label: String = "Ship 1.4", + pipeline: String = "release", + detail: String = "", + ) = AttentionEntry( + runId = runId, + pipeline = pipeline, + label = label, + kind = kind, + detail = detail, + ) + + private fun run(id: Long, status: String, title: String? = null, diagnostic: String = "") = RunSummary( + id = id, + pipelineId = 4, + name = "release", + title = title, + status = status, + executing = status == "running", + diagnostic = diagnostic, + ) + + // --- event-to-notification mapping ---------------------------------------- + + @Test + fun onlyWaitingAndFailedRaiseANotification() { + assertEquals(RunAlertKind.Decision, alertKindOf(AttentionKind.Decision)) + assertEquals(RunAlertKind.Failed, alertKindOf(AttentionKind.Failed)) + } + + @Test + fun aSuccessfulRunningOrCancelledRunRaisesNothing() { + val runs = listOf( + run(1, "succeeded"), + run(2, "running"), + run(3, "canceled"), + run(4, "interrupted"), + run(5, "queued"), + ) + assertTrue(runAlerts(attentionEntries(runs, AttentionState())).isEmpty()) + } + + @Test + fun waitingAndFailedBecomeOneAlertEachAndFinishedDoesNot() { + val runs = listOf( + run(1, "waiting", title = "Ship 1.4"), + run(2, "failed", diagnostic = "provider returned 500"), + run(3, "succeeded", title = "Nightly"), + ) + val alerts = runAlerts(attentionEntries(runs, AttentionState())) + assertEquals(listOf(1L, 2L), alerts.map { it.runId }) + assertEquals(listOf(RunAlertKind.Decision, RunAlertKind.Failed), alerts.map { it.kind }) + assertEquals("A run needs your decision", alerts[0].title) + assertEquals("Ship 1.4 · release", alerts[0].text) + assertEquals("A run failed", alerts[1].title) + assertEquals("release", alerts[1].text) + } + + @Test + fun oneRunAndEventKindHasOneStableIdentity() { + assertEquals(alertKey(7, RunAlertKind.Decision), alertKey(7, RunAlertKind.Decision)) + assertTrue(alertKey(7, RunAlertKind.Decision) != alertKey(7, RunAlertKind.Failed)) + assertTrue(alertKey(7, RunAlertKind.Decision) != alertKey(8, RunAlertKind.Decision)) + // The notification id is stable per run+kind, so a repost updates in place. + assertEquals(alertNotificationId(7, RunAlertKind.Decision), alertNotificationId(7, RunAlertKind.Decision)) + assertTrue(alertNotificationId(7, RunAlertKind.Decision) != alertNotificationId(7, RunAlertKind.Failed)) + } + + // --- coalescing ------------------------------------------------------------- + + @Test + fun aSingleAlertHasNoSummaryButSeveralCoalesceIntoOne() { + val one = runAlerts(listOf(entry(1, AttentionKind.Decision))) + assertNull(alertSummary(one)) + + val several = runAlerts( + listOf( + entry(1, AttentionKind.Decision), + entry(2, AttentionKind.Failed), + entry(3, AttentionKind.Failed), + ), + ) + val summary = alertSummary(several) + assertNotNull(summary) + assertEquals(3, summary!!.count) + assertEquals("3 runs need you", summary.title) + assertEquals("1 waiting for you · 2 failed", summary.text) + assertEquals(3, summary.lines.size) + } + + // --- dedupe and clearing ---------------------------------------------------- + + @Test + fun theSameRunAndKindIsPostedOnlyOnce() { + val ledger = AlertLedger() + val alerts = runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed))) + + val first = ledger.reconcile(alerts) + assertEquals(listOf(1L, 2L), first.post.map { it.runId }) + assertTrue(first.cancel.isEmpty()) + + // A later reconciliation (the run stays waiting/failed) posts nothing. + val second = ledger.reconcile(alerts) + assertTrue(second.post.isEmpty()) + assertTrue(second.isEmpty) + assertEquals(2, ledger.shown.size) + } + + @Test + fun aResolvedRunIsCancelledAndOnlyTheNewOneIsPosted() { + val ledger = AlertLedger() + ledger.reconcile(runAlerts(listOf(entry(1, AttentionKind.Decision)))) + + val delta = ledger.reconcile(runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed)))) + assertEquals(listOf(2L), delta.post.map { it.runId }) + assertTrue(delta.cancel.isEmpty()) + + // Run 1 resolves/leaves the surface: its notification is cleared, run 2 stays. + val cleared = ledger.reconcile(runAlerts(listOf(entry(2, AttentionKind.Failed)))) + assertTrue(cleared.post.isEmpty()) + assertEquals(listOf(1L), cleared.cancel.map { it.runId }) + assertEquals(setOf(alertKey(2, RunAlertKind.Failed)), ledger.shown.keys) + } + + @Test + fun everythingIsClearedWhenNothingNeedsTheOperator() { + val ledger = AlertLedger() + ledger.reconcile(runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed)))) + + val cleared = ledger.reconcile(emptyList()) + assertEquals(setOf(1L, 2L), cleared.cancel.map { it.runId }.toSet()) + assertTrue(ledger.shown.isEmpty()) + } + + @Test + fun arrivingAtAStillWaitingRunClearsItWithoutReNotifying() { + val ledger = AlertLedger() + val alerts = runAlerts(listOf(entry(1, AttentionKind.Decision), entry(2, AttentionKind.Failed))) + ledger.reconcile(alerts) + assertEquals(2, ledger.visible().size) + + // The operator opens run 1; its notification is cleared and the grouped + // summary stops counting it. + assertEquals(listOf(1L), ledger.arrived(1).map { it.runId }) + assertEquals(listOf(2L), ledger.visible().map { it.runId }) + // The run is still waiting, so the next reconciliation must not re-post it. + val again = ledger.reconcile(alerts) + assertTrue(again.post.isEmpty()) + // Run 2 is untouched and still tracked. + assertTrue(ledger.shown.containsKey(alertKey(2, RunAlertKind.Failed))) + } + + @Test + fun aRunThatFailsAgainAfterResolvingNotifiesAgain() { + val ledger = AlertLedger() + val failed = runAlerts(listOf(entry(1, AttentionKind.Failed))) + assertEquals(1, ledger.reconcile(failed).post.size) + // Resolved (left the surface): the key is forgotten. + assertTrue(ledger.reconcile(emptyList()).cancel.isNotEmpty()) + // A new failure for the same run is a new event and notifies once more. + assertEquals(1, ledger.reconcile(failed).post.size) + } + + // --- permission paths ------------------------------------------------------- + + @Test + fun aGrantedPermissionIsNeverAsked() { + val prompt = alertPermissionPrompt(granted = true, asked = false, trigger = true) + assertFalse(prompt.request) + assertNull(prompt.rationale) + } + + @Test + fun theFirstTimeSomethingNeedsTheOperatorAsksWithARationale() { + val prompt = alertPermissionPrompt(granted = false, asked = false, trigger = true) + assertTrue(prompt.request) + assertEquals(NOTIFICATION_RATIONALE, prompt.rationale) + } + + @Test + fun nothingIsAskedBeforeSomethingNeedsTheOperator() { + val prompt = alertPermissionPrompt(granted = false, asked = false, trigger = false) + assertFalse(prompt.request) + assertNull(prompt.rationale) + } + + @Test + fun aRefusalIsRememberedAndNeverAskedAgain() { + // "asked" covers both a refusal and a dismissal of the rationale. + val prompt = alertPermissionPrompt(granted = false, asked = true, trigger = true) + assertFalse(prompt.request) + assertNull(prompt.rationale) + } + + // --- tap destination -------------------------------------------------------- + + @Test + fun aWaitingRunOpensTheDecisionSheetAndAFailedRunOpensTheRun() { + assertEquals(AlertTapTarget.DecisionSheet, alertTapTarget(RunAlertKind.Decision)) + assertEquals(AlertTapTarget.Run, alertTapTarget(RunAlertKind.Failed)) + + assertEquals("pipelines://run/42", alertDeepLink(42, RunAlertKind.Failed)) + assertEquals( + "pipelines://run/42?action=$RUN_DEEP_LINK_ACTION_DECIDE", + alertDeepLink(42, RunAlertKind.Decision), + ) + } + + @Test + fun theRunDeepLinkCarriesItsOptionalAction() { + val decision = runLinkFromDeepLink("pipelines://run/42?action=$RUN_DEEP_LINK_ACTION_DECIDE") + assertEquals(42L, decision?.runId) + assertEquals(RUN_DEEP_LINK_ACTION_DECIDE, decision?.action) + + val plain = runLinkFromDeepLink("pipelines://run/42") + assertEquals(42L, plain?.runId) + assertNull(plain?.action) + + assertNull(runLinkFromDeepLink("pipelines://run/abc?action=$RUN_DEEP_LINK_ACTION_DECIDE")) + assertNull(runLinkFromDeepLink("pipelines://run/0")) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt index 2b491377..50ed94f0 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/AttentionTest.kt @@ -8,10 +8,11 @@ import org.junit.Assert.assertTrue import org.junit.Test /** - * The attention surface's pure model: the event-to-entry mapping (waiting, - * failed and nothing else), the ranking of the three kinds, an entry appearing - * from a pushed run event and clearing when it is resolved, deliberate - * dismissal, the empty case, persistence, and the notification's deep link. + * The attention surface's pure model: the event-to-entry mapping (a waiting run + * and a failed run, and nothing else — a successful run is never announced), the + * ranking of the two kinds, an entry appearing from a pushed run event and + * clearing when it is resolved, deliberate dismissal, the empty case, persistence, + * and the notification's deep link. */ class AttentionTest { @@ -45,10 +46,10 @@ class AttentionTest { // --- mapping --------------------------------------------------------------- @Test - fun onlyWaitingFailedAndFinishedAskForAttention() { + fun onlyAWaitingOrFailedRunAsksForAttention() { assertEquals(AttentionKind.Decision, attentionKindOf("waiting")) assertEquals(AttentionKind.Failed, attentionKindOf("failed")) - assertEquals(AttentionKind.Finished, attentionKindOf("succeeded")) + assertNull(attentionKindOf("succeeded")) assertNull(attentionKindOf("queued")) assertNull(attentionKindOf("running")) assertNull(attentionKindOf("canceled")) @@ -68,7 +69,7 @@ class AttentionTest { ), AttentionState(), ) - assertEquals(3, entries.size) + assertEquals(2, entries.size) val decision = entries[0] assertEquals(AttentionKind.Decision, decision.kind) assertEquals("Ship 1.4", decision.label) @@ -77,25 +78,21 @@ class AttentionTest { val failed = entries[1] assertEquals(AttentionKind.Failed, failed.kind) assertEquals("provider returned 500", failed.detail) - val finished = entries[2] - assertEquals(AttentionKind.Finished, finished.kind) - assertEquals("nightly", finished.label) } // --- ordering -------------------------------------------------------------- @Test - fun decisionRanksBeforeFailedBeforeFinished() { + fun decisionRanksBeforeFailed() { val entries = attentionEntries( listOf( - run(3, "succeeded", finishedAt = "2026-10-17T09:09:00Z"), run(2, "failed", finishedAt = "2026-10-17T09:08:00Z"), run(1, "waiting"), ), AttentionState(), ) - assertEquals(listOf(AttentionKind.Decision, AttentionKind.Failed, AttentionKind.Finished), entries.map { it.kind }) - assertEquals(listOf(1L, 2L, 3L), entries.map { it.runId }) + assertEquals(listOf(AttentionKind.Decision, AttentionKind.Failed), entries.map { it.kind }) + assertEquals(listOf(1L, 2L), entries.map { it.runId }) } @Test @@ -142,7 +139,7 @@ class AttentionTest { assertTrue(attentionEntries(retried, AttentionState()).isEmpty()) } - // --- dismissal and look ---------------------------------------------------- + // --- dismissal ------------------------------------------------------------- @Test fun aDeliberateDismissalRemovesAnEntryForGood() { @@ -155,11 +152,16 @@ class AttentionTest { } @Test - fun aFinishedRunClearsOnceTheOperatorHasLooked() { - val runs = listOf(run(1, "succeeded")) - assertEquals(1, attentionEntries(runs, AttentionState()).size) - val looked = AttentionState().lookedAtFinished(setOf(1L)) - assertTrue(attentionEntries(runs, looked).isEmpty()) + fun aSuccessfulRunIsNeverListed() { + assertTrue(attentionEntries(listOf(run(1, "succeeded")), AttentionState()).isEmpty()) + // Even a finished run that was never looked at does not appear: a + // successful run raises nothing on any surface. + assertTrue( + attentionEntries( + listOf(run(2, "succeeded"), run(3, "running"), run(4, "canceled")), + AttentionState(), + ).isEmpty(), + ) } // --- empty case ------------------------------------------------------------ @@ -169,7 +171,13 @@ class AttentionTest { assertTrue(attentionEntries(emptyList(), AttentionState()).isEmpty()) assertTrue( attentionEntries( - listOf(run(1, "running"), run(2, "queued"), run(3, "canceled"), run(4, "interrupted")), + listOf( + run(1, "running"), + run(2, "queued"), + run(3, "canceled"), + run(4, "interrupted"), + run(5, "succeeded"), + ), AttentionState(), ).isEmpty(), ) @@ -182,18 +190,21 @@ class AttentionTest { assertEquals("A run is waiting for you", attentionHeadline(decision)) val failed = attentionEntries(listOf(run(2, "failed"), run(3, "failed")), AttentionState()) assertEquals("2 runs need you", attentionHeadline(failed)) + val singleFailed = attentionEntries(listOf(run(4, "failed")), AttentionState()) + assertEquals("A run failed", attentionHeadline(singleFailed)) } // --- persistence ----------------------------------------------------------- @Test fun attentionStateSurvivesAnEncodeDecodeRoundTrip() { - val state = AttentionState() - .dismissed(attentionKey(7, AttentionKind.Failed)) - .lookedAtFinished(setOf(9L, 11L)) + val state = AttentionState().dismissed(attentionKey(7, AttentionKind.Failed)) assertEquals(state, AttentionState.decode(state.encode())) assertEquals(AttentionState(), AttentionState.decode("")) assertEquals(AttentionState(), AttentionState.decode("not json")) + // A state stored by an older build that also recorded looked-at finished + // runs still decodes, keeping the dismissals. + assertEquals(AttentionState(), AttentionState.decode("""{"finishedSeen":[9,11]}""")) } // --- notification deep link ------------------------------------------------ diff --git a/android/app/src/test/java/net/awan/pipelines/ui/OmniSearchResultsTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/OmniSearchResultsTest.kt index ddb081c6..2bd8b23d 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/OmniSearchResultsTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/OmniSearchResultsTest.kt @@ -1,5 +1,19 @@ 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.InsertDriveFile +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.Code +import androidx.compose.material.icons.filled.Commit +import androidx.compose.material.icons.filled.DataObject +import androidx.compose.material.icons.filled.Description +import androidx.compose.material.icons.filled.History +import androidx.compose.material.icons.filled.Image +import androidx.compose.material.icons.filled.PictureAsPdf +import androidx.compose.ui.graphics.vector.ImageVector import net.awan.pipelines.data.protocol.Protocol import net.awan.pipelines.data.protocol.RunStep import net.awan.pipelines.data.protocol.SearchArtifact @@ -10,6 +24,8 @@ 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 org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertNotNull @@ -19,26 +35,77 @@ import org.junit.Test class OmniSearchResultsTest { - // ---- Badges and rows --------------------------------------------------- + // ---- Type glyphs and rows ---------------------------------------------- @Test - fun everyKindMapsToItsBadge() { - assertEquals("pipeline", searchBadge(Protocol.SEARCH_KIND_PIPELINE)) - assertEquals("pipeline", searchBadge(Protocol.SEARCH_KIND_VERSION)) - assertEquals("run", searchBadge(Protocol.SEARCH_KIND_RUN)) - assertEquals("step", searchBadge(Protocol.SEARCH_KIND_STEP)) - assertEquals("artifact", searchBadge(Protocol.SEARCH_KIND_ARTIFACT)) - assertEquals("match", searchBadge(Protocol.SEARCH_KIND_FIELD)) - // A kind the client does not know still gets a badge and is shown. - assertEquals("match", searchBadge("future_kind")) - assertEquals("match", searchBadge("")) + fun everyKindMapsToItsOwnGlyph() { + assertEquals(Icons.Filled.AccountTree, searchResultIcon(hit(Protocol.SEARCH_KIND_PIPELINE))) + assertEquals(Icons.Filled.Commit, searchResultIcon(hit(Protocol.SEARCH_KIND_VERSION))) + assertEquals(Icons.Filled.History, searchResultIcon(hit(Protocol.SEARCH_KIND_RUN))) + assertEquals(Icons.AutoMirrored.Filled.Segment, searchResultIcon(hit(Protocol.SEARCH_KIND_STEP))) + assertEquals(Icons.AutoMirrored.Filled.Subject, searchResultIcon(hit(Protocol.SEARCH_KIND_FIELD))) + // An artifact shows its content type's glyph; an unknown kind gets a neutral + // mark rather than none, and no two kinds share a glyph. + assertEquals(Icons.Filled.Description, searchResultIcon(hit(Protocol.SEARCH_KIND_ARTIFACT))) + assertEquals(Icons.AutoMirrored.Filled.HelpOutline, searchResultIcon(hit("future_kind"))) + val glyphs = listOf( + Protocol.SEARCH_KIND_PIPELINE, + Protocol.SEARCH_KIND_VERSION, + Protocol.SEARCH_KIND_RUN, + Protocol.SEARCH_KIND_STEP, + Protocol.SEARCH_KIND_FIELD, + Protocol.SEARCH_KIND_ARTIFACT, + "future_kind", + ).map { searchResultIcon(hit(it)) } + assertEquals(glyphs.size, glyphs.toSet().size) } @Test - fun eachRowCarriesABadgeTitleAndSecondaryLine() { + fun anArtifactGlyphIsTheGallerysContentTypeMapping() { + // Every artifact reuses artifactIcon(artifactKind(...)) rather than a second + // mapping, so the search surface and the gallery can never disagree. + val cases = listOf( + "image/png" to "shot.png", + "application/pdf" to "report.pdf", + "application/json" to "run.json", + "text/markdown" to "notes.md", + "application/xml" to "graph.xml", + "text/plain" to "readme.txt", + "application/octet-stream" to "blob", + ) + cases.forEach { (contentType, name) -> + assertEquals( + "artifact $contentType", + artifactIcon(artifactKind(contentType, name)), + artifactGlyph(contentType, name), + ) + } + // Spot-check the concrete glyphs the brief names. + assertEquals(Icons.Filled.Image, artifactGlyph("image/png", "shot.png")) + assertEquals(Icons.Filled.PictureAsPdf, artifactGlyph("application/pdf", "report.pdf")) + assertEquals(Icons.Filled.DataObject, artifactGlyph("application/json", "run.json")) + assertEquals(Icons.Filled.Code, artifactGlyph("application/xml", "graph.xml")) + assertEquals(Icons.Filled.Description, artifactGlyph("text/plain", "readme.txt")) + assertEquals(Icons.AutoMirrored.Filled.InsertDriveFile, artifactGlyph("application/octet-stream", "blob")) + } + + @Test + fun everyKindCarriesItsKindInWords() { + assertEquals("Pipeline", searchResultKindLabel(hit(Protocol.SEARCH_KIND_PIPELINE))) + assertEquals("Pipeline version", searchResultKindLabel(hit(Protocol.SEARCH_KIND_VERSION))) + assertEquals("Run", searchResultKindLabel(hit(Protocol.SEARCH_KIND_RUN))) + assertEquals("Step", searchResultKindLabel(hit(Protocol.SEARCH_KIND_STEP))) + assertEquals("Field", searchResultKindLabel(hit(Protocol.SEARCH_KIND_FIELD))) + // The default artifact fixture is a markdown file; an image names itself. + assertEquals("Document artifact", searchResultKindLabel(hit(Protocol.SEARCH_KIND_ARTIFACT))) + assertEquals("Image artifact", searchResultKindLabel(artifactHit("image/png", "shot.png"))) + assertEquals("Unrecognised result", searchResultKindLabel(hit("future_kind"))) + } + + @Test + fun eachRowCarriesATitleAndSecondaryLine() { results().forEach { hit -> val row = searchRow(hit, "release") - assertTrue("badge for ${hit.kind}", row.badge.isNotBlank()) assertTrue("title for ${hit.kind}", row.title.isNotBlank()) assertTrue("secondary for ${hit.kind}", row.secondary.isNotBlank()) } @@ -62,6 +129,91 @@ class OmniSearchResultsTest { assertNull("an unknown kind is not navigable", searchTarget(unknown)) } + // ---- Kind filter ------------------------------------------------------- + + @Test + fun everyFilterCarriesTheServerKindAndResolvesFromStorage() { + assertEquals("", SearchKindFilter.All.serverKind) + assertEquals(Protocol.SEARCH_KIND_PIPELINE, SearchKindFilter.Pipelines.serverKind) + assertEquals(Protocol.SEARCH_KIND_VERSION, SearchKindFilter.Versions.serverKind) + assertEquals(SearchKindFilter.All, SearchKindFilter.fromStorage("")) + assertEquals(SearchKindFilter.Runs, SearchKindFilter.fromStorage("run")) + // A stale/unknown stored value falls back to every kind; "prompts" is not a + // server kind, so it is deliberately not an option. + assertEquals(SearchKindFilter.All, SearchKindFilter.fromStorage("prompts")) + } + + @Test + fun theKindFilterNarrowsTheListToThatKind() { + val mixed = listOf( + hit(Protocol.SEARCH_KIND_PIPELINE), + hit(Protocol.SEARCH_KIND_RUN), + hit(Protocol.SEARCH_KIND_STEP), + hit(Protocol.SEARCH_KIND_FIELD), + hit(Protocol.SEARCH_KIND_ARTIFACT), + hit(Protocol.SEARCH_KIND_VERSION), + ) + assertEquals(mixed, filterSearchResults(mixed, SearchKindFilter.All)) + assertEquals(listOf(hit(Protocol.SEARCH_KIND_RUN)), filterSearchResults(mixed, SearchKindFilter.Runs)) + assertEquals(listOf(hit(Protocol.SEARCH_KIND_ARTIFACT)), filterSearchResults(mixed, SearchKindFilter.Artifacts)) + assertEquals( + listOf(hit(Protocol.SEARCH_KIND_VERSION)), + filterSearchResults(mixed, SearchKindFilter.Versions), + ) + } + + // ---- Sort ordering ----------------------------------------------------- + + @Test + fun relevanceKeepsTheServersRanking() { + val ordered = listOf( + hitWithRecency(Protocol.SEARCH_KIND_RUN, "2026-01-01T00:00:00Z"), + hitWithRecency(Protocol.SEARCH_KIND_PIPELINE, "2026-03-01T00:00:00Z"), + ) + assertEquals(ordered, sortSearchResults(ordered, SearchSort.Relevance)) + } + + @Test + fun newestFirstOrdersByRecencyDescending() { + val older = hitWithRecency(Protocol.SEARCH_KIND_RUN, "2026-01-01T00:00:00Z") + val newer = hitWithRecency(Protocol.SEARCH_KIND_PIPELINE, "2026-03-01T00:00:00Z") + assertEquals(listOf(newer, older), sortSearchResults(listOf(older, newer), SearchSort.Newest)) + } + + @Test + fun aRecencyTieKeepsTheServersOrder() { + val first = hitWithRecency(Protocol.SEARCH_KIND_RUN, "2026-01-01T00:00:00Z") + val second = hitWithRecency(Protocol.SEARCH_KIND_PIPELINE, "2026-01-01T00:00:00Z") + assertEquals(listOf(first, second), sortSearchResults(listOf(first, second), SearchSort.Newest)) + } + + @Test + fun aMissingRecencySortsLast() { + val dated = hitWithRecency(Protocol.SEARCH_KIND_RUN, "2026-01-01T00:00:00Z") + val undated = SearchResult(kind = Protocol.SEARCH_KIND_RUN, recency = null) + assertEquals(listOf(dated, undated), sortSearchResults(listOf(undated, dated), SearchSort.Newest)) + } + + @Test + fun nameOrdersByTheDisplayedTitleAndATieKeepsItsOrder() { + val alpha1 = SearchResult(kind = Protocol.SEARCH_KIND_PIPELINE, pipeline = SearchPipeline(id = 1, name = "alpha")) + val beta = SearchResult(kind = Protocol.SEARCH_KIND_PIPELINE, pipeline = SearchPipeline(id = 2, name = "beta")) + val alpha2 = SearchResult(kind = Protocol.SEARCH_KIND_PIPELINE, pipeline = SearchPipeline(id = 3, name = "alpha")) + // The two "alpha" rows tie and keep their input order; "beta" moves last. + assertEquals(listOf(alpha1, alpha2, beta), sortSearchResults(listOf(beta, alpha1, alpha2), SearchSort.Name)) + } + + @Test + fun theStoredSortAndTheControlSummaryResolve() { + assertEquals(SearchSort.Relevance, SearchSort.fromStorage("")) + assertEquals(SearchSort.Name, SearchSort.fromStorage("name")) + assertEquals(SearchSort.Relevance, SearchSort.fromStorage("bogus")) + assertEquals("All kinds · Relevance", searchControlsSummary(SearchKindFilter.All, SearchSort.Relevance)) + // An order that runs on the fetched results says so in the collapsed summary. + assertEquals("Runs · Newest first (in hand)", searchControlsSummary(SearchKindFilter.Runs, SearchSort.Newest)) + assertEquals("Fields · Name (in hand)", searchControlsSummary(SearchKindFilter.Fields, SearchSort.Name)) + } + // ---- Snippet highlighting --------------------------------------------- @Test @@ -220,13 +372,25 @@ class OmniSearchResultsTest { } @Test - fun theEmptyStateNamesTheQueryAndOnlyAppearsWhenLoaded() { + fun theEmptyStateNamesTheQueryAndTheActiveFilter() { val empty = SearchUiState(query = "release").loaded(SearchResponse(results = emptyList())) - assertTrue(empty.isEmptyResult()) - // Still loading: not the empty state. - assertFalse(empty.editing("release2").isEmptyResult()) - // A failure is an error, not an empty result. - assertFalse(SearchUiState(query = "release").failed("boom").isEmptyResult()) + assertEquals( + "No matches for \"release\".", + searchPanelEmptyMessage(empty, emptyList(), SearchKindFilter.All), + ) + // A filter that empties the list names itself rather than the generic line. + val pipelineOnly = empty.copy(results = listOf(hit(Protocol.SEARCH_KIND_PIPELINE))) + assertEquals( + "No runs match \"release\".", + searchPanelEmptyMessage(pipelineOnly, emptyList(), SearchKindFilter.Runs), + ) + // Rows shown: no message. Still loading, blank query or an error: no message + // (the panel shows progress, nothing, or the error respectively). + val shown = listOf(hit(Protocol.SEARCH_KIND_RUN)) + assertNull(searchPanelEmptyMessage(empty.copy(results = shown), shown, SearchKindFilter.All)) + assertNull(searchPanelEmptyMessage(empty.editing("release2"), emptyList(), SearchKindFilter.All)) + assertNull(searchPanelEmptyMessage(SearchUiState(query = ""), emptyList(), SearchKindFilter.All)) + assertNull(searchPanelEmptyMessage(empty.failed("boom"), emptyList(), SearchKindFilter.All)) } // ---- Fixtures ---------------------------------------------------------- @@ -265,6 +429,17 @@ class OmniSearchResultsTest { else -> SearchResult(kind = kind, target = "") } + private fun hitWithRecency(kind: String, recency: String?): SearchResult = + hit(kind).copy(recency = recency) + + private fun artifactHit(contentType: String, name: String): SearchResult = SearchResult( + kind = Protocol.SEARCH_KIND_ARTIFACT, + artifact = SearchArtifact(name = name, contentType = contentType), + ) + + private fun artifactGlyph(contentType: String, name: String): ImageVector = + searchResultIcon(artifactHit(contentType, name)) + private fun results(): List = listOf( Protocol.SEARCH_KIND_PIPELINE, Protocol.SEARCH_KIND_VERSION, diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt index 7991e473..74b7bd13 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt @@ -65,12 +65,11 @@ class ChatFormatTest { } @Test - fun sessionStatusReportsRunningBusyAndIdle() { + fun sessionStatusIsRunningOrIdleNeverReadOnly() { assertEquals("Running", sessionStatusLabel(ChatSession(id = "s"), runningLocally = true)) - assertEquals( - "Busy · read-only", - sessionStatusLabel(ChatSession(id = "s", busy = true), runningLocally = false), - ) + // The server no longer marks a session Busy for another client, and a + // session is never read-only: the stale flag cannot produce that label. + assertEquals("Idle", sessionStatusLabel(ChatSession(id = "s", busy = true), runningLocally = false)) assertEquals("Idle", sessionStatusLabel(ChatSession(id = "s"), runningLocally = false)) } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatRunningWorkTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatRunningWorkTest.kt new file mode 100644 index 00000000..3e82282d --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatRunningWorkTest.kt @@ -0,0 +1,235 @@ +package net.awan.pipelines.ui.chat + +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import net.awan.pipelines.data.protocol.ChatEventFrame +import net.awan.pipelines.data.protocol.ChatMessage +import net.awan.pipelines.data.protocol.ChatPart +import net.awan.pipelines.data.protocol.ChatProtocol +import net.awan.pipelines.data.protocol.ChatSession +import net.awan.pipelines.data.protocol.ChatTime +import net.awan.pipelines.data.protocol.ChatToolState +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +/** + * The in-flight work a conversation and its session row show: a running tool with + * its name, the command or description the part carries, and a live elapsed time + * that grows from when the call turned running, uses the protocol's own timing + * when the part has it, and clears the moment the call completes or errors. All + * pure or driven against [ChatStore] with an injected clock, so no device, server + * or Compose runtime is needed. + */ +class ChatRunningWorkTest { + + private fun tool( + id: String, + name: String, + status: String, + input: JsonObject? = null, + time: ChatTime? = null, + ) = ChatPart( + type = ChatProtocol.PART_TOOL, + id = id, + name = name, + state = ChatToolState(status = status, input = input), + time = time, + ) + + private fun toolFrame(sessionId: String, messageId: String, part: ChatPart) = + ChatEventFrame(sessionId = sessionId, messageId = messageId, kind = ChatProtocol.PART_TOOL, part = part) + + private fun input(vararg pairs: Pair): JsonObject = + JsonObject(pairs.associate { (key, value) -> key to JsonPrimitive(value) }) + + private fun threadWith(vararg parts: ChatPart) = ChatThread( + sessionId = "s", + running = true, + messages = listOf( + ChatMessage( + id = "m1", + sessionId = "s", + role = ChatProtocol.ROLE_ASSISTANT, + parts = parts.toList(), + ), + ), + ) + + @Test + fun aRunningToolShowsItsNameDetailAndGrowingTime() { + var clock = 1_000L + val store = ChatStore(now = { clock }) + store.open(ChatSession(id = "s", title = "s")) + store.history("s", emptyList()) + + store.event( + toolFrame("s", "m1", tool("c1", "shell", ChatProtocol.TOOL_RUNNING, input("command" to "ls -la"))), + ) + + val thread = store.value.thread("s")!! + assertTrue(thread.running) + val call = thread.runningTools.single() + assertEquals("shell", call.name) + assertEquals("ls -la", toolDetail(call)) + // Elapsed is measured locally from when the call turned running, so it + // starts at zero and grows with the clock. + assertEquals(0L, thread.toolElapsedMillis(call, clock)) + clock = 6_000L + val later = thread.toolElapsedMillis(call, clock) + assertEquals(5_000L, later) + assertTrue(later > 0L) + } + + @Test + fun aToolWithProtocolTimingUsesItsOwnStart() { + val timed = tool("c1", "bash", ChatProtocol.TOOL_RUNNING, time = ChatTime(created = 900, ran = 1_000)) + // The protocol's own `ran` wins over the local stamp, so the elapsed is + // its start to now. + assertEquals(4_000L, runningToolElapsedMillis(timed, startedAt = 0L, nowMillis = 5_000L)) + // Neither a protocol start nor a local one: nothing to show, never a guess. + assertEquals(0L, runningToolElapsedMillis(tool("c2", "bash", ChatProtocol.TOOL_RUNNING), 0L, 5_000L)) + } + + @Test + fun aCompletedOrFailedCallLeavesTheRunningSetAndTheFailureIsVisible() { + var clock = 1_000L + val store = ChatStore(now = { clock }) + store.open(ChatSession(id = "s", title = "s")) + + store.event(toolFrame("s", "m1", tool("c1", "shell", ChatProtocol.TOOL_RUNNING, input("command" to "ls")))) + assertEquals(1, store.value.thread("s")!!.runningTools.size) + + // Completion clears the call from the in-flight set and drops its stamp. + clock = 2_000L + store.event(toolFrame("s", "m1", tool("c1", "shell", ChatProtocol.TOOL_COMPLETED, input("command" to "ls")))) + val done = store.value.thread("s")!! + assertTrue(done.runningTools.isEmpty()) + assertTrue(done.toolStartedAt.isEmpty()) + assertFalse(toolFailed(done.messages.last().parts.single().state)) + + // A failure is out of the running set too, and reads as failed on its chip. + store.event(toolFrame("s", "m1", tool("c2", "shell", ChatProtocol.TOOL_ERROR))) + val failed = store.value.thread("s")!! + assertTrue(failed.runningTools.isEmpty()) + assertTrue(toolFailed(failed.messages.last().parts.first { it.id == "c2" }.state)) + } + + @Test + fun severalCallsRunTogetherInOrderWithStableStartStamps() { + var clock = 1_000L + val store = ChatStore(now = { clock }) + store.open(ChatSession(id = "s", title = "s")) + + store.event(toolFrame("s", "m1", tool("c1", "shell", ChatProtocol.TOOL_RUNNING, input("command" to "build")))) + clock = 2_000L + store.event(toolFrame("s", "m1", tool("c2", "grep", ChatProtocol.TOOL_RUNNING, input("pattern" to "TODO")))) + + val thread = store.value.thread("s")!! + // Both render, in transcript order, so the list does not flicker between them. + assertEquals(listOf("c1", "c2"), thread.runningTools.map { it.id }) + // Each keeps the clock it first turned running on... + assertEquals(mapOf("c1" to 1_000L, "c2" to 2_000L), thread.toolStartedAt) + + // ...so a later frame for the first call does not restart its timer. + clock = 3_000L + store.event( + toolFrame("s", "m1", tool("c1", "shell", ChatProtocol.TOOL_RUNNING, input("command" to "build && test"))), + ) + val updated = store.value.thread("s")!! + assertEquals(1_000L, updated.toolStartedAt["c1"]) + clock = 11_000L + assertEquals(10_000L, updated.toolElapsedMillis(updated.runningTools.single { it.id == "c1" }, clock)) + } + + @Test + fun aCallWithoutADescriptionStillRendersNameStatusAndTime() { + var clock = 5_000L + val store = ChatStore(now = { clock }) + store.open(ChatSession(id = "s", title = "s")) + // No input at all: the part carries no description to show. + store.event(toolFrame("s", "m1", tool("c1", "task", ChatProtocol.TOOL_RUNNING))) + + val call = store.value.thread("s")!!.runningTools.single() + assertNull(toolDetail(call)) + assertEquals("task", toolLabel(call)) + assertTrue(ChatProtocol.toolRunning(call.state)) + clock = 9_000L + assertEquals(4_000L, store.value.thread("s")!!.toolElapsedMillis(call, clock)) + } + + @Test + fun toolDetailPrefersDescriptionThenCommandAndIgnoresWhatItCannotRead() { + // A description wins over a command when both are present. + assertEquals( + "Summarise the diff", + toolDetail( + tool( + "c1", "task", ChatProtocol.TOOL_RUNNING, + input("description" to "Summarise the diff", "command" to "git diff"), + ), + ), + ) + // A shell's command is next. + assertEquals( + "ls -la", + toolDetail(tool("c2", "shell", ChatProtocol.TOOL_RUNNING, input("command" to "ls -la"))), + ) + // A file tool's path is shown when nothing more descriptive exists. + assertEquals( + "/tmp/a.txt", + toolDetail(tool("c3", "read", ChatProtocol.TOOL_RUNNING, input("filePath" to "/tmp/a.txt"))), + ) + // A multi-line command collapses to a single line. + assertEquals( + "run this", + toolDetail(tool("c4", "shell", ChatProtocol.TOOL_RUNNING, input("command" to "run\n this"))), + ) + // A partial (not-yet-object) input, a missing state, and an input with no + // known key all show nothing rather than something invented. + assertNull( + toolDetail( + ChatPart( + type = ChatProtocol.PART_TOOL, + id = "c5", + name = "shell", + state = ChatToolState(status = ChatProtocol.TOOL_STREAMING, input = JsonPrimitive("{\"command\"")), + ), + ), + ) + assertNull(toolDetail(ChatPart(type = ChatProtocol.PART_TOOL, id = "c6", name = "shell"))) + assertNull(toolDetail(tool("c7", "shell", ChatProtocol.TOOL_RUNNING, input("foo" to "bar")))) + } + + @Test + fun aCallRunningTooLongIsMarked() { + assertFalse(toolLongRunning(TOOL_LONG_RUNNING_MILLIS - 1)) + assertTrue(toolLongRunning(TOOL_LONG_RUNNING_MILLIS)) + } + + @Test + fun theSessionRowReportsWhatIsRunning() { + assertEquals("Running shell", sessionWorkLabel(busy = false, threadWith(tool("c1", "shell", ChatProtocol.TOOL_RUNNING)))) + assertEquals( + "Running 2 tools", + sessionWorkLabel( + busy = false, + threadWith( + tool("c1", "shell", ChatProtocol.TOOL_RUNNING), + tool("c2", "grep", ChatProtocol.TOOL_RUNNING), + ), + ), + ) + // A turn running with no tool yet reads as plain Running, never idle, so a + // text stream and a parked tool call stay distinguishable. + assertEquals("Running", sessionWorkLabel(busy = false, ChatThread(sessionId = "s", running = true))) + assertEquals("Running", sessionWorkLabel(busy = true, ChatThread(sessionId = "s", running = true))) + + // Nothing running falls back to the ordinary busy/idle label. + assertEquals("Busy · read-only", sessionWorkLabel(busy = true, thread = null)) + assertEquals("Idle", sessionWorkLabel(busy = false, thread = null)) + assertEquals("Idle", sessionWorkLabel(busy = false, ChatThread(sessionId = "s"))) + } +} diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt index eaf2bfa1..0c94115f 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt @@ -113,19 +113,15 @@ class MultiChatStateTest { } @Test - fun busySessionIsReadOnlyAndCannotSend() { + fun busySessionStaysWritable() { val store = ChatStore() + // Another client watching the session never makes it read-only: the + // server fans the stream out and accepts a prompt from any client. store.open(session("a", busy = true)) store.draft("a", "unsent") val thread = store.value.thread("a")!! - assertTrue(thread.readOnly) - assertFalse(thread.canSend) - - // The server can clear busy later; the chat then becomes writable again. - store.sessionsLoaded(listOf(session("a", busy = false))) - store.draft("a", "unsent") - assertFalse(store.value.thread("a")!!.readOnly) - assertTrue(store.value.thread("a")!!.canSend) + assertTrue(thread.canSend) + assertTrue(thread.busy) } @Test @@ -192,10 +188,9 @@ class MultiChatStateTest { val store = ChatStore() store.open(session("a", busy = true)) store.running("a", true) - // Our own turn keeps the session writable even though the server reports it busy. + // A turn in flight (ours or another client's) keeps the session writable. store.draft("a", "next prompt") val thread = store.value.thread("a")!! - assertFalse(thread.readOnly) assertTrue(thread.canSend) } @@ -229,4 +224,78 @@ class MultiChatStateTest { assertFalse(store.value.open.any { it.sessionId == "a" }) assertTrue(store.value.open.any { it.sessionId == "b" }) } + + @Test + fun remoteUserFrameIsFoldedOnceAndAttributed() { + val store = ChatStore() + store.open(session("a")) + // The operator's own message, appended locally when sent. + store.appendLocalUserMessage("a", "mine") + // Another client's prompt arrives live, attributed to that device. + val frame = ChatEventFrame( + sessionId = "a", + messageId = "usr_7", + kind = ChatProtocol.EVENT_USER, + client = "Pixel 10 Pro Fold", + part = ChatPart(type = ChatProtocol.PART_TEXT, text = "from the fold"), + ) + store.event(frame) + val messages = store.value.thread("a")!!.messages + assertEquals(2, messages.size) + assertEquals("mine", messages[0].parts.single().text) + assertEquals(ChatProtocol.ROLE_USER, messages[1].role) + assertEquals("Pixel 10 Pro Fold", messages[1].client) + assertEquals("from the fold", messages[1].parts.single().text) + + // A replayed frame (e.g. after a reconnect) is folded once, not twice. + store.event(frame) + assertEquals(2, store.value.thread("a")!!.messages.size) + } + + @Test + fun remoteAnswerClearsTheApprovalCard() { + val store = ChatStore() + store.open(session("a")) + store.permission(ChatPermissionFrame(sessionId = "a", requestId = "req_1", action = "bash")) + val open = approvalCard(store.value.thread("a")!!.permission, store.value.thread("a")!!.permissionAnswer)!! + assertTrue("the card is answerable while the request is open", open.actionable) + + // Another client answered: the server pushes the resolved frame, which + // clears this client's card and shows the outcome without ever disabling + // it while the first answer was in flight. + store.permission( + ChatPermissionFrame( + sessionId = "a", + requestId = "req_1", + action = "bash", + resolved = true, + decision = ChatProtocol.DECISION_ONCE, + resolvedBy = "Pixel 9 Pro XL", + ), + ) + val thread = store.value.thread("a")!! + val cleared = approvalCard(thread.permission, thread.permissionAnswer)!! + assertFalse("a resolved request offers no controls", cleared.actionable) + assertEquals(ApprovalState.RESOLVED, cleared.state) + assertEquals(ChatProtocol.DECISION_ONCE, cleared.decision) + } + + @Test + fun queuedPromptIsShownUntilTheTurnStreams() { + val store = ChatStore() + store.open(session("a")) + store.setQueued("a", true) + assertTrue(store.value.thread("a")!!.queued) + // The queued turn's first frame means it is running, so the marker clears. + store.event( + ChatEventFrame( + sessionId = "a", + messageId = "m1", + kind = ChatProtocol.PART_TEXT, + delta = "hi", + part = ChatPart(type = ChatProtocol.PART_TEXT, id = "m1#0"), + ), + ) + assertFalse(store.value.thread("a")!!.queued) + } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusTest.kt index 2c98d746..ce9a39d4 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/components/RunStatusTest.kt @@ -11,14 +11,18 @@ class RunStatusTest { assertEquals(RunState.Queued, runStateOf("queued")) assertEquals(RunState.Waiting, runStateOf("waiting")) assertEquals(RunState.Active, runStateOf("active")) + assertEquals(RunState.Waiting, runStateOf("waiting")) assertEquals(RunState.Succeeded, runStateOf("succeeded")) - // Step/outcome words map onto the same states. + // Step/outcome words map onto the same states, so one word is one colour. assertEquals(RunState.Succeeded, runStateOf("completed")) assertEquals(RunState.Succeeded, runStateOf("success")) + assertEquals(RunState.Succeeded, runStateOf("done")) assertEquals(RunState.Failed, runStateOf("failed")) assertEquals(RunState.Failed, runStateOf("error")) assertEquals(RunState.Canceled, runStateOf("canceled")) assertEquals(RunState.Interrupted, runStateOf("interrupted")) + assertEquals(RunState.Blocked, runStateOf("blocked")) + assertEquals(RunState.Skipped, runStateOf("skipped")) } @Test diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactTypeTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactTypeTest.kt index 57060c12..a6274e23 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactTypeTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/ArtifactTypeTest.kt @@ -74,4 +74,17 @@ class ArtifactTypeTest { val glyphs = ArtifactKind.entries.map { artifactIcon(it) } assertEquals(ArtifactKind.entries.size, glyphs.toSet().size) } + + @Test + fun everyKindHasAWordThatNamesIt() { + // The search surface names an artifact by this word for a screen reader; + // it must exist for every kind and be distinct. + assertEquals("Image", artifactKindLabel(ArtifactKind.Image)) + assertEquals("PDF", artifactKindLabel(ArtifactKind.Pdf)) + assertEquals("JSON", artifactKindLabel(ArtifactKind.Json)) + assertEquals("Document", artifactKindLabel(ArtifactKind.Document)) + assertEquals("File", artifactKindLabel(ArtifactKind.Other)) + val labels = ArtifactKind.entries.map { artifactKindLabel(it) } + assertEquals(ArtifactKind.entries.size, labels.toSet().size) + } } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt index d52555ba..7a3a08e0 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt @@ -5,6 +5,9 @@ import net.awan.pipelines.data.protocol.GraphEdge import net.awan.pipelines.data.protocol.GraphRoute import net.awan.pipelines.data.protocol.Protocol import net.awan.pipelines.data.protocol.RunGraphState +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.runStateColor +import net.awan.pipelines.ui.components.runStateOf import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue @@ -15,9 +18,9 @@ class GraphPaletteTest { /** The dark Pipelines surface the outcome label chip is drawn on. */ private val darkSurface = Color(0xFF0E1513) - /** The two terminal roles as the dark scheme supplies them. */ - private val successRole = Color(0xFFF2C879) - private val errorRole = Color(0xFFFFB4AB) + /** The two terminal roles are the shared run-status colours. */ + private val successRole = runStateColor(RunState.Succeeded) + private val errorRole = runStateColor(RunState.Failed) private fun colors() = GraphColors( success = successRole, @@ -43,11 +46,39 @@ class GraphPaletteTest { "exhausted", "retry", "approved", "fast", "missing", "done", ) + /** The outcomes with no run-status meaning that the graph palette owns. */ + private val graphOnlyOutcomes = listOf( + "rejected", "exhausted", "retry", "approved", "fast", "missing", + ) + + /** + * A word that is a run state resolves to exactly the colour the runs list + * draws for it: the graph factory and [outcomeColor] share one source. + */ @Test - fun everyRealisticOutcomeGetsADistinctColour() { + fun statusOutcomesTakeTheSharedRunStatusColour() { val colors = colors() - val mapped = realisticOutcomes.map { outcomeColor(it, colors) } - assertEquals(realisticOutcomes.size, mapped.toSet().size) + listOf( + "success", "completed", "done", "error", "failed", + "blocked", "skipped", "waiting", "running", "queued", + "canceled", "interrupted", + ).forEach { word -> + assertEquals( + "outcomeColor($word) must equal the runs-list colour", + runStateColor(runStateOf(word)), + outcomeColor(word, colors), + ) + } + } + + /** The graph-only outcomes keep distinct curated colours, none a status colour. */ + @Test + fun graphOnlyOutcomesGetDistinctColours() { + val colors = colors() + val mapped = graphOnlyOutcomes.map { outcomeColor(it, colors) } + assertEquals(graphOnlyOutcomes.size, mapped.toSet().size) + val statusColours = RunState.entries.map { runStateColor(it) }.toSet() + mapped.forEach { assertFalse("$it borrowed a run-status colour", it in statusColours) } } @Test @@ -74,10 +105,8 @@ class GraphPaletteTest { assertEquals(unknown, outcomeColor("something-brand-new", colors)) // A blank name is just another unknown: stable and non-throwing. assertEquals(outcomeColor("", colors), outcomeColor("", colors)) - // The fallback comes from the reserved region, not a known outcome slot. - val knownIndices = realisticOutcomes - .filter { it != "success" && it != "error" } - .map { GraphPalette.outcomeColorIndex(it) } + // The fallback comes from the reserved region, not a known graph-only slot. + val knownIndices = graphOnlyOutcomes.map { GraphPalette.outcomeColorIndex(it) } assertFalse(GraphPalette.outcomeColorIndex("something-brand-new") in knownIndices) } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/StatusColorConsistencyTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/StatusColorConsistencyTest.kt new file mode 100644 index 00000000..3233bf5c --- /dev/null +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/StatusColorConsistencyTest.kt @@ -0,0 +1,57 @@ +package net.awan.pipelines.ui.graph + +import net.awan.pipelines.ui.components.RunState +import net.awan.pipelines.ui.components.runStateColor +import net.awan.pipelines.ui.components.runStateOf +import net.awan.pipelines.ui.theme.PipelinesDarkColors +import org.junit.Assert.assertEquals +import org.junit.Test + +/** + * The one-colour contract behind the status brief: whatever draws a status or a + * stage outcome — the runs list, the timeline's step chips, the graph, the stage + * sheet — resolves a word through one owned source, so a word means one colour + * everywhere and never a second colour for the same meaning. + */ +class StatusColorConsistencyTest { + + private val colors = graphColors(PipelinesDarkColors) + + /** + * Every word the timeline can show that is a run state resolves, through the + * graph factory the timeline uses, to exactly the runs-list colour. + */ + @Test + fun theTimelineColourComesFromTheRunsListSource() { + listOf( + "success", "completed", "done", "error", "failed", + "blocked", "skipped", "waiting", "running", "queued", + "canceled", "cancelled", "interrupted", "active", + ).forEach { word -> + assertEquals( + "timeline colour for '$word' must be the runs-list colour", + runStateColor(runStateOf(word)), + outcomeColor(word, colors), + ) + } + } + + /** + * Every state maps to exactly one colour: the lookup is deterministic, and no + * two states collide except the one deliberate alias (a live run and the + * server's `active` usage bucket are the same in-progress state). + */ + @Test + fun everyStateMapsToExactlyOneColour() { + RunState.entries.forEach { state -> + assertEquals(runStateColor(state), runStateColor(state)) + } + val shared = RunState.entries + .groupBy { runStateColor(it) } + .filterValues { it.size > 1 } + .values + .map { it.toSet() } + .toSet() + assertEquals(setOf(setOf(RunState.Running, RunState.Active)), shared) + } +} diff --git a/docs/cli.md b/docs/cli.md index ada999b2..996962c5 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -304,12 +304,31 @@ The brokered OpenCode chat exposes the operator's own sessions, separate from th sessions pipeline runs create. The protocol types are: - `chat_sessions` lists the operator's own sessions only, ordered - most-recently-used first. Each carries its `directory`, its `tag`, its `busy` - state (another connection currently holds it) and its recency. A session with + most-recently-used first. Each carries its `directory`, its `tag` and its + recency. A session with no recorded tag is never listed, and no pipeline stage session is ever listed: stage sessions are still recorded in `run_steps`/`run_session_owners` for the run that owns them. The list is fail-closed: with no registry and no - store it returns an empty list, never the endpoint's whole session list. + store it returns an empty list, never the endpoint's whole session list. A + session is never marked `busy`: any number of clients may watch and write one. +- `chat_subscribe` attaches a connection to one session's shared live stream (body + `session_id`) and replays the session's still-pending approval requests, so every + client that watches a session sees every frame any client's turn produces — the + other devices' prompts and the turn's streaming output — and can answer a shared + approval. Attaching is idempotent per connection; the subscription is released + when the connection ends. +- `chat_prompt` may come from any client. A prompt whose session already has a turn + in flight is accepted into that session's bounded queue (currently 8) and + acknowledged with `chat_queued: true`; the agent never receives two interleaved + turns. The prompt is echoed to the other watching clients as a `chat_event` of + kind `user`, carried with the sender's `client` label (a device name), while the + sender's own transcript keeps its local copy. +- `chat_reply` is exactly-once: the first answer to a pending request wins, is + recorded with the answering client's label and is pushed back to every watching + client as the same `chat_permission` frame with `resolved: true`, `decision` and + `resolved_by`, so each card clears and shows the outcome. A later answer is + refused as already answered (naming the client that won), never silently ignored + and never delivered to the agent twice. - `chat_create` takes a `title` (default "New chat") and a `directory` (default `~`, the operator's home; `~`, an omitted or empty value and a `~/...` value all resolve to the home directory). A relative or missing directory is @@ -357,8 +376,11 @@ password file as a reference). The stored tag is exactly `operator`; the display label `Operator` is derived from it, so there is no second tag vocabulary. Chat uses the server's one OpenCode -transport, and every existing chat guarantee (retained-state bounds, the -permission/approval flow, interruption, one broker call per list) is unchanged. +transport. A session's stream is fanned out to every client watching it, prompts +are serialised per session (queued behind the in-flight turn rather than +rejected), and approvals are shared and exactly-once; the retained-state bounds, +the resync-on-reconnect path, the exclusion of a run's own session and +per-connection write serialisation are unchanged. The operator-session registry, filter, directory defaulting and the list bound are covered by the `pipeline`, `opencode` and `server` unit tests. The live end-to-end diff --git a/docs/notes/chat-in-flight-tool-work.md b/docs/notes/chat-in-flight-tool-work.md new file mode 100644 index 00000000..605f1bdf --- /dev/null +++ b/docs/notes/chat-in-flight-tool-work.md @@ -0,0 +1,65 @@ +# Chat in-flight tool work + +## What this item changed + +`android/` only, the chat's two "working" surfaces. + +- `ui/chat/ChatFormat.kt` adds `runningToolCalls` (the tool parts still + `running`, in transcript order), `toolDetail` (the command/description the + part's own input carries, from description/command/filePath/file_path/path/ + pattern/query/url, one line, elided at 72 chars, `null` when absent), + `runningToolElapsedMillis` (the protocol's `time.ran`/`created` when present, + else the local per-part stamp), `runningToolStamps` (a stable start per part + across frames), `TOOL_LONG_RUNNING_MILLIS` = 60s with `toolLongRunning`, and + `sessionWorkLabel`. +- `ui/chat/ChatStore.kt`: `ChatThread.toolStartedAt` plus `runningTools` and + `toolElapsedMillis`; `history()`, the frame fold and `setRunning` maintain it. +- `ui/chat/ChatTranscript.kt`: `RunningIndicator` now also lists one line per + running call (name, detail where present, live elapsed), keyed by part id so + concurrent calls render together; a call past 60s is tinted and marked + `· long`. +- `ui/chat/ChatListPane.kt`: the session row renders + `sessionWorkLabel(session.busy, thread)`. +- `ui/chat/ChatRunningWorkTest.kt` covers it (name/detail/elapsed, clear on + completion, error state, concurrent calls, no-detail stream). + +No percentage, ETA or progress bar is invented; only the reported fields (tool +name, `state.status`, `state.input`) are used. + +## Shared documents this change makes stale + +`android/README.md` documents the two surfaces this item changed, in the +`## Streaming replies (16 Oct 2026)` record. The note is written here rather +than edited in place; the `docs-fold` writer should update it. + +- `android/README.md:4633` — the **Running indicator** bullet reads "The + transcript's indicator shows the spinner, `Working…` and the live elapsed + time (ticked once a second, never per frame, through the shared + `formatDuration`)." It should add that the indicator also lists, one line per + tool call still in flight, the call's name, the command/description the part + carries when it carries one, and that call's own live elapsed time; that a + call running 60 seconds or more is tinted and marked `· long`; that a call's + line drops out the moment it completes or errors, which is what clears the + indicator; and that no percentage, ETA or progress bar is shown. The rest of + the bullet (one-second tick, the tick loop keyed on the turn's start, the + elapsed count surviving a chat switch) is still true. +- `android/README.md:4454` — the session-list sentence "the list shows each + session's running/busy/read-only status" is now incomplete: a working session + row names what it is doing (`Running `, or `Running tools` when + several run at once) instead of only `Running`, while a turn that is only + generating text still reads plain `Running`, so the two stay distinguishable; + a busy session with nothing running still reads `Busy · read-only`, and an + idle one `Idle`. + +Dates, counts and capture names in those dated records are past evidence and +stay as they are; only the two behaviour statements above are now stale. + +## Not stale + +- No packaged OpenCode skill reference documents this app surface. The chat + references in `internal/author/skill/references/operations.md` document the + server's brokered `chat_*` protocol, which this change does not touch, and no + packaged template or `internal/author/` managed file names the app's chat + indicator or session label. +- `android/AGENTS.md` already lists `ui/chat/` and its files, so it needs no + change. diff --git a/docs/notes/docs-fold-single-writer.md b/docs/notes/docs-fold-single-writer.md new file mode 100644 index 00000000..c689fc9e --- /dev/null +++ b/docs/notes/docs-fold-single-writer.md @@ -0,0 +1,40 @@ +# docs-fold single documentation writer + +## What this item changed + +Per-item workflows no longer edit shared documentation themselves. The convention now +lives in `internal/author/skill/references/orchestration.md` (brief item 5, the +hard-constraint bullet, "Single documentation writer", and the "Pipeline choice" +committer bullet), the canonical committer checklist in +`internal/author/skill/references/format.md` (step 6), the bundled committer prompts in +`examples/task.md` and `examples/three-stage.md`, and the repository guideline +`AGENTS.md`. + +The chosen mechanism is a **per-item note file** at `docs/notes/.md`: when a +change makes a shared document stale, the item records what changed and what should +change there, commits that note with its own change, and never edits a shared document. +The chosen **single writer** is the manual-only `docs-fold` pipeline, added as a fifth +bundled starter at `examples/docs-fold.md` and listed in `examples/catalog.go` and +`examples/README.md`. Its `fold` stage reads every note under `docs/notes/`, folds each +into the shared document it names, and deletes the consumed notes in its own commit. + +## Shared documents this change makes stale + +Adding the fifth starter (`docs-fold`) makes the following documents' starter counts +wrong. They were deliberately **not** edited by this item; the `docs-fold` writer should +correct them when it next folds notes. + +- `README.md:191` — "To skip authoring, use **:templates**, choose one of the four + generic starters," should read "five generic starters". +- `docs/cli.md:170` — "Use `:templates` for four simple, manual-only starters: task, + review, research, and plan/implement/review." should say five starters and name + `docs-fold` (fold accumulated documentation notes, then commit locally). +- `internal/author/skill/references/operations.md:13` — "Four optional generic starters + are task, review, research and three-stage;" should read "Five optional generic + starters are task, review, research, three-stage and docs-fold;". + +## Do not change + +- `docs/first-version-testing.md:148` and the dated records in + `docs/installation-verification.md` describe a past fixture run at the time it ran; + they are dated evidence, not current counts, and stay as they are. diff --git a/examples/README.md b/examples/README.md index 30b4e478..636b07bb 100644 --- a/examples/README.md +++ b/examples/README.md @@ -1,6 +1,6 @@ # Simple workflow templates -Four optional, technology-neutral starters. Nothing is installed as a published +Five optional, technology-neutral starters. Nothing is installed as a published pipeline automatically; all templates are manual-only and have at most four stages. | Template key | Workflow | Tools | @@ -9,6 +9,7 @@ pipeline automatically; all templates are manual-only and have at most four stag | `review` | Read repository content and report findings | Read/glob/grep and conditional web search/fetch; no edit/shell | | `research` | Research a topic, then write a sourced report | Web search/fetch, then none | | `three-stage` | Plan → implement → review → commit | Planner read/glob/grep + conditional web; implementer read/glob/grep/edit/shell with no web (follows the planner's research); reviewer independent shell + conditional web; committer read/shell | +| `docs-fold` | Fold accumulated item documentation notes into the shared docs, then commit locally | Fold: read/glob/grep/edit/shell; committer: read/shell | Every workflow that changes the repository ends in a **committer** stage that commits locally and never pushes. The committer stages the union of the runner's @@ -17,6 +18,12 @@ declared `changed_files` — a declared list can be incomplete — then runs the repository's required checks before committing. `task` and `three-stage` follow this; `review` and `research` change nothing and so do not commit. +`docs-fold` is the deliberate **single documentation writer**. A per-item workflow never +edits a shared README or topic doc: when its change makes one stale it records a note at +`docs/notes/.md`, unique per item, and commits that note with the change. Running +the manual-only `docs-fold` pipeline later folds the accumulated notes into the shared +documentation and removes them. + Model and agent stages return the line-oriented result: the first non-empty line is the declared outcome, a `# output` section holds the JSON output map for the next stage, and any further `# ` section is retained verbatim as evidence. The diff --git a/examples/catalog.go b/examples/catalog.go index 5070bcda..150c9f97 100644 --- a/examples/catalog.go +++ b/examples/catalog.go @@ -16,6 +16,7 @@ var starters = []protocol.Template{ {Key: "three-stage", Name: "Plan, implement, review", Description: "Plan a change, implement it, review and verify it, then commit it locally. Any language or file type."}, {Key: "review", Name: "Review a repository", Description: "One read-only stage to review repository content and report findings."}, {Key: "research", Name: "Research a topic", Description: "Research a topic on the web, then write a sourced report. Requires web search support."}, + {Key: "docs-fold", Name: "Fold documentation notes", Description: "Fold the accumulated per-item documentation notes into the shared docs, then commit locally. The repository's single documentation writer; manual-only."}, } func Catalog() []protocol.Template { diff --git a/examples/catalog_test.go b/examples/catalog_test.go index ba0e8a23..6b690b3f 100644 --- a/examples/catalog_test.go +++ b/examples/catalog_test.go @@ -27,11 +27,11 @@ func TestReadmeThreeStageExampleIsValid(t *testing.T) { func TestCatalogContainsValidUnpublishedTemplates(t *testing.T) { items := examples.Catalog() - if len(items) != 4 { + if len(items) != 5 { t.Fatal("unexpected catalog size", len(items)) } seen := map[string]bool{} - wantStages := map[string]int{"task": 2, "review": 1, "research": 2, "three-stage": 4} + wantStages := map[string]int{"task": 2, "review": 1, "research": 2, "three-stage": 4, "docs-fold": 2} for _, item := range items { if seen[item.Key] || item.Description == "" || item.Name == "" { t.Fatal("invalid template metadata", item.Key) @@ -104,6 +104,10 @@ var starterTools = map[string]map[string][]string{ "reviewer": {"read", "glob", "grep", "shell", "websearch", "webfetch"}, "committer": {"read", "glob", "grep", "shell"}, }, + "docs-fold": { + "fold": {"read", "glob", "grep", "edit", "shell"}, + "committer": {"read", "glob", "grep", "shell"}, + }, } func TestStarterRoleToolRestrictions(t *testing.T) { @@ -182,6 +186,7 @@ func TestWorkProducingStartersEndInACommitter(t *testing.T) { for _, tc := range []struct{ key, producer string }{ {"task", "worker"}, {"three-stage", "implementer"}, + {"docs-fold", "fold"}, } { graph := parsedCatalog(t)[tc.key] last := graph.Stages[len(graph.Stages)-1] diff --git a/examples/docs-fold.md b/examples/docs-fold.md new file mode 100644 index 00000000..a7200acf --- /dev/null +++ b/examples/docs-fold.md @@ -0,0 +1,90 @@ +# stage fold + +```output +{ summary, changed_files, folded_notes } +``` + +```prompt +Fold the accumulated per-item documentation notes into the repository's shared +documentation. Read every file under `docs/notes/`; for each note, apply the change it +records to the shared document the note names - the repository's READMEs and topic docs +and the packaged skill references - then delete the consumed note. Do not edit any other +file, change behaviour, or rewrite documentation that is still true. Keep values from +their single existing sources. An empty or missing `docs/notes/` directory is a success +no-op: make no change, commit nothing, and say so. Limit inspection to the notes +directory and the documents they name; never scan filesystem or mount roots, and use +commands supported by the actual execution environment. Save any artifacts you produce +into the artifacts directory named in the runtime context. Report the notes read, the +documents changed and the notes deleted in an `# evidence` section, with the exact +commands and observed results. Return the line-oriented result: the first non-empty line +is the declared outcome, a `# output` section holds one JSON object with the output +fields named above, and any further `# ` section is retained verbatim as +evidence. Return blocked if the notes directory cannot be read. +``` + +```tools +read +glob +grep +edit +shell +``` + +```configs +provider=opencode-go +model=deepseek-v4.1-flash +retries=2 +timeout=1h +``` + +```edges +success -> committer +blocked -> #failure +error -> #failure +``` + +# stage committer + +```output +{ committed, commit, changed_files, pre_commit_checks } +``` + +```prompt +Commit this run's change locally. Never push, tag, deploy or rewrite history. Select +the run's changed paths from input.server_changed_files (the runner's captured +evidence) and the fold stage's declared changed_files, and stage their union, including +the notes the fold stage deleted (stage the removal, not only surviving paths). Inspect +the staged diff before committing; never commit unrelated work, secrets or generated +artifacts. When nothing is staged - for example an empty notes directory - do not create +an empty commit; return success with a clear note. Otherwise commit with a concise +message naming this run's change and report the commit hash. If a required check fails, +do not commit; return blocked with the failing output. Return the line-oriented result: +the first non-empty line is the declared outcome, a `# output` section holds one JSON +object with the output fields named above, and any further `# ` section is +retained verbatim as evidence. Never claim an unexecuted check passed or fabricate a +commit. +``` + +```memory +{"changed_files":"fold.changed_files","server_changed_files":"input.server_changed_files"} +``` + +```tools +read +glob +grep +shell +``` + +```configs +provider=opencode-go +model=deepseek-v4.1-flash +retries=2 +timeout=1h +``` + +```edges +success -> #success +blocked -> #failure +error -> #failure +``` diff --git a/examples/task.md b/examples/task.md index 9395a751..428a5365 100644 --- a/examples/task.md +++ b/examples/task.md @@ -71,7 +71,12 @@ Commit this run's change locally. Never push, tag, deploy or rewrite history. Select the run's changed paths from input.server_changed_files (the runner's captured evidence) and the worker's declared changed_files, and stage their union of paths that still exist, keeping any exclusions. Inspect the staged diff before -committing; never commit unrelated work, secrets or generated artifacts. Pre-commit +committing; never commit unrelated work, secrets or generated artifacts. Follow the +documentation-note step of the committer checklist in `references/format.md`: when the +change makes a shared document stale, stage the item's own documentation note +(`docs/notes/.md`) with the change, and never edit a shared document (a README, +topic docs or the packaged skill references) here; a single documentation writer folds +notes later. Pre-commit checklist: confirm the staged paths are this run's change; run the repository's required checks and record the exact commands and observed results in an `# evidence` section; do not commit if a required check fails, return blocked diff --git a/examples/three-stage.md b/examples/three-stage.md index f23e25f6..7cd154c2 100644 --- a/examples/three-stage.md +++ b/examples/three-stage.md @@ -179,7 +179,11 @@ Select the run's changed paths from input.server_changed_files (the runner's captured evidence) and the implementer's declared changed_files, and stage their union of paths that still exist, keeping any exclusions. Inspect the staged diff before committing; never commit unrelated work, secrets or generated artifacts. -Pre-commit checklist: confirm the staged paths are this run's change; run the +Follow the documentation-note step of the committer checklist in +`references/format.md`: when the change makes a shared document stale, stage the item's +own documentation note (`docs/notes/.md`) with the change, and never edit a shared +document (a README, topic docs or the packaged skill references) here; a single +documentation writer folds notes later. Pre-commit checklist: confirm the staged paths are this run's change; run the repository's required checks and record the exact commands and observed results in a `# evidence` section; do not commit if a required check fails, return blocked with the failing output instead. If nothing is staged, do not create an diff --git a/internal/author/skill/references/format.md b/internal/author/skill/references/format.md index 0e101011..a1f129a4 100644 --- a/internal/author/skill/references/format.md +++ b/internal/author/skill/references/format.md @@ -228,6 +228,15 @@ State this pre-commit checklist in the prompt: note. 5. Commit with a concise message naming the run's change and report the commit hash; never push, tag, rebase or amend. +6. Ensure the item's per-item documentation note (`docs/notes/.md`, written when + the change makes a shared document stale) is staged with the change. Never edit a + shared document (a README or topic doc, or a packaged skill reference) here: a single + documentation writer folds notes later (`references/orchestration.md`). An item that + staled no shared document has no note and needs no step 6. + +This list is the canonical checklist. The bundled starters `task`, `three-stage` and +`docs-fold` each repeat it in their committer prompt because a template is embedded and +published on its own; keep those copies in sync with this list. Merging is the operator's or a lane's job, not the committer's: it commits locally and stops (`references/orchestration.md`, `references/lanes.md`). The server does diff --git a/internal/author/skill/references/orchestration.md b/internal/author/skill/references/orchestration.md index a2aa982e..66f5f2d2 100644 --- a/internal/author/skill/references/orchestration.md +++ b/internal/author/skill/references/orchestration.md @@ -55,9 +55,11 @@ Every brief has: output it must report, plus the screenshots the reviewer must read. Say plainly: "report the exact commands and their observed results. Do not claim a check you did not run." -5. **Where it belongs** — the packaged templates, the repository's guidelines (README - and topic docs) and the packaged skill references the change is expected to touch, - so the committer can check and update them before it commits. +5. **Documentation note** — where the change makes shared documentation stale, the item + records that in its own per-item note `docs/notes/.md`: what it changed and + which shared document (a README or topic doc, or a packaged skill reference) is now + stale and what should change there. The item writes only its note; it must not edit a + shared document. See "Single documentation writer" below. 6. **The hard constraints block** (below). 7. **Publishing rules** (`references/delivery.md`). @@ -81,7 +83,8 @@ dependencies; do not restart, rebuild or reconfigure the Pipelines or OpenCode server, the installer, the ntfy service or any other service - runs and lanes are active; never install on the operator's physical device; keep geometry and values from their single existing sources rather than new literals; commit locally only, -never push; . +never push; record a documentation note in `docs/notes/.md` rather than editing +a shared document; . ``` Requirements must be concrete and checkable. Name files, functions, commands, and @@ -106,12 +109,36 @@ Adapt the scope and publishing lines per item; keep the rest. - **Keep values from single sources** — geometry, tokens, sizes and constants come from the source that already owns them, not from new literals. - **Commit locally only, never push** — the committer stage commits, no other stage. -- **Reflect the change where it belongs** — before committing, the committer checks - that the change is reflected in the packaged templates, the repository's guidelines - (README and topic docs) and the packaged skill references, updates anything stale, - and states in the commit body what it checked or that nothing needed updating. +- **Record stale documentation; do not rewrite it** — before committing, the committer + ensures the item's `docs/notes/.md` note, when the change makes a shared document + stale, is staged with the change, and states in the commit body what it checked. The + committer never edits a shared document (a README or topic doc, or a packaged skill + reference) itself; the single documentation writer folds notes later. - **Publish rules** — WIP artefact naming and LAN URLs per `references/delivery.md`. +## Single documentation writer + +Shared documentation — the repository's READMEs and topic docs (for this repository +`android/README.md` and `docs/cli.md`) and the packaged skill references in +`internal/author/skill/references/` — has exactly one writer, never an item. Each item +that makes one of these stale leaves a note at `docs/notes/.md` (item 5 above). +The note's filename is unique per item, so two items never write the same file and +never conflict on prose. + +The writer is the manual-only `docs-fold` pipeline, bundled as the starter +`examples/docs-fold.md`. Its `fold` stage reads every note under `docs/notes/`, folds +each into the shared document it names, and deletes the consumed notes in its own +commit; an empty `docs/notes/` is a success no-op with no empty commit. It is never +scheduled and is never part of a per-item workflow. + +The operator triggers it deliberately: + +```sh +pipelines new "Docs fold" --template docs-fold --no-open +pipelines submit +pipelines run "Docs fold" +``` + ## Pipeline choice - Use a pipeline that keeps **implementer + reviewer + ui_reviewer + committer** for @@ -123,10 +150,11 @@ Adapt the scope and publishing lines per item; keep the rest. `skipped` with a reason when the change has no rendered surface. Never accept a UI change approved without the images. - The committer is the only stage that commits, and it stages only the run's changed - files. Before committing it checks that the change is reflected in the packaged - templates, the repository's guidelines (README and topic docs) and the packaged - skill references, updates anything stale, and states in the commit body what it - checked or that nothing needed updating. It must also select `input.server_changed_files` + files. Before committing it ensures the item's `docs/notes/.md` note, when the + change makes a shared document stale, is staged with the change, and states in the + commit body what it checked; it never edits a shared document (a README or topic doc, + or a packaged skill reference) itself, because a single documentation writer folds + notes later. It must also select `input.server_changed_files` (the runner's captured evidence, `references/control.md`) alongside the implementer's declared `changed_files` and stage their union: an implementer's declared list can be incomplete, and a captured path it omitted is still this run's change. Its prompt carries diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index 282c0da0..9db719f7 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -33,9 +33,17 @@ const ( // operator-session registry. ChatReopen clears the closed state again, so a // finished chat can be resumed. Both take a ChatQuery (the session id) and // echo the updated session like chat_create/chat_adopt. Neither ever touches - // the pipeline-owned run sessions. + // the pipeline-owned run sessions, and a closed session stays watchable: close + // only records the finished state, it never detaches a client. ChatClose = "chat_close" ChatReopen = "chat_reopen" + // ChatSubscribe attaches a connection to one session's shared live stream so + // it receives every frame any client's turn produces (its own and the other + // devices'), not only the frames of a turn it prompted itself. Any number of + // clients may watch one session; the session is never read-only. The request + // body is a ChatQuery naming the session and the response echoes the request + // id once the subscription is attached. + ChatSubscribe = "chat_subscribe" // ChatDirectories is the request/response type for the operator's directory // choices: the home directory plus the directories of previous operator // sessions, most recently used first, deduplicated and bounded. It is a @@ -59,13 +67,16 @@ const ( ) // ChatEvent.Kind values pushed on the chat_event stream. Step and usage carry -// no ChatPart; they report turn progress and the turn's totals. +// no ChatPart; they report turn progress and the turn's totals. User carries the +// text of a prompt another client sent, so a transcript can show it live; it is +// never sent back to the client that sent the prompt. const ( ChatEventText = ChatPartText ChatEventReasoning = ChatPartReasoning ChatEventTool = ChatPartTool ChatEventStep = "step" ChatEventUsage = "usage" + ChatEventUser = "user" ) // ChatStep.Status values, mirroring the OpenCode session.step events. @@ -121,10 +132,11 @@ type ChatSession struct { Tag string `json:"tag,omitempty"` CreatedAt int64 `json:"created_at,omitempty"` UpdatedAt int64 `json:"updated_at,omitempty"` - // Busy marks a session another client currently holds (or one the server - // itself owns as an active run), so the phone can show it read-only instead - // of letting two clients silently write the same conversation. It is - // additive and optional: older peers ignore it. + // Busy is retained for wire compatibility only: it is never set by this + // server. A session is never read-only, any number of clients may watch and + // write it, and only a turn is serialised (a waiting prompt is acknowledged + // as queued on its own client instead of marking the session Busy). Older + // peers still parse the field; newer ones ignore it. Busy bool `json:"busy,omitempty"` // Closed records that the operator finished with this session: the server // keeps the session, its transcript and its history, but the closed state is @@ -171,26 +183,34 @@ type ChatQuery struct { // ChatPromptRequest is the chat_prompt request body: the text to send, with an // optional model/agent override and attached file URIs. The matching response is -// the inbox envelope, which the server folds into a ChatMessage. +// the inbox envelope, which the server folds into a ChatMessage. Client is the +// sending device's human-readable label so every other client can attribute the +// message; the server sanitises it and falls back to a generic label when it is +// blank. type ChatPromptRequest struct { SessionID string `json:"session_id"` Text string `json:"text"` Model string `json:"model,omitempty"` Agent string `json:"agent,omitempty"` Files []string `json:"files,omitempty"` + Client string `json:"client,omitempty"` } // ChatMessage is one stored turn returned by chat_messages. A user turn is a // single text part; an assistant turn holds the text, reasoning and tool parts // the phone renders. Parts corresponds to the OpenCode content array. type ChatMessage struct { - ID string `json:"id"` - SessionID string `json:"session_id"` - Role string `json:"role"` - Model string `json:"model,omitempty"` - Agent string `json:"agent,omitempty"` - CreatedAt int64 `json:"created_at,omitempty"` - Parts []ChatPart `json:"parts"` + ID string `json:"id"` + SessionID string `json:"session_id"` + Role string `json:"role"` + Model string `json:"model,omitempty"` + Agent string `json:"agent,omitempty"` + CreatedAt int64 `json:"created_at,omitempty"` + // Client is the sending device's label on a user turn the server echoed, so a + // resumed transcript still says who sent the message. It is empty on an + // assistant turn. + Client string `json:"client,omitempty"` + Parts []ChatPart `json:"parts"` } // ChatPart is one element of a ChatMessage. Type selects the meaning: text and @@ -252,6 +272,9 @@ type ChatEventFrame struct { Part *ChatPart `json:"part,omitempty"` Step *ChatStep `json:"step,omitempty"` Usage *ChatUsage `json:"usage,omitempty"` + // Client is the sending device's label on a user frame (ChatEventUser), so a + // transcript can say who sent the message. It is empty on assistant frames. + Client string `json:"client,omitempty"` } // ChatStep is a progress marker for the current step of a turn. @@ -285,6 +308,15 @@ type ChatPermissionFrame struct { Metadata map[string]any `json:"metadata,omitempty"` Source *ChatPermissionSource `json:"source,omitempty"` Message string `json:"message,omitempty"` + // Resolved, Decision and ResolvedBy report the shared, exactly-once outcome + // of a request any client may answer: once the first answer is recorded the + // server pushes the same frame back to every watching client with Resolved + // set, the Decision it recorded and the label of the client that gave it, so + // their cards clear and show the outcome instead of offering a stale choice. + // They are empty on a still-pending request. + Resolved bool `json:"resolved,omitempty"` + Decision string `json:"decision,omitempty"` + ResolvedBy string `json:"resolved_by,omitempty"` } // ChatPermissionSource identifies what raised a permission request, matching the @@ -298,10 +330,13 @@ type ChatPermissionSource struct { // ChatReplyRequest is the chat_reply request body: the phone's decision on a // pending permission request, mirroring -// POST /api/session/{id}/permission/{requestID}/reply. +// POST /api/session/{id}/permission/{requestID}/reply. Client is the answering +// device's label, recorded with the resolution so every other client can see +// which device answered. type ChatReplyRequest struct { SessionID string `json:"session_id"` RequestID string `json:"request_id"` Decision string `json:"decision"` Message string `json:"message,omitempty"` + Client string `json:"client,omitempty"` } diff --git a/internal/protocol/chat_test.go b/internal/protocol/chat_test.go index 15f27d29..09ad04be 100644 --- a/internal/protocol/chat_test.go +++ b/internal/protocol/chat_test.go @@ -27,7 +27,13 @@ func chatSamples() []struct { {"create", ChatCreateRequest{Title: "demo", Directory: "/work"}}, {"adopt", ChatAdoptRequest{SessionID: "ses_1"}}, {"query", ChatQuery{SessionID: "ses_1", Limit: 50}}, - {"prompt", ChatPromptRequest{SessionID: "ses_1", Text: "hello", Model: "m", Agent: "build", Files: []string{"file:///tmp/a.png"}}}, + {"prompt", ChatPromptRequest{SessionID: "ses_1", Text: "hello", Model: "m", Agent: "build", Files: []string{"file:///tmp/a.png"}, Client: "Pixel 9 Pro XL"}}, + {"prompt_queued_ack", Message{Type: ChatPrompt, ID: "a1", ChatQueued: true}}, + {"subscribe", ChatQuery{SessionID: "ses_1"}}, + {"event_user", ChatEventFrame{ + SessionID: "ses_1", MessageID: "usr_1", Kind: ChatEventUser, Client: "Pixel 10 Pro Fold", + Part: &ChatPart{Type: ChatPartText, ID: "usr", Text: "from the fold"}, + }}, {"message", ChatMessage{ ID: "msg_1", SessionID: "ses_1", Role: ChatRoleAssistant, Model: "m", Agent: "build", CreatedAt: 1792112366711, Parts: []ChatPart{ @@ -66,7 +72,11 @@ func chatSamples() []struct { Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"}, Message: "wants to run a command", }}, - {"reply", ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionOnce, Message: "ok"}}, + {"permission_resolved", ChatPermissionFrame{ + SessionID: "ses_1", RequestID: "per_1", Action: "bash", + Resolved: true, Decision: ChatDecisionOnce, ResolvedBy: "Pixel 9 Pro XL", + }}, + {"reply", ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionOnce, Message: "ok", Client: "Pixel 9 Pro XL"}}, } } diff --git a/internal/protocol/message.go b/internal/protocol/message.go index c9165a19..74065770 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -170,6 +170,12 @@ type Message struct { // requests themselves ride on ChatQuery (the session id), matching // chat_messages/chat_interrupt. ChatClose *ChatCloseResult `json:"chat_close,omitempty"` + // ChatSubscribe attaches this connection to one session's shared stream; the + // body names the session like ChatQuery. A chat_prompt response sets + // ChatQueued when the prompt had to wait for an in-flight turn and was + // accepted into the session's queue instead of being sent immediately. + ChatSubscribe *ChatQuery `json:"chat_subscribe,omitempty"` + ChatQueued bool `json:"chat_queued,omitempty"` // ChatDirectories carries the operator's directory choices on a // chat_directories response (home first, then recent operator-session // directories, deduplicated and bounded). Additive/omitempty so older peers diff --git a/internal/server/chat.go b/internal/server/chat.go index f46082fb..1601fbfc 100644 --- a/internal/server/chat.go +++ b/internal/server/chat.go @@ -55,10 +55,10 @@ type operatorRegistry interface { ReopenOperatorSession(ctx context.Context, sessionID string) error } -// chatClientToken returns an unguessable per-connection identity. It attributes -// a session claim so two clients on the same server cannot silently write the -// same conversation; a fresh token per connection means a reconnected client is -// a new writer and must re-claim. +// chatClientToken returns an unguessable per-connection identity. Its only role +// is to key a connection's chat-room subscriptions and to exclude the sender from +// its own fan-out; it carries no ownership. A fresh token per connection means a +// reconnected client is a new identity and simply reattaches. func chatClientToken() string { var b [8]byte if _, err := rand.Read(b[:]); err != nil { @@ -77,6 +77,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker case protocol.ChatPrompt: handleChatPrompt(ctx, request, broker, hub, registry, clientID, write) return true + case protocol.ChatSubscribe: + handleChatSubscribe(request, broker, hub, clientID, write) + return true case protocol.ChatMessages: handleChatMessages(ctx, request, broker, hub, write) return true @@ -87,7 +90,7 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker handleChatSimple(ctx, request, broker, hub, write) return true case protocol.ChatSessions: - handleChatSessions(ctx, request, broker, hub, registry, clientID, write) + handleChatSessions(ctx, request, broker, hub, registry, write) return true case protocol.ChatCreate: handleChatCreate(ctx, request, broker, registry, write) diff --git a/internal/server/chat_claims.go b/internal/server/chat_claims.go deleted file mode 100644 index bd97b6ef..00000000 --- a/internal/server/chat_claims.go +++ /dev/null @@ -1,76 +0,0 @@ -package server - -// claim reserves sessionID for clientID. It reports true when the session is -// free or already held by the same client (so a client may re-prompt its own -// session) and false when another client holds it. The claim map is bounded by -// chatMaxTurns with oldest-eviction so a stuck client cannot grow it without -// limit. -func (h *chatHub) claim(sessionID, clientID string) bool { - if sessionID == "" || clientID == "" { - return false - } - h.mu.Lock() - defer h.mu.Unlock() - if h.claims == nil { - h.claims = map[string]string{} - } - if holder, ok := h.claims[sessionID]; ok { - return holder == clientID - } - h.evictClaimsLocked() - h.claims[sessionID] = clientID - h.claimOrder = append(h.claimOrder, sessionID) - return true -} - -// release drops the same client's claim on sessionID; a claim held by a -// different client is left untouched so a stale release cannot free a live one. -func (h *chatHub) release(sessionID, clientID string) { - h.mu.Lock() - defer h.mu.Unlock() - if holder, ok := h.claims[sessionID]; !ok || holder != clientID { - return - } - delete(h.claims, sessionID) - for i, id := range h.claimOrder { - if id == sessionID { - h.claimOrder = append(h.claimOrder[:i], h.claimOrder[i+1:]...) - break - } - } -} - -// busyForOther reports whether another client currently holds sessionID. -func (h *chatHub) busyForOther(sessionID, clientID string) bool { - h.mu.Lock() - defer h.mu.Unlock() - holder, ok := h.claims[sessionID] - return ok && holder != clientID -} - -// active reports whether any client currently holds sessionID, so a turn may be -// running. chat_close uses it to decide whether to interrupt; the claim is -// released when the turn's stream drains, so it is never left set for a settled -// session. -func (h *chatHub) active(sessionID string) bool { - h.mu.Lock() - defer h.mu.Unlock() - _, ok := h.claims[sessionID] - return ok -} - -// evictClaimsLocked drops the oldest claim when the cap is reached, keeping the -// claim map bounded like the retained turns. Callers must hold h.mu. -func (h *chatHub) evictClaimsLocked() { - if len(h.claims) < chatMaxTurns { - return - } - for len(h.claimOrder) > 0 { - oldest := h.claimOrder[0] - h.claimOrder = h.claimOrder[1:] - if _, ok := h.claims[oldest]; ok { - delete(h.claims, oldest) - return - } - } -} diff --git a/internal/server/chat_close.go b/internal/server/chat_close.go index 87a7933b..822615bb 100644 --- a/internal/server/chat_close.go +++ b/internal/server/chat_close.go @@ -42,8 +42,9 @@ func handleChatClose(ctx context.Context, request protocol.Message, broker chatB } // Stop a running turn first. A failed interrupt is surfaced and the close is // not recorded, so the operator is never told a live turn was stopped when it - // was not. - interrupted := hub.active(sessionID) + // was not. The flag comes from the session's room (a turn in flight), so an + // idle session is never interrupted. + interrupted := hub.turnInFlight(sessionID) if interrupted { if err := broker.Interrupt(ctx, sessionID); err != nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " could not be stopped: " + err.Error()}) diff --git a/internal/server/chat_commands.go b/internal/server/chat_commands.go index 58600e58..2d160373 100644 --- a/internal/server/chat_commands.go +++ b/internal/server/chat_commands.go @@ -68,9 +68,27 @@ func handleChatSimple(ctx context.Context, request protocol.Message, broker chat _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid permission decision is required"}) return } + // A pending approval is shared and exactly-once: the first answer wins and is + // recorded with the client that gave it, and a later answer is refused as + // already answered rather than reaching the agent twice. + label := sanitizeChatClientLabel(reply.Client) + if hub != nil { + if prior, ok := hub.reservePermission(reply.SessionID, reply.RequestID, label); !ok { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: permissionRefusal(prior, reply.RequestID)}) + return + } + } if err := broker.Reply(ctx, *reply); err != nil { + if hub != nil { + hub.releasePermission(reply.SessionID, reply.RequestID) + } _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) return } _ = write(protocol.Message{Type: protocol.ChatReply, ID: request.ID}) + if hub != nil { + // Push the resolution to every client watching the session so each card + // clears and shows the outcome and which device answered. + hub.confirmPermission(reply.SessionID, reply.RequestID, label, reply.Decision) + } } diff --git a/internal/server/chat_hub.go b/internal/server/chat_hub.go index f265b56f..b04105b7 100644 --- a/internal/server/chat_hub.go +++ b/internal/server/chat_hub.go @@ -1,7 +1,9 @@ package server import ( + "context" "log" + "strconv" "sync" "time" @@ -22,15 +24,18 @@ const chatMaxTurns = 128 // chatHub retains the accumulated turn state per session, independently of any // single connection, so a reconnecting client can re-sync what it missed. State // is keyed by session and then by message id (a session holds many turns), and -// is capped at chatRetainedLimit. +// is capped at chatRetainedLimit. It also owns the per-session live rooms: the +// one broker stream, the prompt queue and the fan-out to every attached client. type chatHub struct { - mu sync.Mutex - turns map[string]*chatTurn - now func() time.Time - // claims maps a session to the client currently writing it so a second - // client is rejected; claimOrder bounds the map like chatMaxTurns. - claims map[string]string - claimOrder []string + mu sync.Mutex + turns map[string]*chatTurn + rooms map[string]*chatRoom + baseCtx context.Context + registry operatorRegistry + now func() time.Time + // userSeq is a monotonic source of ids for the user turns the server echoes + // to the other clients, so each retained user message has a stable id. + userSeq int } // chatPart is the retained form of one part. Text and reasoning deltas append to @@ -40,12 +45,16 @@ type chatPart struct { text []byte } -// chatMessage is one retained assistant turn. Its parts keep the exact ids the -// supporting chat_event frames carried, so a resume preserves attribution. +// chatMessage is one retained turn. Its parts keep the exact ids the supporting +// chat_event frames carried, so a resume preserves attribution. Role and client +// are carried for a user turn the server echoed (a prompt another client sent), +// so a resumed transcript still says who sent it. type chatMessage struct { - id string - order []string - parts map[string]*chatPart + id string + role string + client string + order []string + parts map[string]*chatPart } type chatTurn struct { @@ -62,10 +71,33 @@ type chatTurn struct { // bounds it to chatPermissionRetainedLimit. permissions map[string]struct{} permissionOrder []string + // resolutions records the shared exactly-once answers to permission requests, + // keyed by request id, so a second answer is refused and the recorded outcome + // survives the clients that gave it; resolutionOrder bounds it to + // chatPermissionRetainedLimit like the dedup set above. + resolutions map[string]*chatResolution + resolutionOrder []string +} + +// chatResolution is the shared answer to one permission request. answered is +// false while the first answer is still being delivered to the agent, so a +// concurrent second answer is refused without ever reaching the agent twice. +type chatResolution struct { + client string + decision string + answered bool } func newChatHub() *chatHub { - return &chatHub{turns: map[string]*chatTurn{}, now: time.Now} + return &chatHub{turns: map[string]*chatTurn{}, rooms: map[string]*chatRoom{}, baseCtx: context.Background(), now: time.Now} +} + +// nextUserMessageID mints a stable id for one echoed user turn. +func (h *chatHub) nextUserMessageID() string { + h.mu.Lock() + defer h.mu.Unlock() + h.userSeq++ + return "usr_" + strconv.Itoa(h.userSeq) } func (h *chatHub) clock() time.Time { @@ -100,11 +132,33 @@ func (h *chatHub) apply(frame protocol.ChatEventFrame) { } message := turn.messages[frame.MessageID] if message == nil { - message = &chatMessage{id: frame.MessageID, parts: map[string]*chatPart{}} + role := protocol.ChatRoleAssistant + client := "" + if frame.Kind == protocol.ChatEventUser { + role = protocol.ChatRoleUser + client = frame.Client + } + message = &chatMessage{id: frame.MessageID, role: role, client: client, parts: map[string]*chatPart{}} turn.order = append(turn.order, frame.MessageID) turn.messages[frame.MessageID] = message + } else if message.client == "" && frame.Kind == protocol.ChatEventUser { + message.client = frame.Client } switch frame.Kind { + case protocol.ChatEventUser: + if frame.Part == nil || frame.Part.ID == "" || frame.Part.Text == "" || turn.overflow { + return + } + if !turn.retain(len(frame.Part.Text)) { + return + } + part, ok := message.parts[frame.Part.ID] + if !ok { + part = &chatPart{part: protocol.ChatPart{Type: protocol.ChatPartText, ID: frame.Part.ID}} + message.order = append(message.order, frame.Part.ID) + message.parts[frame.Part.ID] = part + } + part.text = append(part.text, frame.Part.Text...) case protocol.ChatEventText, protocol.ChatEventReasoning: id := "" if frame.Part != nil { @@ -255,6 +309,10 @@ func (h *chatHub) snapshot(sessionID string) []protocol.ChatMessage { continue } out := protocol.ChatMessage{ID: id, SessionID: sessionID, Role: protocol.ChatRoleAssistant} + if message.role != "" { + out.Role = message.role + } + out.Client = message.client for _, partID := range message.order { if part, ok := message.parts[partID]; ok { piece := part.part diff --git a/internal/server/chat_multiclient_test.go b/internal/server/chat_multiclient_test.go new file mode 100644 index 00000000..43d373a5 --- /dev/null +++ b/internal/server/chat_multiclient_test.go @@ -0,0 +1,472 @@ +package server + +import ( + "context" + "errors" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/coder/websocket" + "github.com/coder/websocket/wsjson" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// channelChat is a broker whose stream is driven frame-by-frame from a channel, +// so a test can hold a turn in flight and prove prompt serialisation, fan-out and +// exactly-once approval behaviour without a real OpenCode service. +type channelChat struct { + mu sync.Mutex + prompts []string + perm []protocol.ChatPermissionFrame + replies []protocol.ChatReplyRequest + frames chan protocol.ChatEventFrame + ready chan struct{} + once sync.Once + // promptErrAt, when nonzero, is the 1-based index of the Prompt call that + // fails, so a test can prove a broker failure is reported to the client that + // sent the prompt. + promptErrAt int +} + +func newChannelChat() *channelChat { + return &channelChat{frames: make(chan protocol.ChatEventFrame, 32), ready: make(chan struct{})} +} + +func (c *channelChat) Prompt(_ context.Context, _, text string) error { + c.mu.Lock() + c.prompts = append(c.prompts, text) + fail := c.promptErrAt != 0 && len(c.prompts) == c.promptErrAt + c.mu.Unlock() + if fail { + return errors.New("broker rejected the prompt") + } + return nil +} + +func (c *channelChat) Stream(ctx context.Context, _ string, ready func(), emit func(protocol.ChatEventFrame) error) error { + c.once.Do(func() { + close(c.ready) + if ready != nil { + ready() + } + }) + for { + select { + case <-ctx.Done(): + return ctx.Err() + case frame := <-c.frames: + if err := emit(frame); err != nil { + return err + } + } + } +} + +func (c *channelChat) Interrupt(context.Context, string) error { return nil } + +func (c *channelChat) Messages(context.Context, string, int) ([]protocol.ChatMessage, error) { + return nil, nil +} + +func (c *channelChat) Sessions(context.Context) ([]protocol.ChatSession, error) { return nil, nil } + +func (c *channelChat) Create(_ context.Context, title, directory string) (protocol.ChatSession, error) { + return protocol.ChatSession{ID: "ses_created", Title: title, Directory: directory}, nil +} + +func (c *channelChat) Session(context.Context, string) (protocol.ChatSession, bool, error) { + return protocol.ChatSession{}, false, nil +} + +func (c *channelChat) Permissions(context.Context, string) ([]protocol.ChatPermissionFrame, error) { + c.mu.Lock() + defer c.mu.Unlock() + return append([]protocol.ChatPermissionFrame(nil), c.perm...), nil +} + +func (c *channelChat) Reply(_ context.Context, request protocol.ChatReplyRequest) error { + c.mu.Lock() + c.replies = append(c.replies, request) + c.mu.Unlock() + return nil +} + +func (c *channelChat) push(frame protocol.ChatEventFrame) { + c.frames <- frame +} + +func (c *channelChat) promptCount() int { + c.mu.Lock() + defer c.mu.Unlock() + return len(c.prompts) +} + +func (c *channelChat) promptTexts() []string { + c.mu.Lock() + defer c.mu.Unlock() + return append([]string(nil), c.prompts...) +} + +func (c *channelChat) replyCount() int { + c.mu.Lock() + defer c.mu.Unlock() + return len(c.replies) +} + +// dialChatServer starts one server and dials n connections, returning the server +// so a test can reconnect a dropped client to the same hub. +func dialChatServer(t *testing.T, options Options, n int) (context.Context, context.CancelFunc, *httptest.Server, []*websocket.Conn) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + srv := httptest.NewServer(HandlerWithOptions(ctx, options)) + t.Cleanup(func() { srv.Close(); cancel() }) + conns := make([]*websocket.Conn, 0, n) + for i := 0; i < n; i++ { + conns = append(conns, dialChatConn(t, ctx, srv)) + } + return ctx, cancel, srv, conns +} + +func dialChatConn(t *testing.T, ctx context.Context, srv *httptest.Server) *websocket.Conn { + t.Helper() + conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { conn.CloseNow() }) + return conn +} + +// readUntil reads messages until one of type want arrives, failing on a server +// error frame; interleaved push frames are skipped. +func readUntil(t *testing.T, ctx context.Context, conn *websocket.Conn, want string) protocol.Message { + t.Helper() + for { + var message protocol.Message + if err := wsjson.Read(ctx, conn, &message); err != nil { + t.Fatalf("read (waiting for %s): %v", want, err) + } + if message.Type == protocol.Error { + t.Fatalf("server error frame while waiting for %s: %s", want, message.Error) + } + if message.Type == want { + return message + } + } +} + +// nextEvent reads the next chat_event frame strictly, so a test can assert the +// order of the turn's frames. +func nextEvent(t *testing.T, ctx context.Context, conn *websocket.Conn) protocol.ChatEventFrame { + t.Helper() + for { + var message protocol.Message + if err := wsjson.Read(ctx, conn, &message); err != nil { + t.Fatalf("read event: %v", err) + } + if message.Type == protocol.Error { + t.Fatalf("server error frame: %s", message.Error) + } + if message.Type == protocol.ChatEvent && message.ChatEvent != nil { + return *message.ChatEvent + } + } +} + +// nextPermission reads the next chat_permission frame for requestID. +func nextPermission(t *testing.T, ctx context.Context, conn *websocket.Conn, requestID string) protocol.ChatPermissionFrame { + t.Helper() + for { + var message protocol.Message + if err := wsjson.Read(ctx, conn, &message); err != nil { + t.Fatalf("read permission: %v", err) + } + if message.Type == protocol.Error { + t.Fatalf("server error frame: %s", message.Error) + } + if message.Type == protocol.ChatPermission && message.ChatPermission != nil && message.ChatPermission.RequestID == requestID { + return *message.ChatPermission + } + } +} + +func writeChat(t *testing.T, ctx context.Context, conn *websocket.Conn, message protocol.Message) { + t.Helper() + if err := wsjson.Write(ctx, conn, message); err != nil { + t.Fatal(err) + } +} + +// TestChatFanoutToSeveralClients is the multi-client acceptance test: a prompt +// from one client is accepted, its user turn is pushed live to the other client +// attributed to the sending device, and the turn's streaming frames reach every +// watching client, not only the one that prompted. +func TestChatFanoutToSeveralClients(t *testing.T) { + broker := newChannelChat() + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // The tablet watches the session before anything is sent. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatSubscribe, ID: "s1", ChatSubscribe: &protocol.ChatQuery{SessionID: "ses_1"}}) + readUntil(t, ctx, tablet, protocol.ChatSubscribe) + + // The phone prompts. Its ack is not a queue acknowledgement. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "from the phone", Client: "Pixel 9"}}) + ack := readUntil(t, ctx, phone, protocol.ChatPrompt) + if ack.ID != "p1" || ack.ChatQueued { + t.Fatalf("phone prompt ack = %+v, want accepted (not queued)", ack) + } + + // The tablet sees the phone's message, attributed to the phone. + userFrame := nextEvent(t, ctx, tablet) + if userFrame.Kind != protocol.ChatEventUser || userFrame.Client != "Pixel 9" || userFrame.Part == nil || userFrame.Part.Text != "from the phone" { + t.Fatalf("tablet user frame = %+v, want the phone's message attributed to Pixel 9", userFrame) + } + + // The turn's streaming output reaches both clients in order. + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: "hel", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: "lo", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}}) + + for _, client := range []struct { + name string + conn *websocket.Conn + }{{"phone", phone}, {"tablet", tablet}} { + var text strings.Builder + for i := 0; i < 2; i++ { + frame := nextEvent(t, ctx, client.conn) + if frame.Kind != protocol.ChatEventText { + t.Fatalf("%s frame %d = %+v, want text", client.name, i, frame) + } + text.WriteString(frame.Delta) + } + if text.String() != "hello" { + t.Fatalf("%s saw %q, want the streamed turn output", client.name, text.String()) + } + if end := nextEvent(t, ctx, client.conn); end.Kind != protocol.ChatEventStep || end.Step == nil || end.Step.Status != protocol.ChatStepEnded { + t.Fatalf("%s step frame = %+v, want ended", client.name, end) + } + } +} + +// TestChatPromptSerialisedPerSession pins that two prompts for one session never +// interleave: the second is accepted as queued and only posted once the first +// turn ends. +func TestChatPromptSerialisedPerSession(t *testing.T) { + broker := newChannelChat() + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "one"}}) + if ack := readUntil(t, ctx, phone, protocol.ChatPrompt); ack.ChatQueued { + t.Fatalf("first prompt should start immediately: %+v", ack) + } + + // The tablet's prompt while the turn is in flight is queued, and it is told so. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatPrompt, ID: "p2", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "two"}}) + if ack := readUntil(t, ctx, tablet, protocol.ChatPrompt); !ack.ChatQueued { + t.Fatalf("second prompt should be acknowledged as queued: %+v", ack) + } + if broker.promptCount() != 1 { + t.Fatalf("prompts forwarded = %d, want 1 while the first turn is in flight", broker.promptCount()) + } + + // End the first turn; the queued prompt is then posted. + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}}) + deadline := time.Now().Add(3 * time.Second) + for broker.promptCount() < 2 { + if time.Now().After(deadline) { + t.Fatalf("queued prompt was never posted: %v", broker.promptTexts()) + } + time.Sleep(5 * time.Millisecond) + } + if got := broker.promptTexts(); len(got) != 2 || got[0] != "one" || got[1] != "two" { + t.Fatalf("prompts = %v, want [one two] in order", got) + } +} + +// TestChatApprovalFirstAnswerWins is the exactly-once acceptance test: a pending +// approval is shared, the first answer is recorded with the client that gave it +// and broadcast to every client, and a later answer is refused. +func TestChatApprovalFirstAnswerWins(t *testing.T) { + broker := newChannelChat() + broker.perm = []protocol.ChatPermissionFrame{{SessionID: "ses_1", RequestID: "req_1", Action: "bash", Resources: []string{"rm -rf /tmp"}}} + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // A turn starts so the poller runs and pushes the pending request. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "run it"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + + pending := nextPermission(t, ctx, phone, "req_1") + if pending.Resolved { + t.Fatalf("request already marked resolved: %+v", pending) + } + + // A second client attaches and is replayed the still-pending request, so its + // card is answerable too. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatSubscribe, ID: "s1", ChatSubscribe: &protocol.ChatQuery{SessionID: "ses_1"}}) + readUntil(t, ctx, tablet, protocol.ChatSubscribe) + replay := nextPermission(t, ctx, tablet, "req_1") + if replay.Resolved || replay.Action != "bash" { + t.Fatalf("replayed permission = %+v, want the pending request", replay) + } + + // The phone answers first. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatReply, ID: "a1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce, Client: "Pixel 9"}}) + readUntil(t, ctx, phone, protocol.ChatReply) + + // Both clients see the resolution, with the answering device recorded. + for _, client := range []struct { + name string + conn *websocket.Conn + }{{"phone", phone}, {"tablet", tablet}} { + resolution := nextPermission(t, ctx, client.conn, "req_1") + if !resolution.Resolved || resolution.Decision != protocol.ChatDecisionOnce || resolution.ResolvedBy != "Pixel 9" { + t.Fatalf("%s resolution = %+v, want resolved once by Pixel 9", client.name, resolution) + } + } + + // The tablet's later answer is refused, and it never reaches the agent. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatReply, ID: "a2", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionAlways, Client: "Pixel 10 Pro Fold"}}) + var refused protocol.Message + if err := wsjson.Read(ctx, tablet, &refused); err != nil { + t.Fatal(err) + } + if refused.Type != protocol.Error || !strings.Contains(refused.Error, "already answered by Pixel 9") { + t.Fatalf("second answer was not refused as already answered: %+v", refused) + } + if broker.replyCount() != 1 { + t.Fatalf("broker replies = %d, want the agent to receive exactly one answer", broker.replyCount()) + } +} + +// TestChatSubscribeWireShape pins the exact wire body the Android app sends for +// chat_subscribe (ChatProtocol.subscribeRequest): the session id travels in the +// chat_subscribe field, not chat_query. The handler once read chat_query, so the +// unit tests passed while the shipped app's subscribe was silently rejected; this +// test writes the raw JSON, attaches the connection and proves a prompt from +// another client reaches it. +func TestChatSubscribeWireShape(t *testing.T) { + broker := newChannelChat() + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, watch := conns[0], conns[1] + + if err := watch.Write(ctx, websocket.MessageText, []byte(`{"type":"chat_subscribe","id":"s1","chat_subscribe":{"session_id":"ses_1"}}`)); err != nil { + t.Fatal(err) + } + if ack := readUntil(t, ctx, watch, protocol.ChatSubscribe); ack.ID != "s1" { + t.Fatalf("subscribe ack = %+v, want id s1", ack) + } + + // The watcher is attached: another client's prompt is fanned out to it. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "ping", Client: "Pixel 9"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + frame := nextEvent(t, ctx, watch) + if frame.Kind != protocol.ChatEventUser || frame.Client != "Pixel 9" || frame.Part == nil || frame.Part.Text != "ping" { + t.Fatalf("watcher frame = %+v, want the phone's message (subscribe did not attach)", frame) + } +} + +// TestChatQueuedPromptFailureSurfaced pins that a prompt accepted as queued whose +// delivery to the agent later fails is reported to the client that sent it, +// instead of leaving its composer showing "Queued" with no error. +func TestChatQueuedPromptFailureSurfaced(t *testing.T) { + broker := newChannelChat() + broker.promptErrAt = 2 // the queued (second) prompt fails to reach the agent + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // The phone's prompt starts a turn held in flight. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "one"}}) + if ack := readUntil(t, ctx, phone, protocol.ChatPrompt); ack.ChatQueued { + t.Fatalf("first prompt should start immediately: %+v", ack) + } + + // The tablet's prompt is accepted as queued and acknowledged as such. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatPrompt, ID: "p2", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "two"}}) + if ack := readUntil(t, ctx, tablet, protocol.ChatPrompt); !ack.ChatQueued { + t.Fatalf("second prompt should be acknowledged as queued: %+v", ack) + } + + // End the first turn; the queued prompt is posted and the broker rejects it. + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}}) + + for { + var message protocol.Message + if err := wsjson.Read(ctx, tablet, &message); err != nil { + t.Fatalf("read (waiting for the queued prompt failure): %v", err) + } + if message.Type != protocol.Error { + continue + } + if message.ID != "p2" || !strings.Contains(message.Error, "broker rejected the prompt") { + t.Fatalf("queued prompt failure = %+v, want an error for p2 naming the broker failure", message) + } + break + } +} + +// TestChatPendingApprovalsAllReplayed pins that every unresolved approval request +// a room holds is replayed to a client that attaches afterwards, not only the +// most recent one, so both cards are answerable on the late client. +func TestChatPendingApprovalsAllReplayed(t *testing.T) { + broker := newChannelChat() + broker.perm = []protocol.ChatPermissionFrame{ + {SessionID: "ses_1", RequestID: "req_1", Action: "bash", Resources: []string{"rm -rf /tmp"}}, + {SessionID: "ses_1", RequestID: "req_2", Action: "write", Resources: []string{"/etc/hosts"}}, + } + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // A turn starts so the poller pushes both pending requests to the phone. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "run them"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + nextPermission(t, ctx, phone, "req_1") + nextPermission(t, ctx, phone, "req_2") + + // A client that attaches afterwards is replayed both. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatSubscribe, ID: "s1", ChatSubscribe: &protocol.ChatQuery{SessionID: "ses_1"}}) + readUntil(t, ctx, tablet, protocol.ChatSubscribe) + first := nextPermission(t, ctx, tablet, "req_1") + second := nextPermission(t, ctx, tablet, "req_2") + if first.Resolved || second.Resolved || first.Action != "bash" || second.Action != "write" { + t.Fatalf("replayed permissions = %+v / %+v, want both still-pending requests", first, second) + } +} + +// TestChatResyncAfterReconnect is the resync acceptance test: a client that drops +// and reconnects re-syncs the whole conversation from retained state, including +// the user turn and who sent it. +func TestChatResyncAfterReconnect(t *testing.T) { + broker := scriptedChat() + ctx, _, srv, conns := dialChatServer(t, Options{Chat: broker}, 1) + phone := conns[0] + + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi", Client: "Pixel 9"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + readChatTurn(t, ctx, phone) + + // The phone's socket drops. + phone.CloseNow() + + // A fresh connection re-syncs from retained state. + reconnected := dialChatConn(t, ctx, srv) + writeChat(t, ctx, reconnected, protocol.Message{Type: protocol.ChatMessages, ID: "m1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}) + response := readUntil(t, ctx, reconnected, protocol.ChatMessages) + if len(response.ChatMessages) != 2 { + t.Fatalf("resync returned %d messages, want user+assistant: %+v", len(response.ChatMessages), response.ChatMessages) + } + user := response.ChatMessages[0] + if user.Role != protocol.ChatRoleUser || user.Client != "Pixel 9" || len(user.Parts) != 1 || user.Parts[0].Text != "hi" { + t.Fatalf("resynced user turn = %+v", user) + } + assistant := response.ChatMessages[1] + if assistant.Role != protocol.ChatRoleAssistant || assistant.ID != "msg_1" { + t.Fatalf("resynced assistant turn = %+v", assistant) + } +} diff --git a/internal/server/chat_permissions.go b/internal/server/chat_permissions.go index 28a2b72b..32d006ba 100644 --- a/internal/server/chat_permissions.go +++ b/internal/server/chat_permissions.go @@ -1,5 +1,7 @@ package server +import "git.a-wan.net/alan/pipelines/internal/protocol" + // chatPermissionRetainedLimit bounds the dedup set of already-pushed permission // request ids one session retains, so a long turn cannot grow it without limit. const chatPermissionRetainedLimit = 256 @@ -31,24 +33,83 @@ func (h *chatHub) seenPermission(sessionID, requestID string) bool { return true } -// forgetPermission releases a request id reserved by seenPermission when its -// frame could not be written, so a later poll re-pushes it instead of the id -// staying "seen" while the phone never received the request. -func (h *chatHub) forgetPermission(sessionID, requestID string) { +// reservePermission claims the shared right to answer requestID for client. It +// returns true when this caller is the first to answer (the only caller allowed +// to reach the agent), and false with the recorded resolution when the request is +// already answered or is already being answered, so a later answer is refused +// rather than delivered twice. The reservation is bounded like the dedup set. +func (h *chatHub) reservePermission(sessionID, requestID, client string) (*chatResolution, bool) { if sessionID == "" || requestID == "" { - return + return nil, false } + h.mu.Lock() + defer h.mu.Unlock() + turn := h.turnLocked(sessionID) + if turn.resolutions == nil { + turn.resolutions = map[string]*chatResolution{} + } + if prior, ok := turn.resolutions[requestID]; ok { + return prior, false + } + turn.resolutions[requestID] = &chatResolution{client: client} + turn.resolutionOrder = append(turn.resolutionOrder, requestID) + if len(turn.resolutionOrder) > chatPermissionRetainedLimit { + oldest := turn.resolutionOrder[0] + turn.resolutionOrder = turn.resolutionOrder[1:] + delete(turn.resolutions, oldest) + } + return nil, true +} + +// releasePermission drops a reservation whose answer never reached the agent, so +// a later attempt can win instead of the request staying permanently refused. +func (h *chatHub) releasePermission(sessionID, requestID string) { h.mu.Lock() defer h.mu.Unlock() turn := h.turns[sessionID] if turn == nil { return } - delete(turn.permissions, requestID) - for i, id := range turn.permissionOrder { + delete(turn.resolutions, requestID) + for i, id := range turn.resolutionOrder { if id == requestID { - turn.permissionOrder = append(turn.permissionOrder[:i], turn.permissionOrder[i+1:]...) + turn.resolutionOrder = append(turn.resolutionOrder[:i], turn.resolutionOrder[i+1:]...) break } } } + +// confirmPermission records the delivered answer and pushes the resolution to +// every watching client, so each one's approval card clears and shows the +// outcome and which client gave it. +func (h *chatHub) confirmPermission(sessionID, requestID, client, decision string) { + h.mu.Lock() + if turn := h.turns[sessionID]; turn != nil { + if resolution, ok := turn.resolutions[requestID]; ok { + resolution.decision = decision + resolution.answered = true + } + } + frame := protocol.ChatPermissionFrame{SessionID: sessionID, RequestID: requestID} + var targets []*chatSub + if room := h.rooms[sessionID]; room != nil { + for i := range room.pending { + if room.pending[i].RequestID == requestID { + frame = room.pending[i] + room.pending = append(room.pending[:i], room.pending[i+1:]...) + break + } + } + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + h.mu.Unlock() + frame.Resolved = true + frame.Decision = decision + frame.ResolvedBy = client + msg := protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame} + for _, sub := range targets { + sub.send(msg) + } +} diff --git a/internal/server/chat_room.go b/internal/server/chat_room.go new file mode 100644 index 00000000..9ae2450c --- /dev/null +++ b/internal/server/chat_room.go @@ -0,0 +1,675 @@ +package server + +import ( + "context" + "errors" + "fmt" + "log" + "strings" + "sync" + "time" + + "git.a-wan.net/alan/pipelines/internal/opencode" + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// The chat room is one session's shared live channel. Many clients attach to it +// (the operator's phone, tablet and terminal) and every frame any turn produces +// is fanned out to all of them, so each device sees the same conversation +// including the other devices' prompts and the turn's streaming output. The room +// owns the session's one broker stream and its one prompt queue, so a session is +// never read-only for a client and two turns never interleave: a prompt that +// arrives while a turn is in flight is queued (bounded) and its client is told so +// in the ack. +const ( + // chatRoomSubscriberBuffer bounds one attached client's pending frames. A + // client that falls this far behind is dropped rather than blocking the turn + // or the other clients; it re-syncs from history when it reattaches. + chatRoomSubscriberBuffer = 64 + // chatRoomQueueLimit bounds the prompts one session may hold while a turn is + // in flight. A prompt that would exceed it is refused with a visible error + // instead of being silently dropped. + chatRoomQueueLimit = 8 + // chatClientLabelMax bounds the human-readable client label the server stores + // and echoes, so a long device name cannot grow a frame without limit. + chatClientLabelMax = 48 + // chatClientLabelFallback labels a prompt whose sender did not name itself, so + // a transcript always has something to attribute the message to. + chatClientLabelFallback = "Another device" + // chatRoomPendingLimit bounds how many unresolved approval requests one room + // retains for replay to a client that attaches after they were raised, so a + // long turn cannot grow the replay state without limit. + chatRoomPendingLimit = 16 +) + +// chatSub is one client's attachment to a session's shared stream. Frames reach +// it through a dedicated writer goroutine so a slow or broken client never stalls +// the turn or the other subscribers; the buffered channel bounds how far behind +// it may fall. +type chatSub struct { + hub *chatHub + room *chatRoom + clientID string + label string + ch chan protocol.Message + done chan struct{} + once sync.Once + write func(protocol.Message) error +} + +func (s *chatSub) run() { + for { + select { + case <-s.done: + return + case msg := <-s.ch: + if err := s.write(msg); err != nil { + s.close() + return + } + } + } +} + +func (s *chatSub) send(msg protocol.Message) { + select { + case <-s.done: + return + default: + } + select { + case s.ch <- msg: + default: + // The client is not draining: drop it rather than block the fan-out. Its + // next attach re-syncs from history. + s.close() + } +} + +// close detaches the subscription and stops its writer goroutine exactly once. +func (s *chatSub) close() { + s.once.Do(func() { + close(s.done) + s.hub.detach(s.room.sessionID, s) + }) +} + +// chatQueuedPrompt is one prompt waiting for the session's in-flight turn to +// finish. acked marks a prompt the handler already acknowledged as queued, so the +// turn runner does not send a second (success) acknowledgement for the same +// request id; write is kept either way so a later broker failure is still +// reported to the client that sent it. +type chatQueuedPrompt struct { + text string + requestID string + write func(protocol.Message) error + acked bool +} + +// chatRoom is one session's shared live channel. Every field is guarded by the +// owning chatHub's mutex. +type chatRoom struct { + sessionID string + broker chatBroker + ctx context.Context + cancel context.CancelFunc + subs map[string]*chatSub + queue []*chatQueuedPrompt + running bool + streaming bool + // buffering holds the turn's frames until the prompting client's ack has been + // written, so the ack always precedes the frames it acknowledges. It is set + // only while the very first turn subscribes to the firehose. + buffering bool + buffered []protocol.ChatEventFrame + // pending holds the room's unresolved approval requests, in the order they + // were raised, replayed to a client that attaches after they were raised. A + // request is removed once it is resolved. + pending []protocol.ChatPermissionFrame + pollerStarted bool + wake chan struct{} + turnDone chan struct{} +} + +func newChatRoom(base context.Context, sessionID string) *chatRoom { + if base == nil { + base = context.Background() + } + roomCtx, cancel := context.WithCancel(base) + return &chatRoom{ + sessionID: sessionID, + ctx: roomCtx, + cancel: cancel, + subs: map[string]*chatSub{}, + wake: make(chan struct{}, 1), + } +} + +// roomLocked returns the session's room, creating it (and its turn runner) when +// it is the first client to watch the session. Callers must hold h.mu. +func (h *chatHub) roomLocked(sessionID string) *chatRoom { + if h.rooms == nil { + h.rooms = map[string]*chatRoom{} + } + if room := h.rooms[sessionID]; room != nil { + return room + } + room := newChatRoom(h.baseCtx, sessionID) + h.rooms[sessionID] = room + go h.runRoom(room) + return room +} + +// attach registers write as one client's subscription to sessionID's stream and +// returns it, or the existing subscription when the same connection has already +// attached. It is idempotent so a client may prompt and subscribe without +// registering twice. +func (h *chatHub) attach(sessionID, clientID, label string, broker chatBroker, write func(protocol.Message) error) *chatSub { + if sessionID == "" || clientID == "" || write == nil { + return nil + } + h.mu.Lock() + room := h.roomLocked(sessionID) + if room.broker == nil { + room.broker = broker + } + if sub, ok := room.subs[clientID]; ok { + if label != "" { + sub.label = label + } + h.mu.Unlock() + return sub + } + sub := &chatSub{ + hub: h, + room: room, + clientID: clientID, + label: label, + ch: make(chan protocol.Message, chatRoomSubscriberBuffer), + done: make(chan struct{}), + write: write, + } + room.subs[clientID] = sub + h.mu.Unlock() + go sub.run() + return sub +} + +// detach drops one subscription. The room (and its broker stream and queue) is +// released once its last client leaves, so a session with no watchers holds no +// goroutine. +func (h *chatHub) detach(sessionID string, sub *chatSub) { + h.mu.Lock() + room := h.rooms[sessionID] + if room == nil || room.subs[sub.clientID] != sub { + h.mu.Unlock() + return + } + delete(room.subs, sub.clientID) + if len(room.subs) == 0 { + delete(h.rooms, sessionID) + room.cancel() + } + h.mu.Unlock() +} + +// detachClient drops every chat subscription one connection holds; the read loop +// calls it when the connection ends so no subscriber goroutine outlives it. +func (h *chatHub) detachClient(clientID string) { + if clientID == "" { + return + } + h.mu.Lock() + var subs []*chatSub + for _, room := range h.rooms { + if sub, ok := room.subs[clientID]; ok { + subs = append(subs, sub) + } + } + h.mu.Unlock() + for _, sub := range subs { + sub.close() + } +} + +// fanout delivers one frame to every client watching sessionID except the one +// named by except (the sender, who already has it locally). +func (h *chatHub) fanout(sessionID string, msg protocol.Message, except string) { + h.mu.Lock() + var targets []*chatSub + if room := h.rooms[sessionID]; room != nil { + for id, sub := range room.subs { + if id == except { + continue + } + targets = append(targets, sub) + } + } + h.mu.Unlock() + for _, sub := range targets { + sub.send(msg) + } +} + +// broadcastUser retains a prompt as a user turn and pushes it live to every other +// client watching the session, attributed to the sending client's label. The +// sender already has the message locally, so it is excluded to keep its own +// transcript from duplicating it. +func (h *chatHub) broadcastUser(frame protocol.ChatEventFrame, exceptClientID string) { + h.apply(frame) + h.fanout(frame.SessionID, protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame}, exceptClientID) +} + +// emit folds one broker frame into the retained state and fans it out. While the +// first turn's ack is still pending the frames are buffered and flushed in order +// once it is written. A step-ended frame finishes the turn, letting the queue +// advance. +func (h *chatHub) emit(frame protocol.ChatEventFrame) { + h.apply(frame) + h.mu.Lock() + room := h.rooms[frame.SessionID] + buffered := false + var targets []*chatSub + if room != nil { + if room.buffering { + room.buffered = append(room.buffered, frame) + buffered = true + } else { + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + } + if room != nil && frame.Kind == protocol.ChatEventStep && frame.Step != nil && frame.Step.Status == protocol.ChatStepEnded { + h.finishTurnLocked(room) + } + h.mu.Unlock() + if buffered { + return + } + msg := protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame} + for _, sub := range targets { + sub.send(msg) + } +} + +// finishTurnLocked marks the room's turn finished and releases the turn runner's +// wait. Callers must hold h.mu. +func (h *chatHub) finishTurnLocked(room *chatRoom) { + room.running = false + if room.turnDone != nil { + close(room.turnDone) + room.turnDone = nil + } +} + +// turnInFlight reports whether sessionID has a turn in flight, so chat_close +// knows whether to stop one through the broker interrupt before it records the +// closed state. A room exists only while a client is watching the session, and +// running is set by the turn runner for the whole turn (a prompt queued behind a +// live turn leaves it set), so an idle or unwatched session reports false and no +// interrupt is sent. It is one read under the hub mutex and mutates nothing. +func (h *chatHub) turnInFlight(sessionID string) bool { + h.mu.Lock() + defer h.mu.Unlock() + room := h.rooms[sessionID] + return room != nil && room.running +} + +// flushBuffered releases the frames held while the ack was pending and delivers +// them in order. It is a no-op once the room is no longer buffering. +func (h *chatHub) flushBuffered(sessionID string) { + h.mu.Lock() + room := h.rooms[sessionID] + var pending []protocol.ChatEventFrame + var targets []*chatSub + if room != nil && room.buffering { + room.buffering = false + pending = room.buffered + room.buffered = nil + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + h.mu.Unlock() + for i := range pending { + frame := pending[i] + msg := protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame} + for _, sub := range targets { + sub.send(msg) + } + } +} + +// submitPrompt accepts one prompt: it starts the turn runner immediately when no +// turn is in flight, or queues it (bounded) when one is. It returns whether the +// prompt was queued or refused. +func (h *chatHub) submitPrompt(sessionID string, p *chatQueuedPrompt) (queued bool, refused bool) { + h.mu.Lock() + room := h.roomLocked(sessionID) + if room.running || len(room.queue) > 0 { + if len(room.queue) >= chatRoomQueueLimit { + h.mu.Unlock() + return false, true + } + // The client is acknowledged as queued by the handler, so the turn runner + // must not acknowledge the same request again once it runs. The write is + // still kept so a later broker failure reaches the client that sent it. + p.acked = true + room.queue = append(room.queue, p) + signalWake(room.wake) + h.mu.Unlock() + return true, false + } + room.queue = append(room.queue, p) + signalWake(room.wake) + h.mu.Unlock() + return false, false +} + +// pendingFrames returns a copy of the room's unresolved approval requests so a +// client that attaches after they were raised can be shown every one of them. It +// returns nil when the room holds none. +func (h *chatHub) pendingFrames(sessionID string) []protocol.ChatPermissionFrame { + h.mu.Lock() + defer h.mu.Unlock() + room := h.rooms[sessionID] + if room == nil || len(room.pending) == 0 { + return nil + } + frames := make([]protocol.ChatPermissionFrame, len(room.pending)) + copy(frames, room.pending) + return frames +} + +// pushPermission publishes one newly seen pending approval request to every +// client watching the session and remembers it (bounded) for a client that +// attaches later. A request already seen (or already resolved) is not pushed +// again. +func (h *chatHub) pushPermission(sessionID string, frame protocol.ChatPermissionFrame) { + if frame.RequestID == "" || frame.Resolved { + return + } + if !h.seenPermission(sessionID, frame.RequestID) { + return + } + h.mu.Lock() + var targets []*chatSub + if room := h.rooms[sessionID]; room != nil { + known := false + for i := range room.pending { + if room.pending[i].RequestID == frame.RequestID { + room.pending[i] = frame + known = true + break + } + } + if !known { + room.pending = append(room.pending, frame) + if len(room.pending) > chatRoomPendingLimit { + room.pending = room.pending[len(room.pending)-chatRoomPendingLimit:] + } + } + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + h.mu.Unlock() + msg := protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame} + for _, sub := range targets { + sub.send(msg) + } +} + +// runRoom is the session's turn runner: it takes queued prompts one at a time, +// posts each to the broker and waits for the turn to end, so two prompts of one +// session can never interleave. +func (h *chatHub) runRoom(room *chatRoom) { + for { + p, done, ok := h.nextPrompt(room) + if !ok { + return + } + h.runTurn(room, p, done) + } +} + +// nextPrompt pops the next queued prompt, blocking until one arrives or the room +// is released. It marks the room running and creates the turn's completion +// channel so a stale signal from a previous turn can never end the next one. +func (h *chatHub) nextPrompt(room *chatRoom) (*chatQueuedPrompt, chan struct{}, bool) { + for { + h.mu.Lock() + if len(room.queue) > 0 { + p := room.queue[0] + room.queue = room.queue[1:] + room.running = true + room.turnDone = make(chan struct{}) + done := room.turnDone + h.mu.Unlock() + return p, done, true + } + h.mu.Unlock() + select { + case <-room.ctx.Done(): + return nil, nil, false + case <-room.wake: + } + } +} + +// runTurn subscribes to the broker stream when needed, posts one prompt, writes +// its ack and waits for the turn to end. +func (h *chatHub) runTurn(room *chatRoom, p *chatQueuedPrompt, done chan struct{}) { + broker := h.roomBroker(room) + first := false + h.mu.Lock() + if !room.streaming { + first = true + room.buffering = true + } + h.mu.Unlock() + defer h.flushBuffered(room.sessionID) + + if broker == nil { + h.failPrompt(room, p, errors.New("chat is not configured on this server")) + return + } + if first { + if err := h.startStream(room, broker); err != nil { + h.failPrompt(room, p, err) + h.endRoomTurn(room) + return + } + } + if err := broker.Prompt(room.ctx, room.sessionID, p.text); err != nil { + h.failPrompt(room, p, err) + h.endRoomTurn(room) + return + } + if h.registry != nil { + if err := h.registry.TouchOperatorSession(room.ctx, room.sessionID); err != nil { + log.Printf("touch operator session %s: %v", room.sessionID, err) + } + } + if p.write != nil && !p.acked { + _ = p.write(protocol.Message{Type: protocol.ChatPrompt, ID: p.requestID}) + } + h.flushBuffered(room.sessionID) + // Start the approval poller once, after the first ack, so a pending request + // is surfaced after the prompt is acknowledged and shared with every client. + h.mu.Lock() + startPoller := !room.pollerStarted + room.pollerStarted = true + h.mu.Unlock() + if startPoller { + go h.pollRoom(room, broker) + } + select { + case <-done: + case <-room.ctx.Done(): + } +} + +// endRoomTurn releases the turn slot after a prompt that never entered flight, +// so the queue advances immediately instead of waiting for a step that never +// comes. +func (h *chatHub) endRoomTurn(room *chatRoom) { + h.mu.Lock() + h.finishTurnLocked(room) + h.mu.Unlock() +} + +// failPrompt reports a refused prompt to the client that sent it, so a prompt +// that never reached the agent is visible on the device that sent it rather than +// leaving its composer waiting. It is reported for a queued prompt too, whose +// success ack was already sent but whose delivery may still fail. +func (h *chatHub) failPrompt(room *chatRoom, p *chatQueuedPrompt, err error) { + if p.write == nil || err == nil { + return + } + _ = p.write(protocol.Message{Type: protocol.Error, ID: p.requestID, Error: err.Error()}) +} + +// roomBroker returns the broker bound to the room. +func (h *chatHub) roomBroker(room *chatRoom) chatBroker { + h.mu.Lock() + defer h.mu.Unlock() + return room.broker +} + +// startStream attaches the room to the broker firehose, waiting until the +// subscription is ready so no delta emitted between subscribing and posting a +// prompt is lost. The permission poller starts alongside it. +func (h *chatHub) startStream(room *chatRoom, broker chatBroker) error { + attached := make(chan struct{}) + var once sync.Once + result := make(chan error, 1) + ctx := room.ctx + go func() { + result <- broker.Stream(ctx, room.sessionID, func() { + once.Do(func() { close(attached) }) + }, func(frame protocol.ChatEventFrame) error { + h.emit(frame) + return nil + }) + }() + select { + case <-attached: + case err := <-result: + if err == nil { + err = errors.New("chat stream ended before it was subscribed") + } + return err + case <-ctx.Done(): + return ctx.Err() + } + h.mu.Lock() + room.streaming = true + h.mu.Unlock() + go h.drainStream(room, result) + return nil +} + +// drainStream reports the terminal error of a room's subscription and clears the +// streaming flag so a later turn re-subscribes; it also releases a turn still +// waiting on a stream that ended. +func (h *chatHub) drainStream(room *chatRoom, result <-chan error) { + err := <-result + h.mu.Lock() + room.streaming = false + h.finishTurnLocked(room) + h.mu.Unlock() + if err != nil && room.ctx.Err() == nil { + log.Printf("chat stream session=%s: %v", room.sessionID, err) + } +} + +// pollRoom polls the broker's pending-approval list for the room on a fixed +// interval and pushes each newly seen request to every attached client. The +// first poll runs immediately; the loop stops with the room's context. +func (h *chatHub) pollRoom(room *chatRoom, broker chatBroker) { + ticker := time.NewTicker(chatPermissionPollInterval) + defer ticker.Stop() + reported := false + for { + if err := h.pollPermissionsOnce(room.ctx, broker, room.sessionID); err != nil { + if room.ctx.Err() != nil { + return + } + if errors.Is(err, opencode.ErrPermissionUnsupported) { + log.Printf("chat permission poll session=%s: %v", room.sessionID, err) + return + } + if reported { + log.Printf("chat permission poll session=%s: %v", room.sessionID, err) + } else { + reported = true + h.fanout(room.sessionID, protocol.Message{Type: protocol.Error, Error: "chat permission poll: " + err.Error()}, "") + } + } + select { + case <-room.ctx.Done(): + return + case <-ticker.C: + } + } +} + +// pollPermissionsOnce performs one poll and pushes each newly seen request of the +// session to every client watching it. +func (h *chatHub) pollPermissionsOnce(ctx context.Context, broker chatBroker, sessionID string) error { + pending, err := broker.Permissions(ctx, sessionID) + if err != nil { + return err + } + for _, request := range pending { + if request.SessionID != sessionID || request.RequestID == "" { + continue + } + h.pushPermission(sessionID, request) + } + return nil +} + +// signalWake nudges a room's turn runner without blocking. The channel is +// buffered, so a signal already pending is enough. +func signalWake(ch chan struct{}) { + select { + case ch <- struct{}{}: + default: + } +} + +// sanitizeChatClientLabel cleans a client-supplied device label for storage and +// echo: control characters are dropped, the length is bounded and a blank label +// becomes the generic fallback, so a transcript can always attribute a message. +func sanitizeChatClientLabel(label string) string { + var b strings.Builder + for _, r := range label { + if r < 0x20 || r == 0x7f { + continue + } + b.WriteRune(r) + } + out := strings.TrimSpace(b.String()) + if len(out) > chatClientLabelMax { + out = strings.TrimSpace(out[:chatClientLabelMax]) + } + if out == "" { + return chatClientLabelFallback + } + return out +} + +// permissionRefusal explains why a second answer to an already-answered request +// is refused, naming the client that won so the operator sees what happened. +func permissionRefusal(prior *chatResolution, requestID string) string { + if prior == nil { + return "permission request " + requestID + " is already resolved" + } + if prior.answered { + return fmt.Sprintf("permission request %s was already answered by %s", requestID, prior.client) + } + return fmt.Sprintf("permission request %s is already being answered by %s", requestID, prior.client) +} diff --git a/internal/server/chat_sessions.go b/internal/server/chat_sessions.go index 17efafbf..881dfad7 100644 --- a/internal/server/chat_sessions.go +++ b/internal/server/chat_sessions.go @@ -17,15 +17,15 @@ import ( // fixed list bounds. const operatorDirectoryLimit = 8 -// handleChatSessions answers chat_sessions with the operator's own sessions, -// marking any another client currently holds as Busy. The registry is the single -// source of truth for which sessions are listed and for their directory, tag, -// created/recency, so a pipeline stage session (recorded in run_steps, never in -// the operator registry) is always excluded and a session with no recorded tag -// is never listed. FAIL-CLOSED: when no registry is configured the result is -// empty, never the whole endpoint list. broker.Sessions is called at most once -// per request, and the registry once. -func handleChatSessions(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) { +// handleChatSessions answers chat_sessions with the operator's own sessions. The +// registry is the single source of truth for which sessions are listed and for +// their directory, tag, created/recency, so a pipeline stage session (recorded +// in run_steps, never in the operator registry) is always excluded and a session +// with no recorded tag is never listed. FAIL-CLOSED: when no registry is +// configured the result is empty, never the whole endpoint list. broker.Sessions +// is called at most once per request, and the registry once. A session is never +// marked Busy: any number of clients may watch and write one session. +func handleChatSessions(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, write func(protocol.Message) error) { if broker == nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) return @@ -76,10 +76,10 @@ func handleChatSessions(ctx context.Context, request protocol.Message, broker ch session.UpdatedAt = operator.UpdatedAt // The closed state comes from the registry, so every client sees the same // thing; a closed session stays in the list (the app groups it as history) - // rather than disappearing. + // rather than disappearing. A session is never marked Busy: any number of + // clients may watch and write one session. session.Closed = operator.ClosedAt > 0 session.ClosedAt = operator.ClosedAt - session.Busy = hub.busyForOther(operator.ID, clientID) response.ChatSessions = append(response.ChatSessions, session) } _ = write(response) diff --git a/internal/server/chat_stream.go b/internal/server/chat_stream.go index 52d52d43..da9f9cb3 100644 --- a/internal/server/chat_stream.go +++ b/internal/server/chat_stream.go @@ -2,10 +2,7 @@ package server import ( "context" - "errors" - "log" "strings" - "sync" "time" "git.a-wan.net/alan/pipelines/internal/opencode" @@ -14,10 +11,16 @@ import ( // chatPermissionPollInterval is the fixed interval between permission polls: one // GET per poll through the shared Connection bounds, never a busy loop. The first -// poll runs immediately so a request pending when the prompt is sent is surfaced +// poll runs immediately so a request pending when a turn starts is surfaced // without waiting a full interval. const chatPermissionPollInterval = 2 * time.Second +// handleChatPrompt accepts a prompt from any client. It never rejects a prompt +// because another client is watching the session: the client attaches to the +// session's shared room and the prompt either starts a turn or is queued behind +// the one in flight, with the ack saying which. The prompt is echoed live to +// every other client, attributed to the sending device's label, and the turn's +// output is fanned out to all of them. func handleChatPrompt(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) { if broker == nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) @@ -42,170 +45,78 @@ func handleChatPrompt(ctx context.Context, request protocol.Message, broker chat _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat prompt exceeds 64 KiB"}) return } - // Claim the session before subscribing or prompting: a second client must be - // rejected here, before any broker call, so two clients cannot silently write - // the same conversation. The same client may re-prompt its own session. sessionID := prompt.SessionID - if !hub.claim(sessionID, clientID) { - _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " is busy with another client"}) + sub := hub.attach(sessionID, clientID, sanitizeChatClientLabel(prompt.Client), broker, write) + if sub == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + sessionID}) return } - - // Subscribe to the OpenCode firehose before posting the prompt: the stream - // has no replay cursor (research 2.4), so a delta emitted between the POST - // and the subscription would otherwise be lost. Frames that arrive before the - // ack is written are buffered and flushed in order after it. - streamCtx, streamCancel := context.WithCancel(ctx) - attached := make(chan struct{}) - var attachOnce sync.Once - streamResult := make(chan error, 1) - var bufferMu sync.Mutex - buffering := true - var buffered []protocol.ChatEventFrame - go func() { - streamResult <- broker.Stream(streamCtx, sessionID, func() { - attachOnce.Do(func() { close(attached) }) - }, func(frame protocol.ChatEventFrame) error { - bufferMu.Lock() - if buffering { - buffered = append(buffered, frame) - bufferMu.Unlock() - return nil - } - bufferMu.Unlock() - hub.apply(frame) - return write(protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame}) - }) - }() - - select { - case <-attached: - case err := <-streamResult: - streamCancel() - hub.release(sessionID, clientID) - if err != nil && ctx.Err() == nil { - _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat stream: " + err.Error()}) - } - return - case <-ctx.Done(): - streamCancel() - hub.release(sessionID, clientID) + // The user turn every *other* client sees, carrying the sender's label. The + // sender's own client appended it locally, so it is excluded below. + userFrame := protocol.ChatEventFrame{ + SessionID: sessionID, + MessageID: hub.nextUserMessageID(), + Kind: protocol.ChatEventUser, + Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text}, + Client: sub.label, + } + queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{ + text: prompt.Text, + requestID: request.ID, + write: write, + }) + if refused { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " already has the maximum number of prompts queued"}) return } - - if err := broker.Prompt(ctx, sessionID, prompt.Text); err != nil { - streamCancel() - hub.release(sessionID, clientID) - _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) - return + // Publish the user turn to every other client; the sender already has it. + hub.broadcastUser(userFrame, clientID) + if queued { + // The client that sent it is told the prompt is waiting for the in-flight + // turn, so it shows queued/steering instead of blocking or silently + // dropping the message. The turn runner acknowledges it once it runs, so + // clear the ack on the queued entry to avoid a second ack for the same id. + _ = write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID, ChatQueued: true}) } - // Recency is one UPDATE: it moves the operator session to the front of - // chat_sessions. A session id that is not an operator session updates no row - // and is not an error, so pipeline stage prompts are unaffected. if registry != nil { + // Recency is one UPDATE: it moves the operator session to the front of + // chat_sessions. A session id that is not an operator session updates no + // row and is not an error, so pipeline stage prompts are unaffected. if err := registry.TouchOperatorSession(ctx, sessionID); err != nil { - log.Printf("touch operator session %s: %v", sessionID, err) + // Best-effort; the turn runner also touches on delivery. + _ = err } } - // Acknowledge the accepted prompt with the echoed request id, then stream the - // reply. The prompt is sent exactly once and never re-sent on resume. - if err := write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID}); err != nil { - streamCancel() - hub.release(sessionID, clientID) +} + +// handleChatSubscribe attaches one connection to a session's shared stream so it +// receives every frame any client's turn produces, its own or another device's. +// It replays the session's still-pending approval requests, if the room holds +// any, so a device that joins late still shows the cards. +func handleChatSubscribe(request protocol.Message, broker chatBroker, hub *chatHub, clientID string, write func(protocol.Message) error) { + // The wire body of chat_subscribe is the chat_subscribe field (the app's + // subscribeRequest and docs/cli.md both use it), not the chat_query body the + // other session-scoped commands carry. + query := request.ChatSubscribe + if query == nil || !opencode.ValidSessionID(query.SessionID) { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"}) return } - // Flush frames buffered while the prompt was accepted, then resume live - // delivery. Holding bufferMu preserves order: the stream goroutine either - // buffered before this flush or waits and writes after it. - bufferMu.Lock() - buffering = false - pending := buffered - buffered = nil - for _, frame := range pending { - hub.apply(frame) - if err := write(protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame}); err != nil { - bufferMu.Unlock() - streamCancel() - hub.release(sessionID, clientID) - return - } + if broker == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) + return } - bufferMu.Unlock() - go drainChatStream(ctx, streamResult, streamCancel, hub, sessionID, clientID, write) - // Poll for pending approval requests alongside the event stream, sharing - // streamCtx so the poller stops when the stream ends or the client - // disconnects. The first poll runs immediately. - go pollChatPermissions(streamCtx, broker, hub, sessionID, write) -} - -// pollChatPermissions polls the broker's pending-approval list on a fixed -// interval, sharing the chat subscription's context so it stops on disconnect or -// when the turn's stream ends. The hub dedups the request ids, so each pending -// request is pushed at most once; a poll failure is surfaced once through the -// same write closure instead of staying silent. A backend that does not expose -// the approval surface (opencode.ErrPermissionUnsupported) stops the poller -// quietly, so the documented limitation is not reported as a per-prompt error. -func pollChatPermissions(ctx context.Context, broker chatBroker, hub *chatHub, sessionID string, write func(protocol.Message) error) { - ticker := time.NewTicker(chatPermissionPollInterval) - defer ticker.Stop() - reported := false - for { - if err := pushChatPermissions(ctx, broker, hub, sessionID, write); err != nil { - if ctx.Err() != nil { - return - } - if errors.Is(err, opencode.ErrPermissionUnsupported) { - log.Printf("chat permission poll session=%s: %v", sessionID, err) - return - } - if reported { - log.Printf("chat permission poll session=%s: %v", sessionID, err) - } else { - reported = true - _ = write(protocol.Message{Type: protocol.Error, Error: "chat permission poll: " + err.Error()}) - } - } - select { - case <-ctx.Done(): - return - case <-ticker.C: - } - } -} - -// pushChatPermissions performs one poll and writes a chat_permission frame for -// every newly seen request of the session, through the same connection-scoped -// write closure as the chat stream. It never re-pushes a request id, and releases -// the reservation on a write failure so the frame is not silently dropped. -func pushChatPermissions(ctx context.Context, broker chatBroker, hub *chatHub, sessionID string, write func(protocol.Message) error) error { - pending, err := broker.Permissions(ctx, sessionID) - if err != nil { - return err - } - for _, request := range pending { - if request.SessionID != sessionID || request.RequestID == "" { - continue - } - if !hub.seenPermission(sessionID, request.RequestID) { - continue - } - frame := request - if err := write(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame}); err != nil { - hub.forgetPermission(sessionID, request.RequestID) - return err - } - } - return nil -} - -// drainChatStream reports the terminal error of a chat subscription and releases -// its context and the session claim once the stream has ended, so a later client -// is no longer blocked and nothing leaks. -func drainChatStream(ctx context.Context, result <-chan error, cancel context.CancelFunc, hub *chatHub, sessionID, clientID string, write func(protocol.Message) error) { - defer cancel() - defer hub.release(sessionID, clientID) - if err := <-result; err != nil && ctx.Err() == nil { - log.Printf("chat stream session=%s: %v", sessionID, err) - _ = write(protocol.Message{Type: protocol.Error, Error: "chat stream: " + err.Error()}) + sub := hub.attach(query.SessionID, clientID, "", broker, write) + if sub == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + query.SessionID}) + return + } + _ = write(protocol.Message{Type: protocol.ChatSubscribe, ID: request.ID}) + // Replay every still-unresolved approval request the room holds, not only the + // most recent one, so a client that attaches after two requests were raised + // still sees both cards. + for _, pending := range hub.pendingFrames(query.SessionID) { + frame := pending + sub.send(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame}) } } diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index 7c11801e..1dd43b36 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -436,10 +436,18 @@ func TestChatMessagesResumesRetainedState(t *testing.T) { if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } - if response.Type != protocol.ChatMessages || response.ID != "r2" || len(response.ChatMessages) != 1 { + if response.Type != protocol.ChatMessages || response.ID != "r2" || len(response.ChatMessages) != 2 { t.Fatalf("resume response = %+v", response) } - message := response.ChatMessages[0] + // The prompt is retained as a user turn and the assistant reply beside it, so + // a reconnecting client re-syncs a conversation that still says who sent + // what. The user turn carries the sending client's label (the generic + // fallback when the prompt did not name one). + user := response.ChatMessages[0] + if user.Role != protocol.ChatRoleUser || len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].Text != "hi" || user.Client != chatClientLabelFallback { + t.Fatalf("resumed user turn = %+v", user) + } + message := response.ChatMessages[1] if message.ID != "msg_1" || message.Role != protocol.ChatRoleAssistant || len(message.Parts) != 2 { t.Fatalf("resumed message = %+v", message) } @@ -1361,88 +1369,6 @@ func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) { } } -// TestChatSessionsBusyRejectsSecondClient is the task evidence for busy state: -// while client A holds ses_1 with a blocking prompt, client B's chat_sessions -// reports ses_1 Busy=true and B's chat_prompt for ses_1 is rejected before any -// broker.Prompt call; after A disconnects the claim is released and a later list -// is no longer busy. -func TestChatSessionsBusyRejectsSecondClient(t *testing.T) { - ctx := context.Background() - store := newOperatorStore(t) - if err := store.RecordOperatorSession(ctx, "ses_1", "/work", "operator chat", protocol.ChatSessionTagOperator); err != nil { - t.Fatal(err) - } - broker := scriptedChat() - broker.block = true - broker.done = make(chan struct{}) - broker.sessions = []protocol.ChatSession{{ID: "ses_1"}} - ctx, _, conns := dialChatConns(t, Options{Chat: broker, OperatorRegistry: store}, 2) - connA, connB := conns[0], conns[1] - - if err := wsjson.Write(ctx, connA, protocol.Message{Type: protocol.ChatPrompt, ID: "a1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { - t.Fatal(err) - } - var ack protocol.Message - if err := wsjson.Read(ctx, connA, &ack); err != nil { - t.Fatal(err) - } - if ack.Type != protocol.ChatPrompt || ack.ID != "a1" { - t.Fatalf("prompt ack = %+v", ack) - } - - if err := wsjson.Write(ctx, connB, protocol.Message{Type: protocol.ChatSessions, ID: "b1"}); err != nil { - t.Fatal(err) - } - var listing protocol.Message - if err := wsjson.Read(ctx, connB, &listing); err != nil { - t.Fatal(err) - } - if listing.Type != protocol.ChatSessions || len(listing.ChatSessions) != 1 || !listing.ChatSessions[0].Busy { - t.Fatalf("held session not marked busy: %+v", listing) - } - - if err := wsjson.Write(ctx, connB, protocol.Message{Type: protocol.ChatPrompt, ID: "b2", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hello"}}); err != nil { - t.Fatal(err) - } - var rejected protocol.Message - if err := wsjson.Read(ctx, connB, &rejected); err != nil { - t.Fatal(err) - } - if rejected.Type != protocol.Error || !strings.Contains(rejected.Error, "busy") { - t.Fatalf("second client's prompt was not rejected as busy: %+v", rejected) - } - if prompts, _, _ := broker.counts(); prompts != 1 { - t.Fatalf("busy prompt reached OpenCode: %d prompt calls, want 1", prompts) - } - - // Disconnecting A releases the claim so a later client is no longer blocked. - if err := connA.Close(websocket.StatusNormalClosure, ""); err != nil { - t.Fatal(err) - } - select { - case <-broker.done: - case <-time.After(5 * time.Second): - t.Fatal("stream did not stop after disconnect") - } - deadline := time.Now().Add(5 * time.Second) - for { - if err := wsjson.Write(ctx, connB, protocol.Message{Type: protocol.ChatSessions, ID: "b3"}); err != nil { - t.Fatal(err) - } - var after protocol.Message - if err := wsjson.Read(ctx, connB, &after); err != nil { - t.Fatal(err) - } - if after.Type == protocol.ChatSessions && len(after.ChatSessions) == 1 && !after.ChatSessions[0].Busy { - return - } - if time.Now().After(deadline) { - t.Fatalf("claim not released after disconnect: %+v", after) - } - time.Sleep(10 * time.Millisecond) - } -} - // TestChatPromptPushesPermissionAndForwardsReply is the task evidence: with a // blocking scripted stream keeping the subscription open, a seeded pending // approval request is pushed as a chat_permission frame carrying the seeded @@ -1522,11 +1448,29 @@ func TestChatPermissionDedupesRepeatedPolls(t *testing.T) { mu.Unlock() return nil } + if sub := hub.attach("ses_1", "c1", "phone", broker, write); sub == nil { + t.Fatal("attach returned nil") + } for i := 0; i < 3; i++ { - if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err != nil { + if err := hub.pollPermissionsOnce(context.Background(), broker, "ses_1"); err != nil { t.Fatal(err) } } + deadline := time.Now().Add(2 * time.Second) + for { + mu.Lock() + count := len(pushed) + mu.Unlock() + if count > 0 { + break + } + if time.Now().After(deadline) { + t.Fatal("no permission frame was pushed") + } + time.Sleep(5 * time.Millisecond) + } + // Give a duplicate a chance to arrive before asserting there is none. + time.Sleep(50 * time.Millisecond) mu.Lock() defer mu.Unlock() if len(pushed) != 1 { @@ -1684,32 +1628,6 @@ func TestChatPermissionUnsupportedBackendIsQuiet(t *testing.T) { } } -// TestChatPermissionWriteFailureDoesNotDropRequest pins that a request id is not -// retained as "seen" when its frame could not be written, so the next poll -// re-pushes it instead of silently dropping the approval request. -func TestChatPermissionWriteFailureDoesNotDropRequest(t *testing.T) { - broker := scriptedChat() - broker.permissions = []protocol.ChatPermissionFrame{{SessionID: "ses_1", RequestID: "req_1", Action: "bash"}} - hub := newChatHub() - attempts := 0 - write := func(protocol.Message) error { - attempts++ - if attempts == 1 { - return fmt.Errorf("connection closed") - } - return nil - } - if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err == nil { - t.Fatal("a failed write must surface an error") - } - if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err != nil { - t.Fatalf("retry after a failed write: %v", err) - } - if attempts != 2 { - t.Fatalf("push attempts = %d, want the request re-pushed after the failure", attempts) - } -} - // TestChatAdoptRecordsEndpointSession is the chat_adopt acceptance test: the // endpoint's own record supplies the directory and title, the handler records // the row with the operator tag, and the response echoes the session and its diff --git a/internal/server/templates_test.go b/internal/server/templates_test.go index 6d7910e8..6471d34e 100644 --- a/internal/server/templates_test.go +++ b/internal/server/templates_test.go @@ -2,6 +2,7 @@ package server import ( "context" + "git.a-wan.net/alan/pipelines/examples" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" "github.com/coder/websocket" @@ -44,7 +45,7 @@ func TestTemplatesDoNotSeedDatabaseAndCreateOnlyPreservesExisting(t *testing.T) if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } - if response.Type != protocol.Templates || len(response.Templates) != 4 { + if response.Type != protocol.Templates || len(response.Templates) != len(examples.Catalog()) { t.Fatal("missing catalog", response.Type, len(response.Templates)) } items, err := store.List(ctx) diff --git a/internal/server/websocket.go b/internal/server/websocket.go index 9d3d076a..8ee03ef2 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -86,6 +86,8 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin if registry == nil && len(stores) > 0 { registry = stores[0] } + hub.baseCtx = ctx + hub.registry = registry mux.HandleFunc("GET /artifacts/{run}/{step}/{name...}", func(w http.ResponseWriter, r *http.Request) { if runs == nil { http.NotFound(w, r) @@ -139,6 +141,9 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin // Drop every run subscription this connection holds when the read loop // returns, so no subscriber, goroutine or timer outlives the connection. defer events.unsubscribeClient(clientID) + // Drop every chat subscription too, so a chat room held only by this + // connection releases its broker stream and turn runner. + defer hub.detachClient(clientID) if len(stores) > 0 { items, err := stores[0].List(ctx) if err != nil { diff --git a/scripts/smoke-first-install.py b/scripts/smoke-first-install.py index e13ec5b3..f19e7779 100644 --- a/scripts/smoke-first-install.py +++ b/scripts/smoke-first-install.py @@ -78,7 +78,7 @@ def main(): assert pong["build"] == version, "Client/server build mismatch" assert not rpc("list").get("pipelines"), "Fresh database must be empty" assert not rpc("runs").get("runs"), "Fresh database must have no runs" - assert len(rpc("templates")["templates"]) == 4 + assert len(rpc("templates")["templates"]) == 5 draft = rpc("new", "First test", "Review the repository", "--template", "review", "--no-open", "--yes") assert not rpc("list").get("pipelines"), "Draft creation must not publish" rpc("validate", draft["path"]) @@ -100,7 +100,7 @@ def main(): assert not rpc("runs").get("runs"), "Smoke check must not execute a workflow" finally: stop(process) - print("PASS developer lifecycle fixture: isolated source binaries/skill, offline version, empty DB, four templates, draft/validate/publish, ZIP identical import, restart persistence. Not an installation option; no inference or notifications.") + print("PASS developer lifecycle fixture: isolated source binaries/skill, offline version, empty DB, five templates, draft/validate/publish, ZIP identical import, restart persistence. Not an installation option; no inference or notifications.") if __name__ == "__main__":