Merge main into lane-pill: combine the pill overlay with main's chat-close, omni-search and status work
Brings the branch up to date with main's tip so it can be merged back without conflict. Merged cleanly, with no conflicted path: git auto-merged ui/PipelinesApp.kt, ui/chat/ChatListPane.kt and ui/screens/RunHistoryScreen.kt, keeping main's changes (the omni-search panel, the one status colour, the chat close/tool-work surfaces) alongside this item's pill overlay, its LocalPillBottomInset clearance and the SettingsDestination templates stack. android/README.md is main's version, not this item's: this item records its documentation change in docs/notes/pill-overlay-and-position.md for the single docs-fold writer instead of editing that shared document. Checks re-run on the merged tree (macOS, JAVA_HOME=Android Studio jbr, ANDROID_HOME=~/Library/Android/sdk, Gradle 8.11.1, --offline --no-daemon): `gradle :app:assembleDebug :app:testDebugUnitTest` -> BUILD SUCCESSFUL, 67 result XMLs aggregating to 627 tests, 0 failures, 0 errors, 0 skipped.
This commit is contained in:
@@ -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/<slug>.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/<slug>.md` note.
|
||||
|
||||
## Maintenance workflow
|
||||
|
||||
|
||||
+142
-2
@@ -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 "<Type>
|
||||
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
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
package net.awan.pipelines.data
|
||||
|
||||
import android.os.Build
|
||||
import java.util.UUID
|
||||
import java.util.concurrent.ConcurrentHashMap
|
||||
import kotlinx.coroutines.flow.SharedFlow
|
||||
@@ -27,6 +28,17 @@ import net.awan.pipelines.data.transport.PipelinesClient
|
||||
import net.awan.pipelines.data.transport.ProtocolException
|
||||
import net.awan.pipelines.data.transport.ServerUrl
|
||||
|
||||
/**
|
||||
* The default label this device reports: its model name, so other clients can
|
||||
* attribute a message to "Pixel 9 Pro XL". A build without a usable model (or a
|
||||
* local unit test where the framework stub has none) falls back to a generic
|
||||
* label rather than sending a blank one.
|
||||
*/
|
||||
private fun defaultClientLabel(): String {
|
||||
val model = runCatching { Build.MODEL }.getOrNull()?.trim().orEmpty()
|
||||
return model.ifBlank { "Android device" }
|
||||
}
|
||||
|
||||
/** Run history plus the server's aggregate usage statistics. */
|
||||
data class RunHistory(val runs: List<RunSummary>, val usage: UsageStats?)
|
||||
|
||||
@@ -38,6 +50,13 @@ data class RunHistory(val runs: List<RunSummary>, val usage: UsageStats?)
|
||||
class PipelinesRepository(
|
||||
private val client: PipelinesClient,
|
||||
private val settings: SettingsRepository,
|
||||
/**
|
||||
* The label this device sends with its prompts and approval answers, so every
|
||||
* other client can attribute a user message to the device that sent it and see
|
||||
* which device answered an approval. Defaults to the device model; injectable
|
||||
* so a unit test does not depend on the build.
|
||||
*/
|
||||
val clientLabel: String = defaultClientLabel(),
|
||||
) {
|
||||
val connectionState = client.state
|
||||
|
||||
@@ -155,13 +174,13 @@ class PipelinesRepository(
|
||||
|
||||
/**
|
||||
* Sends one omni-search query over the shared transport and returns the raw
|
||||
* reply envelope. The server command is still landing, so the reply is
|
||||
* classified by its envelope type: [Protocol.SEARCH_RESULTS] is the accepted
|
||||
* search, and any other type is an unexpected reply the caller reports rather
|
||||
* than parsing. The typed result payload is added with the results item.
|
||||
* reply envelope. [kind] narrows the server-side scan to one SearchKind (see
|
||||
* SearchKindFilter); a blank kind searches every kind. The reply is classified
|
||||
* by its envelope type: [Protocol.SEARCH_RESULTS] is the accepted search, and
|
||||
* any other type is an unexpected reply the caller reports rather than parsing.
|
||||
*/
|
||||
suspend fun search(query: String): Message =
|
||||
client.call(Message(type = Protocol.SEARCH, search = SearchRequest(query = query.trim())))
|
||||
suspend fun search(query: String, kind: String = ""): Message =
|
||||
client.call(Message(type = Protocol.SEARCH, search = SearchRequest(query = query.trim(), kind = kind)))
|
||||
|
||||
/** Fetches an artifact's bytes (image preview) over the shared HTTP client. */
|
||||
suspend fun fetchArtifactBytes(url: String): ByteArray = client.fetchBytes(url)
|
||||
@@ -241,9 +260,9 @@ class PipelinesRepository(
|
||||
// directly and never holds its credentials. ----
|
||||
|
||||
/**
|
||||
* Lists the sessions this server owns, with the `busy` flag the phone renders
|
||||
* read-only. The server already returns operator sessions only, so the app
|
||||
* never filters this list by ownership.
|
||||
* Lists the sessions this server owns. The server already returns operator
|
||||
* sessions only, so the app never filters this list by ownership; a session is
|
||||
* never marked read-only.
|
||||
*/
|
||||
suspend fun chatSessions(): List<ChatSession> =
|
||||
client.call(Message(type = Protocol.CHAT_SESSIONS)).chatSessions ?: emptyList()
|
||||
@@ -284,15 +303,29 @@ class PipelinesRepository(
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends one prompt with its attached file URIs; the server echoes an ack and
|
||||
* then pushes chat_event frames. The attachments travel only here, with the
|
||||
* prompt the operator actually sent — never on their own.
|
||||
* Attaches this connection to [sessionId]'s shared live stream, so it sees
|
||||
* every frame any client's turn produces — the other devices' prompts and the
|
||||
* turn's streaming output — and can answer a shared approval. Best-effort: an
|
||||
* older server that does not know `chat_subscribe` simply answers an error
|
||||
* frame, which the caller ignores while history still loads.
|
||||
*/
|
||||
suspend fun chatPrompt(sessionId: String, text: String, files: List<String> = emptyList()) {
|
||||
suspend fun chatSubscribe(sessionId: String) {
|
||||
if (sessionId.isBlank()) return
|
||||
client.call(ChatProtocol.subscribeRequest(sessionId))
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends one prompt with its attached file URIs; the server echoes an ack and
|
||||
* then pushes chat_event frames. The prompt carries this device's label so the
|
||||
* other clients can attribute it. The attachments travel only here, with the
|
||||
* prompt the operator actually sent — never on their own. Returns true when the
|
||||
* server queued the prompt behind an in-flight turn.
|
||||
*/
|
||||
suspend fun chatPrompt(sessionId: String, text: String, files: List<String> = emptyList()): Boolean {
|
||||
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
|
||||
val trimmed = text.trim()
|
||||
if (trimmed.isEmpty()) throw ProtocolException("Enter a message before sending.")
|
||||
client.call(ChatProtocol.promptRequest(sessionId, trimmed, files))
|
||||
return client.call(ChatProtocol.promptRequest(sessionId, trimmed, files, clientLabel)).chatQueued
|
||||
}
|
||||
|
||||
suspend fun chatInterrupt(sessionId: String) {
|
||||
@@ -300,11 +333,31 @@ class PipelinesRepository(
|
||||
client.call(ChatProtocol.interruptRequest(sessionId))
|
||||
}
|
||||
|
||||
/**
|
||||
* Finishes a chat on the server: any running turn is stopped and the session
|
||||
* is recorded closed, so every client sees it. Nothing is deleted. The
|
||||
* server returns the closed session, which the caller folds into its list.
|
||||
*/
|
||||
suspend fun chatClose(sessionId: String): ChatSession {
|
||||
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
|
||||
val response = client.call(ChatProtocol.closeRequest(sessionId))
|
||||
return response.chatSession
|
||||
?: throw ProtocolException("The server did not return the closed chat session.")
|
||||
}
|
||||
|
||||
/** Clears a closed chat's state so it returns to the active list. */
|
||||
suspend fun chatReopen(sessionId: String): ChatSession {
|
||||
if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.")
|
||||
val response = client.call(ChatProtocol.reopenRequest(sessionId))
|
||||
return response.chatSession
|
||||
?: throw ProtocolException("The server did not return the reopened chat session.")
|
||||
}
|
||||
|
||||
suspend fun chatReply(sessionId: String, requestId: String, decision: String, message: String = "") {
|
||||
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() {
|
||||
|
||||
@@ -77,6 +77,13 @@ class SettingsRepository(context: Context) {
|
||||
private val _notificationPermissionAsked =
|
||||
MutableStateFlow(prefs.getBoolean(KEY_NOTIFICATION_PERMISSION_ASKED, false))
|
||||
val notificationPermissionAsked: StateFlow<Boolean> = _notificationPermissionAsked.asStateFlow()
|
||||
// The omni-search kind narrowing (a server kind, "" = every kind) and the
|
||||
// search order, stored as their stable values and resolved by the UI.
|
||||
private val _searchFilterKind = MutableStateFlow(prefs.getString(KEY_SEARCH_FILTER_KIND, "").orEmpty())
|
||||
val searchFilterKind: StateFlow<String> = _searchFilterKind.asStateFlow()
|
||||
|
||||
private val _searchSort = MutableStateFlow(prefs.getString(KEY_SEARCH_SORT, "").orEmpty())
|
||||
val searchSort: StateFlow<String> = _searchSort.asStateFlow()
|
||||
|
||||
fun setServerUrl(value: String) {
|
||||
val trimmed = value.trim()
|
||||
@@ -155,6 +162,16 @@ class SettingsRepository(context: Context) {
|
||||
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()
|
||||
|
||||
@@ -173,5 +190,7 @@ class SettingsRepository(context: Context) {
|
||||
const val KEY_CHAT_SEEN = "chat_seen"
|
||||
const val KEY_ATTENTION = "attention"
|
||||
const val KEY_NOTIFICATION_PERMISSION_ASKED = "notification_permission_asked"
|
||||
const val KEY_SEARCH_FILTER_KIND = "search_filter_kind"
|
||||
const val KEY_SEARCH_SORT = "search_sort"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -30,9 +30,29 @@ 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
|
||||
// history are kept and the closed chat stays in the list (grouped as history),
|
||||
// where it can be reopened. [closedAt] is the epoch-millisecond close time, 0
|
||||
// while open. Additive/optional, so an older server simply never sets them.
|
||||
val closed: Boolean = false,
|
||||
@SerialName("closed_at") val closedAt: Long = 0,
|
||||
)
|
||||
|
||||
/**
|
||||
* The outcome of a `chat_close`, mirroring `internal/protocol/chat.go`
|
||||
* ChatCloseResult: the closed session's id, the epoch-millisecond close time and
|
||||
* whether an in-flight turn was interrupted to stop it. It is the record that a
|
||||
* running turn was stopped.
|
||||
*/
|
||||
@Serializable
|
||||
data class ChatCloseResult(
|
||||
@SerialName("session_id") val sessionId: String = "",
|
||||
@SerialName("closed_at") val closedAt: Long = 0,
|
||||
val interrupted: Boolean = false,
|
||||
)
|
||||
|
||||
@Serializable
|
||||
@@ -55,6 +75,10 @@ data class ChatPromptRequest(
|
||||
val model: String = "",
|
||||
val agent: String = "",
|
||||
val files: List<String> = emptyList(),
|
||||
// The sending device's human-readable label (a device name), so every other
|
||||
// client can attribute the message; the server sanitises it and falls back to
|
||||
// a generic label when it is blank.
|
||||
val client: String = "",
|
||||
)
|
||||
|
||||
/** One stored turn: a user turn is a single text part, an assistant turn holds text/reasoning/tool parts. */
|
||||
@@ -66,6 +90,9 @@ data class ChatMessage(
|
||||
val model: String = "",
|
||||
val agent: String = "",
|
||||
@SerialName("created_at") val createdAt: Long = 0,
|
||||
// The sending device's label on a user turn the server echoed, so a resumed
|
||||
// transcript still says who sent the message. Empty on an assistant turn.
|
||||
val client: String = "",
|
||||
val parts: List<ChatPart> = emptyList(),
|
||||
)
|
||||
|
||||
@@ -138,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
|
||||
@@ -174,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
|
||||
@@ -189,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`. */
|
||||
@@ -207,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"
|
||||
|
||||
@@ -241,10 +283,21 @@ object ChatProtocol {
|
||||
* shape a text-only prompt has always sent). Built here (not inline in the
|
||||
* repository) so production and its unit test share the one wire shape.
|
||||
*/
|
||||
fun promptRequest(sessionId: String, text: String, files: List<String> = emptyList()): Message =
|
||||
fun promptRequest(sessionId: String, text: String, files: List<String> = emptyList(), client: String = ""): Message =
|
||||
Message(
|
||||
type = Protocol.CHAT_PROMPT,
|
||||
chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files),
|
||||
chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files, client = client),
|
||||
)
|
||||
|
||||
/**
|
||||
* The `chat_subscribe` frame that attaches this connection to [sessionId]'s
|
||||
* shared live stream, so the client sees every frame any client's turn
|
||||
* produces. Built here so production and its unit test share the one shape.
|
||||
*/
|
||||
fun subscribeRequest(sessionId: String): Message =
|
||||
Message(
|
||||
type = Protocol.CHAT_SUBSCRIBE,
|
||||
chatSubscribe = ChatQuery(sessionId = sessionId),
|
||||
)
|
||||
|
||||
/**
|
||||
@@ -255,13 +308,31 @@ object ChatProtocol {
|
||||
fun interruptRequest(sessionId: String): Message =
|
||||
Message(type = Protocol.CHAT_INTERRUPT, chatQuery = ChatQuery(sessionId = sessionId))
|
||||
|
||||
/**
|
||||
* The `chat_close` frame that finishes [sessionId]: the server stops any
|
||||
* running turn (through the same interrupt) and records the session closed on
|
||||
* the server, sharing the state with every client. Nothing is deleted. Built
|
||||
* here (not inline in the repository) so production and its unit test share
|
||||
* the one wire shape.
|
||||
*/
|
||||
fun closeRequest(sessionId: String): Message =
|
||||
Message(type = Protocol.CHAT_CLOSE, chatQuery = ChatQuery(sessionId = sessionId))
|
||||
|
||||
/**
|
||||
* The `chat_reopen` frame that clears a closed session's state so it returns
|
||||
* to the active list; the inverse of [closeRequest]. Built here so production
|
||||
* and its unit test share the one wire shape.
|
||||
*/
|
||||
fun reopenRequest(sessionId: String): Message =
|
||||
Message(type = Protocol.CHAT_REOPEN, chatQuery = ChatQuery(sessionId = sessionId))
|
||||
|
||||
/**
|
||||
* The `chat_reply` frame that answers one permission request: [decision] is
|
||||
* one of [DECISION_ONCE]/[DECISION_ALWAYS]/[DECISION_REJECT]. Built here (not
|
||||
* 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(
|
||||
@@ -269,6 +340,7 @@ object ChatProtocol {
|
||||
requestId = requestId,
|
||||
decision = decision,
|
||||
message = message,
|
||||
client = client,
|
||||
),
|
||||
)
|
||||
}
|
||||
|
||||
@@ -68,6 +68,14 @@ object Protocol {
|
||||
const val CHAT_MESSAGES = "chat_messages"
|
||||
const val CHAT_INTERRUPT = "chat_interrupt"
|
||||
const val CHAT_REPLY = "chat_reply"
|
||||
// Close/reopen an operator session on the server (its closed state is
|
||||
// recorded so every client sees it). Both ride on chat_query like
|
||||
// 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"
|
||||
@@ -676,9 +684,17 @@ data class Message(
|
||||
@SerialName("chat_create") val chatCreate: ChatCreateRequest? = null,
|
||||
@SerialName("chat_query") val chatQuery: ChatQuery? = null,
|
||||
@SerialName("chat_prompt") val chatPrompt: ChatPromptRequest? = null,
|
||||
// A chat_prompt response with this set was accepted into the session's queue
|
||||
// because a turn is already in flight; the composer shows queued/steering
|
||||
// instead of blocking input.
|
||||
@SerialName("chat_queued") val chatQueued: Boolean = false,
|
||||
@SerialName("chat_subscribe") val chatSubscribe: ChatQuery? = null,
|
||||
@SerialName("chat_messages") val chatMessages: List<ChatMessage>? = null,
|
||||
@SerialName("chat_event") val chatEvent: ChatEventFrame? = null,
|
||||
@SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null,
|
||||
@SerialName("chat_reply") val chatReply: ChatReplyRequest? = null,
|
||||
// The outcome of a chat_close (session id, closed_at, interrupted); the
|
||||
// close/reopen requests themselves ride on chat_query like chat_interrupt.
|
||||
@SerialName("chat_close") val chatClose: ChatCloseResult? = null,
|
||||
@SerialName("chat_directories") val chatDirectories: List<String>? = null,
|
||||
)
|
||||
|
||||
@@ -83,6 +83,10 @@ class AppViewModel(
|
||||
val pipelineFilterRunStatuses: StateFlow<String> = settings.pipelineFilterRunStatuses
|
||||
val pipelineFilterName: StateFlow<String> = settings.pipelineFilterName
|
||||
|
||||
/** The stored omni-search kind narrowing (a server kind, "" = every kind) and order. */
|
||||
val searchKind: StateFlow<String> = settings.searchFilterKind
|
||||
val searchSort: StateFlow<String> = settings.searchSort
|
||||
|
||||
private val _serverUrlDraft = MutableStateFlow(settings.serverUrl.value)
|
||||
val serverUrlDraft: StateFlow<String> = _serverUrlDraft.asStateFlow()
|
||||
|
||||
@@ -685,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) {
|
||||
@@ -803,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)
|
||||
@@ -821,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
|
||||
@@ -1078,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))
|
||||
@@ -1107,7 +1137,14 @@ 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)
|
||||
} catch (t: Throwable) {
|
||||
if (t is CancellationException) throw t
|
||||
val message = ErrorMessages.describe(t)
|
||||
@@ -1115,6 +1152,7 @@ class AppViewModel(
|
||||
chatStore.failed(sessionId, message)
|
||||
chatStore.restoreAttachments(sessionId, attachments, message)
|
||||
chatStore.running(sessionId, false)
|
||||
chatStore.setQueued(sessionId, false)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1152,6 +1190,44 @@ class AppViewModel(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Finishes a chat on the server: any running turn is stopped (the server
|
||||
* reuses its interrupt) and the session is recorded closed, so every client
|
||||
* sees the same state. Nothing is deleted — the session and its history stay —
|
||||
* and the chat is kept in the list as closed history. Errors are reported on
|
||||
* the list, which is where the action lives.
|
||||
*/
|
||||
fun closeChatSession(sessionId: String) {
|
||||
if (sessionId.isBlank()) return
|
||||
viewModelScope.launch {
|
||||
try {
|
||||
val closed = repository.chatClose(sessionId)
|
||||
chatStore.sessionClosed(sessionId, closed.closedAt)
|
||||
} catch (t: Throwable) {
|
||||
if (t is CancellationException) throw t
|
||||
chatStore.sessionsFailed(ErrorMessages.describe(t))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reopens a closed chat so it returns to the active list. Sending another
|
||||
* message also reopens it (the server clears the closed state on prompt), so
|
||||
* this is the explicit path beside that one.
|
||||
*/
|
||||
fun reopenChatSession(sessionId: String) {
|
||||
if (sessionId.isBlank()) return
|
||||
viewModelScope.launch {
|
||||
try {
|
||||
repository.chatReopen(sessionId)
|
||||
chatStore.sessionReopened(sessionId)
|
||||
} catch (t: Throwable) {
|
||||
if (t is CancellationException) throw t
|
||||
chatStore.sessionsFailed(ErrorMessages.describe(t))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun <T> load(target: MutableStateFlow<LoadState<T>>, block: suspend () -> T) {
|
||||
viewModelScope.launch {
|
||||
target.value = target.value.copy(loading = true, error = null)
|
||||
|
||||
@@ -1,6 +1,15 @@
|
||||
package net.awan.pipelines.ui
|
||||
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.HelpOutline
|
||||
import androidx.compose.material.icons.automirrored.filled.Segment
|
||||
import androidx.compose.material.icons.automirrored.filled.Subject
|
||||
import androidx.compose.material.icons.filled.AccountTree
|
||||
import androidx.compose.material.icons.filled.Commit
|
||||
import androidx.compose.material.icons.filled.History
|
||||
import androidx.compose.runtime.Immutable
|
||||
import androidx.compose.ui.graphics.vector.ImageVector
|
||||
import java.time.OffsetDateTime
|
||||
import net.awan.pipelines.data.protocol.Protocol
|
||||
import net.awan.pipelines.data.protocol.RunStep
|
||||
import net.awan.pipelines.data.protocol.SearchArtifact
|
||||
@@ -11,22 +20,50 @@ import net.awan.pipelines.data.protocol.SearchResult
|
||||
import net.awan.pipelines.data.protocol.SearchRun
|
||||
import net.awan.pipelines.data.protocol.SearchStep
|
||||
import net.awan.pipelines.data.protocol.SearchVersion
|
||||
import net.awan.pipelines.ui.graph.artifactIcon
|
||||
import net.awan.pipelines.ui.graph.artifactKind
|
||||
import net.awan.pipelines.ui.graph.artifactKindLabel
|
||||
import net.awan.pipelines.ui.screens.runTimeline
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Row model: the badge, title and secondary line of one result. Pure (no
|
||||
// Row model: the glyph, title and secondary line of one result. Pure (no
|
||||
// Compose, no coroutines), so the mapping for every kind is unit-testable.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** The short mixed-list type badge for a result kind. */
|
||||
fun searchBadge(kind: String): String = when (kind) {
|
||||
Protocol.SEARCH_KIND_PIPELINE, Protocol.SEARCH_KIND_VERSION -> "pipeline"
|
||||
Protocol.SEARCH_KIND_RUN -> "run"
|
||||
Protocol.SEARCH_KIND_STEP -> "step"
|
||||
Protocol.SEARCH_KIND_ARTIFACT -> "artifact"
|
||||
// A text ("field") match and an unknown kind both read as a generic match;
|
||||
// the unknown one is additionally labelled read-only by [searchRow].
|
||||
else -> "match"
|
||||
/**
|
||||
* The glyph that names one result's type at a glance: the result's kind, and for
|
||||
* an artifact the file type its content resolves to. The artifact mapping is the
|
||||
* gallery's own ([artifactKind]/[artifactIcon]) rather than a second copy, so the
|
||||
* two surfaces can never disagree about a file. The payload decides the branch,
|
||||
* exactly as [searchRow] does, so a known payload with an unknown kind string
|
||||
* still gets the right glyph and an unrecognised result falls back to a neutral
|
||||
* mark instead of vanishing.
|
||||
*/
|
||||
fun searchResultIcon(hit: SearchResult): ImageVector = when {
|
||||
hit.pipeline != null -> Icons.Filled.AccountTree
|
||||
hit.version != null -> Icons.Filled.Commit
|
||||
hit.run != null -> Icons.Filled.History
|
||||
hit.step != null -> Icons.AutoMirrored.Filled.Segment
|
||||
hit.field != null -> Icons.AutoMirrored.Filled.Subject
|
||||
hit.artifact != null -> artifactIcon(artifactKind(hit.artifact.contentType, hit.artifact.name))
|
||||
else -> Icons.AutoMirrored.Filled.HelpOutline
|
||||
}
|
||||
|
||||
/**
|
||||
* The kind in words for a row's accessible description, so a screen reader hears
|
||||
* what the row is even though the glyph alone carries no text. An artifact is
|
||||
* named by its own content type ("Image artifact", "JSON artifact"), from the
|
||||
* same gallery classification [searchResultIcon] uses.
|
||||
*/
|
||||
fun searchResultKindLabel(hit: SearchResult): String = when {
|
||||
hit.pipeline != null -> "Pipeline"
|
||||
hit.version != null -> "Pipeline version"
|
||||
hit.run != null -> "Run"
|
||||
hit.step != null -> "Step"
|
||||
hit.field != null -> "Field"
|
||||
hit.artifact != null ->
|
||||
"${artifactKindLabel(artifactKind(hit.artifact.contentType, hit.artifact.name))} artifact"
|
||||
else -> "Unrecognised result"
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -38,13 +75,12 @@ fun searchBadge(kind: String): String = when (kind) {
|
||||
data class SnippetSpan(val text: String, val matched: Boolean)
|
||||
|
||||
/**
|
||||
* One rendered search row: its type badge, a title and a secondary line. [snippet]
|
||||
* is non-null only for a text ("field") match and carries the snippet split so the
|
||||
* matched span is distinguishable without colour.
|
||||
* One rendered search row: its title and a secondary line. [snippet] is non-null
|
||||
* only for a text ("field") match and carries the snippet split so the matched
|
||||
* span is distinguishable without colour.
|
||||
*/
|
||||
@Immutable
|
||||
data class SearchRow(
|
||||
val badge: String,
|
||||
val title: String,
|
||||
val secondary: String,
|
||||
val snippet: List<SnippetSpan>? = null,
|
||||
@@ -56,7 +92,6 @@ data class SearchRow(
|
||||
* renders its stable target (or a placeholder) and a `read-only` note.
|
||||
*/
|
||||
fun searchRow(hit: SearchResult, query: String): SearchRow {
|
||||
val badge = searchBadge(hit.kind)
|
||||
val pipeline: SearchPipeline? = hit.pipeline
|
||||
val version: SearchVersion? = hit.version
|
||||
val run: SearchRun? = hit.run
|
||||
@@ -65,12 +100,10 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
|
||||
val artifact: SearchArtifact? = hit.artifact
|
||||
return when {
|
||||
pipeline != null -> SearchRow(
|
||||
badge,
|
||||
pipeline.name.ifBlank { "pipeline ${pipeline.id}" },
|
||||
"pipeline ${pipeline.id} · v${pipeline.version} · ${stageCountText(pipeline.stages)}",
|
||||
)
|
||||
version != null -> SearchRow(
|
||||
badge,
|
||||
"pipeline ${version.pipelineId} · v${version.version}",
|
||||
listOfNotNull(
|
||||
version.contentHash.takeIf { it.isNotBlank() }?.let { "content $it" },
|
||||
@@ -78,7 +111,6 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
|
||||
).joinToString(" · "),
|
||||
)
|
||||
run != null -> SearchRow(
|
||||
badge,
|
||||
"run #${run.id}" + run.pipelineName.takeIf { it.isNotBlank() }?.let { " · $it" }.orEmpty(),
|
||||
listOfNotNull(
|
||||
run.status.takeIf { it.isNotBlank() },
|
||||
@@ -87,18 +119,15 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
|
||||
).joinToString(" · "),
|
||||
)
|
||||
step != null -> SearchRow(
|
||||
badge,
|
||||
"run #${step.runId} · ${step.stage.ifBlank { "step" }} visit ${step.visit}",
|
||||
stepSecondary(step),
|
||||
)
|
||||
field != null -> SearchRow(
|
||||
badge,
|
||||
"run #${field.runId} · step ${field.sequence} · ${field.field.ifBlank { "field" }}",
|
||||
field.snippet,
|
||||
snippetSpans(field.snippet, query),
|
||||
)
|
||||
artifact != null -> SearchRow(
|
||||
badge,
|
||||
artifact.name.ifBlank { "artifact" },
|
||||
listOfNotNull(
|
||||
"run #${artifact.runId}",
|
||||
@@ -108,7 +137,6 @@ fun searchRow(hit: SearchResult, query: String): SearchRow {
|
||||
).joinToString(" · "),
|
||||
)
|
||||
else -> SearchRow(
|
||||
badge,
|
||||
hit.target.ifBlank { "Unrecognised result" },
|
||||
if (hit.kind.isBlank()) "read-only" else "kind \"${hit.kind}\" · read-only",
|
||||
)
|
||||
@@ -145,6 +173,92 @@ fun snippetSpans(snippet: String, query: String): List<SnippetSpan> {
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Narrowing and ordering: the filter/sort control's pure model. Pure (no
|
||||
// Compose), so the kind narrowing and each order are unit-testable.
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* The kind narrowing the search filter control offers. [serverKind] is exactly the
|
||||
* server's SearchRequest kind vocabulary (internal/protocol/search.go), sent and
|
||||
* stored verbatim; [All] is the empty kind.
|
||||
*
|
||||
* There is deliberately no "prompts" entry: the server has no such kind (its
|
||||
* kinds are pipeline, version, run, step, field and artifact), so a filter that
|
||||
* could only ever match nothing is not offered.
|
||||
*/
|
||||
enum class SearchKindFilter(val label: String, val serverKind: String) {
|
||||
All("All kinds", ""),
|
||||
Pipelines("Pipelines", Protocol.SEARCH_KIND_PIPELINE),
|
||||
Runs("Runs", Protocol.SEARCH_KIND_RUN),
|
||||
Steps("Steps", Protocol.SEARCH_KIND_STEP),
|
||||
Fields("Fields", Protocol.SEARCH_KIND_FIELD),
|
||||
Artifacts("Artifacts", Protocol.SEARCH_KIND_ARTIFACT),
|
||||
Versions("Versions", Protocol.SEARCH_KIND_VERSION);
|
||||
|
||||
companion object {
|
||||
val Default = All
|
||||
|
||||
/** Resolves a stored kind, tolerating a blank/stale value by returning [Default]. */
|
||||
fun fromStorage(value: String?): SearchKindFilter =
|
||||
entries.firstOrNull { it.serverKind == value } ?: Default
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The orders the search sort control offers. [Relevance] keeps the server's own
|
||||
* ranking (score, then recency, then a stable kind/target tie-break). [Newest]
|
||||
* and [Name] cannot be asked of the server - its search command takes only a
|
||||
* query, an optional kind and a limit - so they order the results already in
|
||||
* hand, and the control says so.
|
||||
*/
|
||||
enum class SearchSort(val label: String, val storageKey: String) {
|
||||
Relevance("Relevance", "relevance"),
|
||||
Newest("Newest first", "newest"),
|
||||
Name("Name", "name");
|
||||
|
||||
companion object {
|
||||
val Default = Relevance
|
||||
|
||||
/** Resolves a stored order, tolerating a blank/stale value by returning [Default]. */
|
||||
fun fromStorage(value: String?): SearchSort =
|
||||
entries.firstOrNull { it.storageKey == value } ?: Default
|
||||
}
|
||||
}
|
||||
|
||||
/** The one-line summary of the active filter and sort the collapsed control shows. */
|
||||
fun searchControlsSummary(kind: SearchKindFilter, sort: SearchSort): String {
|
||||
// Only Relevance is the server's own ranking; the other orders run on the
|
||||
// results in hand, so the summary says so even when the menu is closed.
|
||||
val reach = if (sort == SearchSort.Relevance) "" else " (in hand)"
|
||||
return "${kind.label} · ${sort.label}$reach"
|
||||
}
|
||||
|
||||
/**
|
||||
* Narrows [results] to [filter]'s kind. The filter is also sent to the server
|
||||
* (SearchRequest.kind), so this only re-narrows the results already in hand,
|
||||
* keeping the panel honest while a narrowed request loads.
|
||||
*/
|
||||
fun filterSearchResults(results: List<SearchResult>, filter: SearchKindFilter): List<SearchResult> =
|
||||
if (filter == SearchKindFilter.All) results else results.filter { it.kind == filter.serverKind }
|
||||
|
||||
/**
|
||||
* Orders [results] by [sort]. [Relevance] leaves the server's ranking untouched;
|
||||
* [Newest] and [Name] sort the results in hand (the server has no sort). The
|
||||
* sorts are stable, so two results that tie keep the server's order rather than
|
||||
* swapping arbitrarily.
|
||||
*/
|
||||
fun sortSearchResults(results: List<SearchResult>, sort: SearchSort): List<SearchResult> = when (sort) {
|
||||
SearchSort.Relevance -> results
|
||||
SearchSort.Newest -> results.sortedWith(
|
||||
compareByDescending<SearchResult> { parseInstant(it.recency.orEmpty()) ?: OffsetDateTime.MIN },
|
||||
)
|
||||
SearchSort.Name -> results
|
||||
.map { it to searchRow(it, "").title }
|
||||
.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.second })
|
||||
.map { it.first }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Navigation: the destination a result resolves to. Pure, so the mapping for
|
||||
// every kind is unit-testable.
|
||||
@@ -284,6 +398,22 @@ fun SearchUiState.loaded(response: SearchResponse): SearchUiState =
|
||||
fun SearchUiState.failed(message: String?): SearchUiState =
|
||||
copy(loading = false, error = message, loaded = true)
|
||||
|
||||
/** Whether the panel shows the explicit, query-naming empty state. */
|
||||
fun SearchUiState.isEmptyResult(): Boolean =
|
||||
error == null && !loading && loaded && results.isEmpty() && query.isNotBlank()
|
||||
/**
|
||||
* The empty-state line the panel shows when it has no rows to render for [query]
|
||||
* under [kind], or null when it is showing rows, progress or nothing at all.
|
||||
* [shown] is the filtered and sorted list actually displayed, so a filter that
|
||||
* empties the list reports itself ("No runs match …") rather than the generic
|
||||
* line. Pure, so the empty state is unit-testable without a device.
|
||||
*/
|
||||
fun searchPanelEmptyMessage(
|
||||
state: SearchUiState,
|
||||
shown: List<SearchResult>,
|
||||
kind: SearchKindFilter,
|
||||
): String? = when {
|
||||
state.error != null -> null
|
||||
shown.isNotEmpty() -> null
|
||||
state.loading -> null
|
||||
state.query.isBlank() -> null
|
||||
kind == SearchKindFilter.All -> "No matches for \"${state.query}\"."
|
||||
else -> "No ${kind.label.lowercase()} match \"${state.query}\"."
|
||||
}
|
||||
|
||||
@@ -188,6 +188,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 = {
|
||||
@@ -397,9 +399,13 @@ fun PipelinesApp(
|
||||
verticalArrangement = Arrangement.Bottom,
|
||||
horizontalAlignment = destinationPillAlignment(wide),
|
||||
) {
|
||||
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()
|
||||
|
||||
@@ -12,6 +12,7 @@ import androidx.compose.foundation.lazy.items
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material3.CircularProgressIndicator
|
||||
import androidx.compose.material3.HorizontalDivider
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.LinearProgressIndicator
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.Surface
|
||||
@@ -30,31 +31,47 @@ import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.text.withStyle
|
||||
import androidx.compose.ui.unit.dp
|
||||
import net.awan.pipelines.data.protocol.SearchResult
|
||||
import net.awan.pipelines.ui.components.LabelChip
|
||||
import net.awan.pipelines.ui.components.FilterCheckItem
|
||||
import net.awan.pipelines.ui.components.FilterMenu
|
||||
import net.awan.pipelines.ui.components.SortMenu
|
||||
import net.awan.pipelines.ui.theme.ICON_LIST_DP
|
||||
import net.awan.pipelines.ui.theme.SEARCH_PROGRESS_DP
|
||||
import net.awan.pipelines.ui.theme.SPACING_L
|
||||
import net.awan.pipelines.ui.theme.SPACING_M
|
||||
import net.awan.pipelines.ui.theme.SPACING_S
|
||||
import net.awan.pipelines.ui.theme.SPACING_XXS
|
||||
import net.awan.pipelines.ui.theme.SPACING_XL
|
||||
import net.awan.pipelines.ui.theme.SPACING_XS
|
||||
import net.awan.pipelines.ui.theme.SPACING_XXS
|
||||
import net.awan.pipelines.ui.theme.pipelinesText
|
||||
|
||||
/**
|
||||
* The omni-search results panel: one scrolling surface that sits above the search
|
||||
* field. It renders the last accepted results, and while a newer query loads it
|
||||
* keeps those results and adds a thin progress bar rather than blanking; a
|
||||
* failure is reported without discarding what is already shown. Its height is
|
||||
* bounded by the caller (the window's IME/navigation-bar insets), so it scrolls
|
||||
* inside the remainder instead of running under the keyboard.
|
||||
* field. It leads with the filter and sort controls (the same shared menu
|
||||
* controls the runs list uses), then renders the last accepted results; while a
|
||||
* newer query loads it keeps those results and adds a thin progress bar rather
|
||||
* than blanking, and a failure is reported without discarding what is already
|
||||
* shown. Its height is bounded by the caller (the window's IME/navigation-bar
|
||||
* insets), so it scrolls inside the remainder instead of running under the
|
||||
* keyboard.
|
||||
*/
|
||||
@Composable
|
||||
internal fun SearchResultsPanel(
|
||||
state: SearchUiState,
|
||||
kind: SearchKindFilter,
|
||||
sort: SearchSort,
|
||||
onKind: (SearchKindFilter) -> Unit,
|
||||
onSort: (SearchSort) -> Unit,
|
||||
onSelect: (SearchResult) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
) {
|
||||
val scheme = MaterialTheme.colorScheme
|
||||
val error = state.error
|
||||
// The filter and sort are applied to the results in hand as well as being sent
|
||||
// to the server (the kind) or held client-side (the order), so the list always
|
||||
// matches the active control, even for the moment a narrowed request loads.
|
||||
val shown = remember(state.results, kind, sort) {
|
||||
sortSearchResults(filterSearchResults(state.results, kind), sort)
|
||||
}
|
||||
Surface(
|
||||
modifier = modifier,
|
||||
shape = RoundedCornerShape(SPACING_XL),
|
||||
@@ -63,6 +80,8 @@ internal fun SearchResultsPanel(
|
||||
shadowElevation = 6.dp,
|
||||
) {
|
||||
Column(Modifier.fillMaxWidth()) {
|
||||
SearchControls(kind = kind, sort = sort, onKind = onKind, onSort = onSort)
|
||||
HorizontalDivider(color = scheme.outlineVariant)
|
||||
// A refresh of an already-populated panel shows progress without
|
||||
// replacing the results; the first load shows the searching row below.
|
||||
if (state.loading && state.results.isNotEmpty()) {
|
||||
@@ -70,14 +89,68 @@ internal fun SearchResultsPanel(
|
||||
}
|
||||
when {
|
||||
error != null -> PanelMessage(error, isError = true)
|
||||
state.isEmptyResult() -> PanelMessage("No matches for \"${state.query}\".", isError = false)
|
||||
shown.isNotEmpty() -> SearchResultList(shown, state.query, onSelect)
|
||||
state.loading && state.results.isEmpty() -> SearchingRow()
|
||||
state.results.isNotEmpty() -> SearchResultList(state.results, state.query, onSelect)
|
||||
else -> searchPanelEmptyMessage(state, shown, kind)?.let { PanelMessage(it, isError = false) }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The search surface's filter and sort control, the same shared [FilterMenu] and
|
||||
* [SortMenu] the runs list uses rather than a new pattern, plus the one-line
|
||||
* summary of the active choice so the collapsed controls are legible. The kind
|
||||
* filter narrows server-side; the sort orders the results in hand.
|
||||
*/
|
||||
@Composable
|
||||
private fun SearchControls(
|
||||
kind: SearchKindFilter,
|
||||
sort: SearchSort,
|
||||
onKind: (SearchKindFilter) -> Unit,
|
||||
onSort: (SearchSort) -> Unit,
|
||||
) {
|
||||
Row(
|
||||
// The top inset leaves room for the filter badge, which is drawn above the
|
||||
// icon button; without it the badge spills over the panel's rounded edge.
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(start = SPACING_S, end = SPACING_XS, top = SPACING_S, bottom = SPACING_XS),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(SPACING_XS),
|
||||
) {
|
||||
FilterMenu(
|
||||
activeCount = if (kind == SearchKindFilter.All) 0 else 1,
|
||||
contentDescription = "Filter results",
|
||||
resetLabel = "Clear filter",
|
||||
onReset = { onKind(SearchKindFilter.Default) },
|
||||
) { dismiss ->
|
||||
SearchKindFilter.entries.forEach { option ->
|
||||
FilterCheckItem(option.label, option == kind) {
|
||||
onKind(option)
|
||||
dismiss()
|
||||
}
|
||||
}
|
||||
}
|
||||
SortMenu(
|
||||
options = SearchSort.entries,
|
||||
selected = sort,
|
||||
label = { it.label },
|
||||
header = "Sort results in hand",
|
||||
contentDescription = "Sort results in hand",
|
||||
onSelect = onSort,
|
||||
onReset = { onSort(SearchSort.Default) },
|
||||
)
|
||||
Text(
|
||||
text = searchControlsSummary(kind, sort),
|
||||
style = pipelinesText().meta,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
modifier = Modifier.weight(1f).padding(start = SPACING_S),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun PanelMessage(message: String, isError: Boolean) {
|
||||
Text(
|
||||
@@ -127,10 +200,12 @@ private fun SearchResultList(
|
||||
}
|
||||
|
||||
/**
|
||||
* One result row: its type badge, a title and a secondary line. A text match's
|
||||
* secondary line is its snippet with the matched span rendered bold+underlined,
|
||||
* so the match is distinguishable without relying on colour. A result with no
|
||||
* navigation target (an unknown kind) is shown read-only and is not clickable.
|
||||
* One result row: the type glyph (its kind, or an artifact's content type), a
|
||||
* title and a secondary line. The glyph carries the kind in words as its
|
||||
* content description, since the mark alone is not readable, and the matched span
|
||||
* of a text match is rendered bold+underlined, so the match is distinguishable
|
||||
* without relying on colour. A result with no navigation target (an unknown kind)
|
||||
* is shown read-only and is not clickable.
|
||||
*/
|
||||
@Composable
|
||||
private fun SearchResultRow(
|
||||
@@ -151,9 +226,15 @@ private fun SearchResultRow(
|
||||
},
|
||||
)
|
||||
.padding(horizontal = SPACING_L, vertical = SPACING_M),
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(SPACING_M),
|
||||
) {
|
||||
LabelChip(row.badge, SPACING_S, SPACING_XXS)
|
||||
Icon(
|
||||
imageVector = searchResultIcon(hit),
|
||||
contentDescription = searchResultKindLabel(hit),
|
||||
tint = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.size(ICON_LIST_DP),
|
||||
)
|
||||
Column(
|
||||
modifier = Modifier.weight(1f),
|
||||
verticalArrangement = Arrangement.spacedBy(SPACING_XXS),
|
||||
|
||||
@@ -51,9 +51,9 @@ internal fun ChatComposer(
|
||||
}
|
||||
Surface(color = MaterialTheme.colorScheme.surfaceContainer) {
|
||||
Column(Modifier.fillMaxWidth().padding(CHAT_GUTTER)) {
|
||||
if (thread.readOnly) {
|
||||
if (thread.queued) {
|
||||
Text(
|
||||
text = "Another client holds this session; it is read-only here.",
|
||||
text = "Queued — it will send when the current turn finishes.",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(bottom = CHAT_ITEM_GAP),
|
||||
@@ -65,14 +65,12 @@ internal fun ChatComposer(
|
||||
Row(verticalAlignment = Alignment.Bottom, horizontalArrangement = Arrangement.spacedBy(CHAT_COMPOSER_GAP)) {
|
||||
IconButton(
|
||||
onClick = { picker.launch(arrayOf("*/*")) },
|
||||
enabled = !thread.readOnly,
|
||||
) {
|
||||
Icon(Icons.Default.AttachFile, contentDescription = "Attach file")
|
||||
}
|
||||
OutlinedTextField(
|
||||
value = thread.draft,
|
||||
onValueChange = onDraft,
|
||||
enabled = !thread.readOnly,
|
||||
placeholder = { Text("Message the agent…") },
|
||||
minLines = 1,
|
||||
maxLines = 6,
|
||||
|
||||
@@ -213,11 +213,7 @@ internal fun ChatConversationPane(
|
||||
onRetry = { vm.loadChatHistory(thread.sessionId) },
|
||||
)
|
||||
thread.messages.isEmpty() && !thread.running && approval == null -> EmptyState(
|
||||
message = if (thread.readOnly) {
|
||||
"This chat is read-only while another client holds the session."
|
||||
} else {
|
||||
"This chat has no messages yet. Ask something below."
|
||||
},
|
||||
message = "This chat has no messages yet. Ask something below.",
|
||||
)
|
||||
else -> ChatTranscript(
|
||||
thread = thread,
|
||||
|
||||
@@ -7,6 +7,7 @@ import kotlinx.serialization.json.JsonObject
|
||||
import kotlinx.serialization.json.JsonPrimitive
|
||||
import net.awan.pipelines.data.protocol.ChatPart
|
||||
import net.awan.pipelines.data.protocol.ChatPermissionFrame
|
||||
import net.awan.pipelines.data.protocol.ChatMessage
|
||||
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||
import net.awan.pipelines.data.protocol.ChatSession
|
||||
import net.awan.pipelines.data.protocol.ChatToolState
|
||||
@@ -79,6 +80,126 @@ internal fun formatToolDuration(millis: Long): String = when {
|
||||
/** The chip label for a tool call: its name, or a placeholder when unnamed. */
|
||||
internal fun toolLabel(part: ChatPart): String = part.name.ifBlank { "tool" }
|
||||
|
||||
/**
|
||||
* The in-flight tool calls across a conversation's [messages], in transcript
|
||||
* order, so the conversation's indicator and the session row read the same set
|
||||
* and its order is stable from frame to frame (a chip is never re-ordered by a
|
||||
* rebuild). A call drops out the moment it completes or errors, which is what
|
||||
* clears the indicator, so nothing here ever invents a finish time.
|
||||
*/
|
||||
internal fun runningToolCalls(messages: List<ChatMessage>): List<ChatPart> =
|
||||
messages.flatMap { it.parts }
|
||||
.filter { it.type == ChatProtocol.PART_TOOL && ChatProtocol.toolRunning(it.state) }
|
||||
|
||||
/**
|
||||
* The input keys, in preference order, that carry a human-facing command or a
|
||||
* short description of what a tool call is doing. OpenCode's tools put the
|
||||
* substance in different places (`command` for a shell, `description` for a task,
|
||||
* a path or pattern for the file/search tools), so the first one present is shown
|
||||
* rather than the raw arguments.
|
||||
*/
|
||||
private val TOOL_DETAIL_KEYS = listOf(
|
||||
"description", "command", "filePath", "file_path", "path", "pattern", "query", "url",
|
||||
)
|
||||
|
||||
/** How much of a command/description the phone shows before it is elided. */
|
||||
private const val TOOL_DETAIL_MAX_LENGTH = 72
|
||||
|
||||
private val TOOL_DETAIL_WHITESPACE = Regex("\\s+")
|
||||
|
||||
/**
|
||||
* A one-line command or short description for [part], taken from the input the
|
||||
* part actually carries: the first of [TOOL_DETAIL_KEYS] present, collapsed to a
|
||||
* single line and elided past [TOOL_DETAIL_MAX_LENGTH]. Null when the input
|
||||
* carries no such key (a partial-JSON string while the call is still streaming,
|
||||
* or a tool that reports none), so a caller shows the name alone rather than a
|
||||
* fabricated summary.
|
||||
*/
|
||||
internal fun toolDetail(part: ChatPart): String? {
|
||||
val obj = part.state?.input as? JsonObject ?: return null
|
||||
for (key in TOOL_DETAIL_KEYS) {
|
||||
val value = obj[key] as? JsonPrimitive ?: continue
|
||||
if (!value.isString) continue
|
||||
val text = value.content.trim().replace(TOOL_DETAIL_WHITESPACE, " ")
|
||||
if (text.isBlank()) continue
|
||||
return if (text.length <= TOOL_DETAIL_MAX_LENGTH) {
|
||||
text
|
||||
} else {
|
||||
text.take(TOOL_DETAIL_MAX_LENGTH - 1).trimEnd() + "…"
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/**
|
||||
* How long a running [part] has been going at [nowMillis]. The protocol's own
|
||||
* timing wins whenever the part carries it (a running call from stored history
|
||||
* has `time.ran`, the moment it started); otherwise the elapsed is measured
|
||||
* locally from [startedAt] — the wall clock at which this client first saw the
|
||||
* part running. Zero when neither is usable, so a caller never shows a time it
|
||||
* cannot stand behind.
|
||||
*/
|
||||
internal fun runningToolElapsedMillis(part: ChatPart, startedAt: Long, nowMillis: Long): Long {
|
||||
val protocolStart = part.time?.let { if (it.ran > 0) it.ran else it.created } ?: 0L
|
||||
val start = if (protocolStart > 0) protocolStart else startedAt
|
||||
return if (start in 1 until nowMillis) nowMillis - start else 0L
|
||||
}
|
||||
|
||||
/**
|
||||
* A tool call running longer than this reads as unusually long on the phone and
|
||||
* is marked, so a genuinely stuck call is visible without a fabricated ETA. One
|
||||
* minute: long enough that ordinary calls (a build, a search, a command) are not
|
||||
* flagged, short enough that a hung call stands out while the operator is still
|
||||
* wondering.
|
||||
*/
|
||||
internal const val TOOL_LONG_RUNNING_MILLIS: Long = 60_000L
|
||||
|
||||
/** Whether a running call has been going long enough to be marked as unusual. */
|
||||
internal fun toolLongRunning(elapsedMillis: Long): Boolean = elapsedMillis >= TOOL_LONG_RUNNING_MILLIS
|
||||
|
||||
/**
|
||||
* The running-tool start stamps after a thread's [messages] changed: every tool
|
||||
* part in flight keeps the stamp it already had, or is stamped with [now] when it
|
||||
* has just turned running, and a part that is no longer running loses its stamp.
|
||||
* Kept free of Compose and of [ChatStore] so the bookkeeping and its unit test
|
||||
* share one rule, and a stamp never moves forward while a call keeps running.
|
||||
*/
|
||||
internal fun runningToolStamps(
|
||||
current: Map<String, Long>,
|
||||
messages: List<ChatMessage>,
|
||||
now: Long,
|
||||
): Map<String, Long> {
|
||||
val stamps = LinkedHashMap<String, Long>()
|
||||
messages.forEach { message ->
|
||||
message.parts.forEach { part ->
|
||||
if (part.id.isNotEmpty() && part.type == ChatProtocol.PART_TOOL && ChatProtocol.toolRunning(part.state)) {
|
||||
stamps[part.id] = current[part.id] ?: now
|
||||
}
|
||||
}
|
||||
}
|
||||
return stamps
|
||||
}
|
||||
|
||||
/**
|
||||
* The status a session row reports while a turn is in flight: it names the tool
|
||||
* call it is parked on (or how many, when several run at once) so a working chat
|
||||
* says what it is doing rather than just `Running`, and a chat only generating
|
||||
* text still reads as plain `Running` — the two are never confused. A chat with
|
||||
* nothing running falls back to the ordinary busy/idle label, so a session
|
||||
* waiting on another client is never shown as idle.
|
||||
*/
|
||||
internal fun sessionWorkLabel(busy: Boolean, thread: ChatThread?): String = when {
|
||||
thread?.running == true -> runningSessionLabel(thread.runningTools)
|
||||
busy -> "Busy · read-only"
|
||||
else -> "Idle"
|
||||
}
|
||||
|
||||
private fun runningSessionLabel(tools: List<ChatPart>): String = when (tools.size) {
|
||||
0 -> "Running"
|
||||
1 -> "Running ${toolLabel(tools.single())}"
|
||||
else -> "Running ${tools.size} tools"
|
||||
}
|
||||
|
||||
/**
|
||||
* A session's short title: the server title, or a truncated id when untitled, so
|
||||
* a row never renders as a blank line.
|
||||
@@ -125,21 +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)
|
||||
sessionStatusLabel(runningLocally, session.closed)
|
||||
|
||||
/** The status of a conversation from its own model flags (see [sessionStatusLabel]). */
|
||||
internal fun sessionStatusLabel(busy: Boolean, runningLocally: Boolean): String = when {
|
||||
/**
|
||||
* 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(runningLocally: Boolean, closed: Boolean = false): String = when {
|
||||
closed -> "Closed"
|
||||
runningLocally -> "Running"
|
||||
busy -> "Busy · read-only"
|
||||
else -> "Idle"
|
||||
}
|
||||
|
||||
@@ -183,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),
|
||||
activity = sessionStatusLabel(thread.running, thread.closed),
|
||||
directory = thread.directory,
|
||||
model = thread.model,
|
||||
)
|
||||
@@ -273,6 +397,19 @@ internal fun reasoningLabel(count: Int, streaming: Boolean): String = when {
|
||||
else -> REASONING_SETTLED_LABEL
|
||||
}
|
||||
|
||||
/**
|
||||
* The close confirmation's body: it says exactly what closing does — stops a
|
||||
* running turn, marks the chat closed on every device — and what it does not do:
|
||||
* nothing is deleted, the chat and its history are kept and can be reopened. Kept
|
||||
* pure so the confirmation wording and its unit test share one string instead of
|
||||
* the copy drifting from the promise.
|
||||
*/
|
||||
internal fun closeChatConfirmation(title: String): String =
|
||||
"Closes \"$title\" and marks it closed on every device. " +
|
||||
"A turn that is running is stopped first. " +
|
||||
"Nothing is deleted — the chat and its history are kept, " +
|
||||
"and you can reopen it from the list."
|
||||
|
||||
/**
|
||||
* The elapsed time the server's own timing gives a settled turn: from the
|
||||
* earliest start to the latest completion across the parts that carry a timing
|
||||
|
||||
@@ -96,10 +96,12 @@ internal fun ChatListPane(
|
||||
// The server returns operator sessions only, with the operator's own local
|
||||
// renames and removals applied on top; the app never guesses which session
|
||||
// belongs to a run. The operator's search narrows that list without touching
|
||||
// its order, and the survivors are grouped by directory when there is more
|
||||
// than one so sessions in the same repository sit together.
|
||||
// its order. Active sessions are grouped by directory when there is more than
|
||||
// one; the closed ones the operator finished with sit below them as history.
|
||||
val sessions = state.filteredSessions
|
||||
val groups = groupChatSessionsByDirectory(sessions)
|
||||
val active = state.activeSessions
|
||||
val closed = state.closedSessions
|
||||
val groups = groupChatSessionsByDirectory(active)
|
||||
val query = state.sessionQuery
|
||||
|
||||
// A removal is reported for what it is: a local, undoable change, never a
|
||||
@@ -117,6 +119,7 @@ internal fun ChatListPane(
|
||||
}
|
||||
}
|
||||
var renaming by remember { mutableStateOf<ChatSession?>(null) }
|
||||
var closing by remember { mutableStateOf<ChatSession?>(null) }
|
||||
|
||||
Scaffold(
|
||||
modifier = modifier,
|
||||
@@ -182,12 +185,21 @@ internal fun ChatListPane(
|
||||
groups.forEach { group ->
|
||||
item(key = "dir-" + group.directory) { DirectoryHeader(group.directory) }
|
||||
items(group.sessions, key = { it.id }) { session ->
|
||||
SessionListItem(state, session, vm, onRename = { renaming = it })
|
||||
SessionListItem(state, session, vm, onRename = { renaming = it }, onClose = { closing = it })
|
||||
}
|
||||
}
|
||||
} else {
|
||||
items(sessions, key = { it.id }) { session ->
|
||||
SessionListItem(state, session, vm, onRename = { renaming = it })
|
||||
items(active, key = { it.id }) { session ->
|
||||
SessionListItem(state, session, vm, onRename = { renaming = it }, onClose = { closing = it })
|
||||
}
|
||||
}
|
||||
if (closed.isNotEmpty()) {
|
||||
// Finished chats stay reachable as history: a clearly
|
||||
// labelled section, in the same recency order, from which
|
||||
// each one can be reopened.
|
||||
item(key = "closed-header") { DirectoryHeader(CLOSED_SECTION_LABEL) }
|
||||
items(closed, key = { it.id }) { session ->
|
||||
SessionListItem(state, session, vm, onRename = { renaming = it }, onClose = { closing = it })
|
||||
}
|
||||
}
|
||||
if (state.sessionsError != null) {
|
||||
@@ -216,6 +228,16 @@ internal fun ChatListPane(
|
||||
},
|
||||
)
|
||||
}
|
||||
closing?.let { session ->
|
||||
CloseChatDialog(
|
||||
session = session,
|
||||
onDismiss = { closing = null },
|
||||
onConfirm = {
|
||||
vm.closeChatSession(session.id)
|
||||
closing = null
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -256,17 +278,20 @@ private fun SessionListItem(
|
||||
session: ChatSession,
|
||||
vm: AppViewModel,
|
||||
onRename: (ChatSession) -> Unit,
|
||||
onClose: (ChatSession) -> Unit,
|
||||
) {
|
||||
val thread = state.thread(session.id)
|
||||
SessionRow(
|
||||
session = session,
|
||||
thread = thread,
|
||||
open = thread != null,
|
||||
running = thread?.running == true,
|
||||
unseen = state.isUnseen(session),
|
||||
unseen = !session.closed && state.isUnseen(session),
|
||||
active = state.activeId == session.id,
|
||||
onClick = { vm.openChatSession(session) },
|
||||
onRename = { onRename(session) },
|
||||
onRemove = { vm.removeChat(session.id) },
|
||||
onClose = { onClose(session) },
|
||||
onReopen = { vm.reopenChatSession(session.id) },
|
||||
onHide = { vm.removeChat(session.id) },
|
||||
)
|
||||
}
|
||||
|
||||
@@ -294,15 +319,18 @@ 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,
|
||||
onRename: () -> Unit,
|
||||
onRemove: () -> Unit,
|
||||
onClose: () -> Unit,
|
||||
onReopen: () -> Unit,
|
||||
onHide: () -> Unit,
|
||||
) {
|
||||
val texts = pipelinesText()
|
||||
val running = thread?.running == true
|
||||
val activity = sessionActivity(running, unseen)
|
||||
ListRow(selected = active, onClick = onClick) {
|
||||
Row(
|
||||
@@ -320,13 +348,23 @@ private fun SessionRow(
|
||||
// The kind chip names the session kind the server reported, so an
|
||||
// operator chat is tellable from anything run-related at a glance.
|
||||
sessionTagLabel(session)?.let { LabelChip(it, SPACING_S, SPACING_XXS) }
|
||||
// A closed chat is named as such on the row itself, so it is never
|
||||
// confused with a hide (which only affects this device) or with a
|
||||
// still-open chat.
|
||||
if (session.closed) LabelChip(CLOSED_CHIP_LABEL, SPACING_S, SPACING_XXS)
|
||||
// The activity badge is the new-activity signal; the tag and the
|
||||
// directory below are unchanged beside it.
|
||||
SessionActivityBadge(activity, open)
|
||||
SessionMenu(onRename = onRename, onRemove = onRemove)
|
||||
SessionMenu(
|
||||
closed = session.closed,
|
||||
onRename = onRename,
|
||||
onClose = onClose,
|
||||
onReopen = onReopen,
|
||||
onHide = onHide,
|
||||
)
|
||||
}
|
||||
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(" · ")
|
||||
@@ -334,9 +372,19 @@ private fun SessionRow(
|
||||
}
|
||||
}
|
||||
|
||||
/** A session row's management actions: rename and remove from this device's list. */
|
||||
/**
|
||||
* A session row's management actions. Closing is the real, server-side finish
|
||||
* (shared by every device); hiding only affects this device and is named so the
|
||||
* two cannot be confused. A closed chat offers Reopen instead of Close.
|
||||
*/
|
||||
@Composable
|
||||
private fun SessionMenu(onRename: () -> Unit, onRemove: () -> Unit) {
|
||||
private fun SessionMenu(
|
||||
closed: Boolean,
|
||||
onRename: () -> Unit,
|
||||
onClose: () -> Unit,
|
||||
onReopen: () -> Unit,
|
||||
onHide: () -> Unit,
|
||||
) {
|
||||
var expanded by remember { mutableStateOf(false) }
|
||||
Box {
|
||||
IconButton(onClick = { expanded = true }, modifier = Modifier.size(ICON_BUTTON_SMALL_DP)) {
|
||||
@@ -354,17 +402,52 @@ private fun SessionMenu(onRename: () -> Unit, onRemove: () -> Unit) {
|
||||
onRename()
|
||||
},
|
||||
)
|
||||
if (closed) {
|
||||
DropdownMenuItem(
|
||||
text = { Text("Reopen") },
|
||||
onClick = {
|
||||
expanded = false
|
||||
onReopen()
|
||||
},
|
||||
)
|
||||
} else {
|
||||
DropdownMenuItem(
|
||||
text = { Text("Close chat…") },
|
||||
onClick = {
|
||||
expanded = false
|
||||
onClose()
|
||||
},
|
||||
)
|
||||
}
|
||||
DropdownMenuItem(
|
||||
text = { Text("Remove from list") },
|
||||
text = { Text("Hide on this device") },
|
||||
onClick = {
|
||||
expanded = false
|
||||
onRemove()
|
||||
onHide()
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The close confirmation. It says exactly what closing does and does not do:
|
||||
* stops any running turn, keeps the whole history, and marks the chat closed for
|
||||
* every device — never a delete, and distinct from the local hide.
|
||||
*/
|
||||
@Composable
|
||||
private fun CloseChatDialog(session: ChatSession, onDismiss: () -> Unit, onConfirm: () -> Unit) {
|
||||
AlertDialog(
|
||||
onDismissRequest = onDismiss,
|
||||
title = { Text("Close chat?") },
|
||||
text = {
|
||||
Text(closeChatConfirmation(sessionTitle(session)))
|
||||
},
|
||||
confirmButton = { TextButton(onClick = onConfirm) { Text("Close chat") } },
|
||||
dismissButton = { TextButton(onClick = onDismiss) { Text("Cancel") } },
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* The rename dialog. The brokered protocol has no rename for a chat session, so
|
||||
* the dialog says plainly that the name is kept on this device rather than
|
||||
@@ -400,7 +483,13 @@ private fun RenameChatDialog(session: ChatSession, onDismiss: () -> Unit, onConf
|
||||
}
|
||||
|
||||
/** The removal report: what happened and how to undo it. */
|
||||
private const val CHAT_REMOVED_MESSAGE = "Removed from this list; the chat stays on the server."
|
||||
private const val CHAT_REMOVED_MESSAGE = "Hidden on this device; the chat stays on the server."
|
||||
|
||||
/** The row chip and section heading for a chat the operator finished with. */
|
||||
private const val CLOSED_CHIP_LABEL = "Closed"
|
||||
|
||||
/** The heading of the section that keeps closed chats reachable as history. */
|
||||
private const val CLOSED_SECTION_LABEL = "Closed"
|
||||
|
||||
/** A running/busy/open indicator: a coloured dot plus a word, never colour alone. */
|
||||
@Composable
|
||||
|
||||
@@ -5,16 +5,17 @@ import net.awan.pipelines.data.protocol.PipelinesJson
|
||||
|
||||
/**
|
||||
* The operator's own changes to the session list, which the server has no
|
||||
* request for: a chat cannot be renamed or deleted through the brokered
|
||||
* protocol (there is no chat_rename/chat_delete type, and the OpenCode session
|
||||
* endpoint is not exposed), so both are kept here, on the device, and applied
|
||||
* over whatever the server lists.
|
||||
* request for: a chat cannot be renamed through the brokered protocol (there is
|
||||
* no chat_rename type), so it is kept here, on the device, and applied over
|
||||
* whatever the server lists. Closing a chat and reopening it are *not* here: they
|
||||
* are server-side (`chat_close`/`chat_reopen`) so every device sees them.
|
||||
*
|
||||
* - [titles] are local renames, keyed by session id; a renamed chat shows its
|
||||
* local title and the server's title is left untouched.
|
||||
* - [hidden] are sessions the operator removed from the list. Nothing is deleted
|
||||
* on the server, so the removal is honest and reversible ([remove] can be
|
||||
* undone with [restore]).
|
||||
* - [hidden] are sessions the operator hid on this device. Nothing is deleted on
|
||||
* the server, and no other device is affected, so the hide is honest and
|
||||
* reversible ([remove] can be undone with [restore]). It is distinct from a
|
||||
* server-side close, which marks the chat closed for every client.
|
||||
*
|
||||
* Kept as a serializable value so it survives a restart as one preference,
|
||||
* exactly like the app's other stored settings.
|
||||
|
||||
@@ -57,6 +57,12 @@ data class ChatThread(
|
||||
val updatedAt: Long = 0,
|
||||
/** The server reports another client (or an active run) holds this session. */
|
||||
val busy: Boolean = false,
|
||||
/**
|
||||
* The server reports this session closed: the operator finished with it. The
|
||||
* conversation and its history are kept; the chat can be reopened, and sending
|
||||
* another message reopens it too.
|
||||
*/
|
||||
val closed: Boolean = false,
|
||||
val messages: List<ChatMessage> = emptyList(),
|
||||
val loading: Boolean = false,
|
||||
val loaded: Boolean = false,
|
||||
@@ -70,6 +76,15 @@ data class ChatThread(
|
||||
* the turn settles.
|
||||
*/
|
||||
val runningSince: Long = 0,
|
||||
/**
|
||||
* Wall-clock epoch millis each currently-running tool call was first seen
|
||||
* running, keyed by the tool part's id. The brokered stream pushes a tool part
|
||||
* with no timing envelope, so a running call's elapsed time is measured from
|
||||
* here; a call that settles loses its stamp. Kept on the thread (not in the
|
||||
* composable) so the elapsed time survives a chat switch, exactly like
|
||||
* [runningSince] does for the turn.
|
||||
*/
|
||||
val toolStartedAt: Map<String, Long> = emptyMap(),
|
||||
/** The unsent composer text for this chat. */
|
||||
val draft: String = "",
|
||||
/**
|
||||
@@ -94,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
|
||||
@@ -120,6 +137,22 @@ data class ChatThread(
|
||||
*/
|
||||
fun elapsedMillis(nowMillis: Long): Long =
|
||||
if (running && runningSince in 1 until nowMillis) nowMillis - runningSince else 0
|
||||
|
||||
/**
|
||||
* The tool calls still in flight for this session, in transcript order, so the
|
||||
* conversation's in-flight indicator and the session row both read the same
|
||||
* set. Empty once every call has completed or errored, which is what clears
|
||||
* the indicator.
|
||||
*/
|
||||
val runningTools: List<ChatPart> get() = runningToolCalls(messages)
|
||||
|
||||
/**
|
||||
* How long [part] has been running at [nowMillis]: the protocol's own timing
|
||||
* when the part carries it, else the local start recorded in [toolStartedAt]
|
||||
* (see [runningToolElapsedMillis]). Zero when neither is usable.
|
||||
*/
|
||||
fun toolElapsedMillis(part: ChatPart, nowMillis: Long): Long =
|
||||
runningToolElapsedMillis(part, toolStartedAt[part.id] ?: 0L, nowMillis)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -225,6 +258,21 @@ data class ChatState(
|
||||
*/
|
||||
val filteredSessions: List<ChatSession>
|
||||
get() = filterChatSessions(visibleSessions, sessionQuery)
|
||||
|
||||
/**
|
||||
* The sessions still in play: [filteredSessions] without the closed ones, in
|
||||
* the same recency order. The list shows these as the active conversations.
|
||||
*/
|
||||
val activeSessions: List<ChatSession>
|
||||
get() = filteredSessions.filterNot { it.closed }
|
||||
|
||||
/**
|
||||
* The finished sessions: [filteredSessions] the server reports as closed, in
|
||||
* the same order. They are shown as history — nothing was deleted — and can be
|
||||
* reopened from the list.
|
||||
*/
|
||||
val closedSessions: List<ChatSession>
|
||||
get() = filteredSessions.filter { it.closed }
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -304,6 +352,7 @@ class ChatStore(
|
||||
agent = session.agent.ifBlank { thread.agent },
|
||||
tag = session.tag.ifBlank { thread.tag },
|
||||
busy = session.busy,
|
||||
closed = session.closed,
|
||||
)
|
||||
}
|
||||
// Fold the read state in: the active conversation is on screen, so its
|
||||
@@ -405,9 +454,11 @@ class ChatStore(
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a session from the device's list and closes its conversation, if
|
||||
* open. Nothing is deleted on the server — the session still exists there — so
|
||||
* the removal is honest and reversible through [undoRemove].
|
||||
* Hides a session on this device only and closes its conversation, if open.
|
||||
* Nothing is deleted on the server — the session still exists there — and no
|
||||
* other device is affected, so the hide is honest and reversible through
|
||||
* [undoRemove]. It is deliberately not a "close": the server-side close (see
|
||||
* [sessionClosed]) is shared by every client.
|
||||
*/
|
||||
fun remove(sessionId: String) {
|
||||
if (sessionId.isBlank()) return
|
||||
@@ -429,6 +480,44 @@ class ChatStore(
|
||||
)
|
||||
}
|
||||
|
||||
// ---- Closing and reopening (server-side, shared by every client) ---------
|
||||
|
||||
/**
|
||||
* Records that the server closed [sessionId]: the row is marked closed with
|
||||
* the server's [closedAt] and any in-flight turn is settled, because the
|
||||
* server stopped it. The session is not removed from [ChatState.sessions] —
|
||||
* closed chats stay listed as history.
|
||||
*/
|
||||
fun sessionClosed(sessionId: String, closedAt: Long) {
|
||||
if (sessionId.isBlank()) return
|
||||
val at = if (closedAt > 0) closedAt else now()
|
||||
_state.value = _state.value.copy(
|
||||
sessions = _state.value.sessions.map {
|
||||
if (it.id == sessionId) it.copy(closed = true, closedAt = at) else it
|
||||
},
|
||||
open = _state.value.open.map {
|
||||
if (it.sessionId == sessionId) setRunning(it.copy(closed = true), false) else it
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears the closed state of [sessionId] — an explicit reopen, or a prompt
|
||||
* that the server treated as reopening it — so the chat returns to the active
|
||||
* list without a re-fetch.
|
||||
*/
|
||||
fun sessionReopened(sessionId: String) {
|
||||
if (sessionId.isBlank()) return
|
||||
_state.value = _state.value.copy(
|
||||
sessions = _state.value.sessions.map {
|
||||
if (it.id == sessionId) it.copy(closed = false, closedAt = 0) else it
|
||||
},
|
||||
open = _state.value.open.map {
|
||||
if (it.sessionId == sessionId) it.copy(closed = false) else it
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
// ---- Opening / switching -------------------------------------------------
|
||||
|
||||
/**
|
||||
@@ -454,6 +543,7 @@ class ChatStore(
|
||||
agent = session.agent,
|
||||
updatedAt = session.updatedAt,
|
||||
busy = session.busy,
|
||||
closed = session.closed,
|
||||
)
|
||||
_state.value = _state.value.copy(open = _state.value.open + thread, activeId = session.id, seen = seen)
|
||||
return true
|
||||
@@ -465,6 +555,7 @@ class ChatStore(
|
||||
agent = session.agent.ifBlank { existing.agent },
|
||||
tag = session.tag.ifBlank { existing.tag },
|
||||
busy = session.busy,
|
||||
closed = session.closed,
|
||||
)
|
||||
_state.value = _state.value.copy(
|
||||
open = _state.value.open.map { if (it.sessionId == session.id) merged else it },
|
||||
@@ -580,7 +671,16 @@ class ChatStore(
|
||||
*/
|
||||
fun history(sessionId: String, messages: List<ChatMessage>) {
|
||||
update(sessionId) {
|
||||
it.copy(messages = messages, loading = false, loaded = true, error = null)
|
||||
it.copy(
|
||||
messages = messages,
|
||||
loading = false,
|
||||
loaded = true,
|
||||
error = null,
|
||||
// A running call the history reports (a turn that started before
|
||||
// this fetch) is stamped now, the best local measurement there is;
|
||||
// a call that already settled drops its stamp.
|
||||
toolStartedAt = runningToolStamps(it.toolStartedAt, messages, now()),
|
||||
)
|
||||
}
|
||||
// A conversation on screen is read as its history arrives: its recency
|
||||
// watermark advances to the newest message the server reports (its own
|
||||
@@ -593,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
|
||||
@@ -605,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
|
||||
}
|
||||
@@ -707,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 -> {
|
||||
@@ -718,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.
|
||||
@@ -733,6 +868,7 @@ class ChatStore(
|
||||
agent = session?.agent ?: "",
|
||||
tag = session?.tag ?: "",
|
||||
busy = session?.busy ?: false,
|
||||
closed = session?.closed ?: false,
|
||||
)
|
||||
_state.value = _state.value.copy(open = _state.value.open + placeholder)
|
||||
}
|
||||
@@ -777,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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -790,7 +927,7 @@ class ChatStore(
|
||||
private fun setRunning(thread: ChatThread, running: Boolean): ChatThread = when {
|
||||
running && !thread.running -> thread.copy(running = true, runningSince = now())
|
||||
running -> thread
|
||||
else -> thread.copy(running = false, runningSince = 0)
|
||||
else -> thread.copy(running = false, runningSince = 0, toolStartedAt = emptyMap())
|
||||
}
|
||||
|
||||
private fun update(sessionId: String, block: (ChatThread) -> ChatThread) {
|
||||
|
||||
@@ -20,6 +20,7 @@ import androidx.compose.foundation.lazy.items
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.foundation.text.selection.SelectionContainer
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Build
|
||||
import androidx.compose.material.icons.filled.KeyboardArrowDown
|
||||
import androidx.compose.material.icons.filled.KeyboardArrowUp
|
||||
import androidx.compose.material.icons.filled.Psychology
|
||||
@@ -34,6 +35,7 @@ import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.derivedStateOf
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.key
|
||||
import androidx.compose.runtime.mutableLongStateOf
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
@@ -46,6 +48,7 @@ import androidx.compose.ui.Modifier
|
||||
import androidx.compose.ui.platform.LocalDensity
|
||||
import androidx.compose.ui.semantics.Role
|
||||
import androidx.compose.ui.text.font.FontFamily
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.dp
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.flow.collect
|
||||
@@ -57,6 +60,7 @@ import net.awan.pipelines.ui.formatDuration
|
||||
import net.awan.pipelines.ui.theme.CHAT_BUBBLE_MAX_WIDTH_DP
|
||||
import net.awan.pipelines.ui.theme.CHAT_FOLLOW_THRESHOLD_DP
|
||||
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
|
||||
import net.awan.pipelines.ui.theme.ICON_STATUS_DP
|
||||
import net.awan.pipelines.ui.theme.SPACING_XS
|
||||
|
||||
/** The running indicator's elapsed time ticks once a second, never per frame. */
|
||||
@@ -274,24 +278,90 @@ private fun LazyListState.bottomDistancePx(itemCount: Int): Int? {
|
||||
|
||||
/**
|
||||
* The in-flight turn indicator: a spinner, `Working…` and the turn's live elapsed
|
||||
* time. The elapsed value is derived from the turn's own start ([ChatThread.elapsedMillis]),
|
||||
* so it keeps counting across a chat switch, and the tick loop stops the moment
|
||||
* the turn settles.
|
||||
* time, then one compact line for each tool call in flight — its name, the
|
||||
* command or description the part carries, and how long that call has been
|
||||
* running. The elapsed values are derived from the turn's own start
|
||||
* ([ChatThread.elapsedMillis]) and each call's own start
|
||||
* ([ChatThread.toolElapsedMillis]), so they keep counting across a chat switch,
|
||||
* and the tick loop stops the moment the turn settles. This is what makes the
|
||||
* otherwise-silent part of a turn legible: the operator can tell `working on X`
|
||||
* from `waiting on something` instead of watching a bare `Running`.
|
||||
*/
|
||||
@Composable
|
||||
private fun RunningIndicator(thread: ChatThread) {
|
||||
val elapsedMillis = thread.elapsedMillis(rememberElapsedNow(thread.runningSince))
|
||||
val now = rememberElapsedNow(thread.runningSince)
|
||||
val elapsedMillis = thread.elapsedMillis(now)
|
||||
val tools = thread.runningTools
|
||||
Column(
|
||||
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
|
||||
modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
|
||||
) {
|
||||
Row(
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
|
||||
) {
|
||||
CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
|
||||
Text("Working…", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
|
||||
Text(
|
||||
text = "· ${formatDuration(elapsedMillis / 1_000)}",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
// One line per call in flight, in transcript order and keyed by the part,
|
||||
// so several running at once read together rather than flickering between
|
||||
// them; a call's line drops out the moment it completes or errors.
|
||||
tools.forEach { part ->
|
||||
key(part.id) { RunningToolLine(part, thread.toolElapsedMillis(part, now)) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* One tool call in flight: its name, the command or short description the part
|
||||
* carries (when it carries one) and how long it has been running. A call that has
|
||||
* been running past [TOOL_LONG_RUNNING_MILLIS] is tinted and labelled so a stuck
|
||||
* call stands out. The elapsed time is the only progress signal; no percentage,
|
||||
* ETA or progress bar is ever invented.
|
||||
*/
|
||||
@Composable
|
||||
private fun RunningToolLine(part: ChatPart, elapsedMillis: Long) {
|
||||
val long = toolLongRunning(elapsedMillis)
|
||||
val tint = if (long) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurfaceVariant
|
||||
val detail = toolDetail(part)
|
||||
Row(
|
||||
verticalAlignment = Alignment.CenterVertically,
|
||||
horizontalArrangement = Arrangement.spacedBy(CHAT_ITEM_GAP),
|
||||
modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
|
||||
modifier = Modifier.fillMaxWidth().padding(start = CHAT_GUTTER),
|
||||
) {
|
||||
CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp)
|
||||
Text("Working…", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
|
||||
Icon(
|
||||
Icons.Default.Build,
|
||||
contentDescription = null,
|
||||
tint = tint,
|
||||
modifier = Modifier.size(ICON_STATUS_DP),
|
||||
)
|
||||
Text(
|
||||
text = "· ${formatDuration(elapsedMillis / 1_000)}",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
text = toolLabel(part),
|
||||
style = MaterialTheme.typography.labelMedium,
|
||||
color = tint,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
modifier = if (detail == null) Modifier.weight(1f) else Modifier,
|
||||
)
|
||||
if (detail != null) {
|
||||
Text(
|
||||
text = detail,
|
||||
style = MaterialTheme.typography.labelMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
maxLines = 1,
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
modifier = Modifier.weight(1f),
|
||||
)
|
||||
}
|
||||
Text(
|
||||
text = formatDuration(elapsedMillis / 1_000) + if (long) " · long" else "",
|
||||
style = MaterialTheme.typography.labelMedium,
|
||||
color = tint,
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -352,6 +422,16 @@ private fun MessageItem(
|
||||
SelectionContainer {
|
||||
Column(Modifier.padding(CHAT_GUTTER)) {
|
||||
if (isUser) {
|
||||
// A user turn another device sent is attributed to it, so
|
||||
// the transcript says who sent the message. Our own
|
||||
// messages carry no label.
|
||||
if (message.client.isNotBlank()) {
|
||||
Text(
|
||||
text = message.client,
|
||||
style = MaterialTheme.typography.labelSmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
UserParts(message.parts)
|
||||
} else {
|
||||
AssistantParts(
|
||||
|
||||
@@ -179,7 +179,7 @@ fun FilterCheckItem(
|
||||
)
|
||||
}
|
||||
|
||||
/** A small section caption inside a filter menu (Status/Pipeline/Time range). */
|
||||
/** A small section caption inside a menu (a filter facet or a sort's reach). */
|
||||
@Composable
|
||||
fun FilterSectionHeader(label: String) {
|
||||
Text(
|
||||
|
||||
@@ -10,6 +10,7 @@ import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.DirectionsRun
|
||||
import androidx.compose.material.icons.automirrored.filled.HelpOutline
|
||||
import androidx.compose.material.icons.filled.Block
|
||||
import androidx.compose.material.icons.filled.Bolt
|
||||
import androidx.compose.material.icons.filled.Cancel
|
||||
import androidx.compose.material.icons.filled.CheckCircle
|
||||
@@ -17,6 +18,7 @@ import androidx.compose.material.icons.filled.Error
|
||||
import androidx.compose.material.icons.filled.FrontHand
|
||||
import androidx.compose.material.icons.filled.PauseCircle
|
||||
import androidx.compose.material.icons.filled.Schedule
|
||||
import androidx.compose.material.icons.filled.SkipNext
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
@@ -48,6 +50,8 @@ enum class RunState(val label: String) {
|
||||
Failed("failed"),
|
||||
Canceled("canceled"),
|
||||
Interrupted("interrupted"),
|
||||
Blocked("blocked"),
|
||||
Skipped("skipped"),
|
||||
Active("active"),
|
||||
Unknown("unknown"),
|
||||
}
|
||||
@@ -67,6 +71,8 @@ fun runStateOf(status: String): RunState = when (status.trim().lowercase()) {
|
||||
"failed", "error" -> RunState.Failed
|
||||
"canceled", "cancelled" -> RunState.Canceled
|
||||
"interrupted" -> RunState.Interrupted
|
||||
"blocked" -> RunState.Blocked
|
||||
"skipped" -> RunState.Skipped
|
||||
else -> RunState.Unknown
|
||||
}
|
||||
|
||||
@@ -86,6 +92,8 @@ fun runStateIcon(state: RunState): ImageVector = when (state) {
|
||||
RunState.Failed -> Icons.Default.Error
|
||||
RunState.Canceled -> Icons.Default.Cancel
|
||||
RunState.Interrupted -> Icons.Default.PauseCircle
|
||||
RunState.Blocked -> Icons.Default.Block
|
||||
RunState.Skipped -> Icons.Default.SkipNext
|
||||
RunState.Active -> Icons.Default.Bolt
|
||||
RunState.Unknown -> Icons.AutoMirrored.Filled.HelpOutline
|
||||
}
|
||||
|
||||
@@ -4,17 +4,20 @@ import androidx.compose.ui.graphics.Color
|
||||
import net.awan.pipelines.ui.theme.DarkError
|
||||
|
||||
/**
|
||||
* The app-owned run-status palette.
|
||||
* The app-owned status palette, the single source of truth for the colour of a
|
||||
* status or stage-outcome word.
|
||||
*
|
||||
* Run status is a *different vocabulary* from the graph's stage outcomes
|
||||
* ([net.awan.pipelines.ui.graph.GraphPalette]): a run that is `running` is not a
|
||||
* `skipped` stage, and a `succeeded` run is not the amber the theme uses for a
|
||||
* positive *stage* outcome. Borrowing Material roles therefore put the wrong hue
|
||||
* on the two states that matter most — `primary` (mint) made a *running* run read
|
||||
* green and `tertiary` (amber) made a *succeeded* run read yellow.
|
||||
* Borrowing Material roles put the wrong hue on the two states that matter most —
|
||||
* `primary` (mint) made a *running* run read green and `tertiary` (amber) made a
|
||||
* *succeeded* run read yellow — so every entry below is a deliberate, fixed
|
||||
* colour with an explicit meaning. The stage outcomes that share a word with a
|
||||
* run state (`success`/`done`→[Succeeded], `error`→[Failed], `blocked`,
|
||||
* `skipped`, `waiting`) resolve here too, through [runStateOf], so the timeline,
|
||||
* the graph, the runs list, the stage sheet and the peek all draw one word in one
|
||||
* colour. Only genuinely graph-only flow outcomes (`approved`, `retry`, …) keep
|
||||
* their own curated colour in [net.awan.pipelines.ui.graph.GraphPalette].
|
||||
*
|
||||
* Every entry below is instead a deliberate, fixed colour with an explicit
|
||||
* meaning, tuned for the dark Pipelines surface (`DarkSurface 0xFF0E1513`,
|
||||
* Every entry is tuned for the dark Pipelines surface (`DarkSurface 0xFF0E1513`,
|
||||
* over which the chip label is drawn). The contrast of each colour against that
|
||||
* surface is *measured* by `RunStatusPaletteTest`, never judged by eye. Status is
|
||||
* never colour-only: every entry keeps its own material glyph ([runStateIcon])
|
||||
@@ -29,6 +32,13 @@ internal object RunStatusPalette {
|
||||
private val Running =
|
||||
Entry(Color(0xFF7FB2F0), "blue: in progress; green would read as already finished")
|
||||
|
||||
/**
|
||||
* Waiting for a person (a human decision): a distinct cyan, matching the TUI's
|
||||
* accent for a paused run, so it is neither the running blue nor a failure.
|
||||
*/
|
||||
private val Waiting =
|
||||
Entry(Color(0xFF8EDFF5), "cyan: paused for a person; distinct from running and from failure")
|
||||
|
||||
/** Finished well: the conventional green. Amber/tertiary would read as a warning. */
|
||||
private val Succeeded =
|
||||
Entry(Color(0xFF7FE0A8), "green: completed successfully; amber would read as a warning")
|
||||
@@ -50,11 +60,18 @@ internal object RunStatusPalette {
|
||||
Entry(Color(0xFF9AA6A2), "neutral grey: waiting, clearly not the in-progress blue")
|
||||
|
||||
/**
|
||||
* Parked on a person: violet, distinct from the in-progress blue, the queued
|
||||
* grey and the amber operator-stop, so a run needing a decision is unmistakable.
|
||||
* Parked on a person (a human decision): distinct from the in-progress blue, the
|
||||
* queued grey and the amber operator-stop, so a run needing a decision is
|
||||
* unmistakable. Blocked and skipped are stage outcomes rather than run states:
|
||||
* a stage that could not proceed is orange, and one deliberately not run is a
|
||||
* quiet grey-blue - neither is a failure.
|
||||
*/
|
||||
private val Waiting =
|
||||
Entry(Color(0xFFC0A3F5), "violet: parked for the operator's decision; not running, not a stop")
|
||||
private val Blocked =
|
||||
Entry(Color(0xFFF0A35E), "orange: a blocked stage could not proceed; not the failure red")
|
||||
|
||||
/** Skipped: a stage deliberately not run — a cool muted grey-blue, quiet and distinct. */
|
||||
private val Skipped =
|
||||
Entry(Color(0xFFA8B8C8), "muted grey-blue: a stage deliberately not run; quiet, not a status")
|
||||
|
||||
/** Unknown/blank status: the safe, low-key fallback. */
|
||||
private val Unknown =
|
||||
@@ -67,12 +84,14 @@ internal object RunStatusPalette {
|
||||
*/
|
||||
fun of(state: RunState): Entry = when (state) {
|
||||
RunState.Running, RunState.Active -> Running
|
||||
RunState.Waiting -> Waiting
|
||||
RunState.Succeeded -> Succeeded
|
||||
RunState.Failed -> Failed
|
||||
RunState.Interrupted -> Interrupted
|
||||
RunState.Canceled -> Canceled
|
||||
RunState.Queued -> Queued
|
||||
RunState.Waiting -> Waiting
|
||||
RunState.Blocked -> Blocked
|
||||
RunState.Skipped -> Skipped
|
||||
RunState.Unknown -> Unknown
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,7 +25,9 @@ import androidx.compose.ui.Modifier
|
||||
* icon and works at both window widths (it is not width-dependent geometry).
|
||||
*
|
||||
* [selected] draws a leading check on its row, so the active choice is conveyed
|
||||
* by a glyph as well as by text, never by colour alone.
|
||||
* by a glyph as well as by text, never by colour alone. An optional [header]
|
||||
* captions the menu, e.g. to say that an order applies to the results in hand
|
||||
* rather than server-side.
|
||||
*/
|
||||
@Composable
|
||||
fun <T> SortMenu(
|
||||
@@ -36,6 +38,7 @@ fun <T> SortMenu(
|
||||
onSelect: (T) -> Unit,
|
||||
onReset: () -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
header: String? = null,
|
||||
) {
|
||||
var expanded by remember { mutableStateOf(false) }
|
||||
Box(modifier) {
|
||||
@@ -43,6 +46,7 @@ fun <T> SortMenu(
|
||||
Icon(Icons.AutoMirrored.Filled.Sort, contentDescription = contentDescription)
|
||||
}
|
||||
DropdownMenu(expanded = expanded, onDismissRequest = { expanded = false }) {
|
||||
header?.let { FilterSectionHeader(it) }
|
||||
options.forEach { option ->
|
||||
DropdownMenuItem(
|
||||
text = { Text(label(option)) },
|
||||
|
||||
@@ -82,6 +82,26 @@ internal fun artifactIcon(kind: ArtifactKind): ImageVector = when (kind) {
|
||||
ArtifactKind.Other -> Icons.AutoMirrored.Filled.InsertDriveFile
|
||||
}
|
||||
|
||||
/**
|
||||
* The word that names [kind] where a surface shows the type glyph but must also
|
||||
* say the type in prose (a screen reader cannot read an icon). It is the same
|
||||
* classification [artifactIcon] draws from, so the glyph and the word never
|
||||
* disagree. Pure, so the mapping is unit-tested.
|
||||
*/
|
||||
internal fun artifactKindLabel(kind: ArtifactKind): String = when (kind) {
|
||||
ArtifactKind.Image -> "Image"
|
||||
ArtifactKind.Video -> "Video"
|
||||
ArtifactKind.Audio -> "Audio"
|
||||
ArtifactKind.Pdf -> "PDF"
|
||||
ArtifactKind.Json -> "JSON"
|
||||
ArtifactKind.Archive -> "Archive"
|
||||
ArtifactKind.Spreadsheet -> "Spreadsheet"
|
||||
ArtifactKind.Log -> "Log"
|
||||
ArtifactKind.Code -> "Code"
|
||||
ArtifactKind.Document -> "Document"
|
||||
ArtifactKind.Other -> "File"
|
||||
}
|
||||
|
||||
private val ARCHIVE_EXTENSIONS =
|
||||
setOf("zip", "tar", "gz", "tgz", "bz2", "xz", "rar", "7z", "jar", "war")
|
||||
|
||||
|
||||
@@ -8,9 +8,15 @@ import kotlin.math.min
|
||||
import kotlin.math.pow
|
||||
|
||||
/**
|
||||
* The curated graph colour palette.
|
||||
* The curated palette for the graph-only flow outcomes.
|
||||
*
|
||||
* Every distinct outcome gets its own deliberate entry (no `hashCode() % 4`
|
||||
* A stage outcome that is also a run state (`success`/`done`/`error`/`blocked`/
|
||||
* `skipped`/`waiting`) is coloured from the one owned status palette
|
||||
* ([net.awan.pipelines.ui.components.RunStatusPalette], through [outcomeColor]),
|
||||
* so the graph, the timeline and the runs list never disagree. This palette
|
||||
* covers only the words with no status meaning — the loop/choice outcomes a
|
||||
* pipeline defines (`rejected`, `exhausted`, `retry`, `approved`, `fast`,
|
||||
* `missing`) — giving each its own deliberate entry (no `hashCode() % 4`
|
||||
* collisions): the mapping is pure and deterministic, so a given outcome name is
|
||||
* the same colour across runs and recompositions, and an unknown/new name gets a
|
||||
* stable reserved fallback colour instead of silently borrowing a known one.
|
||||
@@ -19,46 +25,35 @@ import kotlin.math.pow
|
||||
* over which the outcome label is drawn on a ~0.92-alpha chip). Every entry is
|
||||
* bright enough to be legible both as a 3px edge stroke and as the small 11sp
|
||||
* label text: contrast is *measured* by [GraphPaletteTest], not asserted by eye.
|
||||
*
|
||||
* The two terminal outcomes stay theme roles in [GraphColors] (`error`→error,
|
||||
* `success`→tertiary) so their meaning is preserved; everything else uses
|
||||
* [colors].
|
||||
*/
|
||||
internal object GraphPalette {
|
||||
|
||||
/**
|
||||
* The fixed palette. Deliberately fixed (rather than scheme-derived) so an
|
||||
* outcome is the same colour on every device; the two terminal roles above
|
||||
* remain scheme roles.
|
||||
* outcome is the same colour on every device.
|
||||
*/
|
||||
val colors: List<Color> = listOf(
|
||||
Color(0xFF8FE0A0), // 0 blocked - green
|
||||
Color(0xFFF5A3A3), // 1 rejected - red
|
||||
Color(0xFF8FB4F5), // 2 skipped - blue
|
||||
Color(0xFFF5B37A), // 3 exhausted - orange
|
||||
Color(0xFF7FD4E8), // 4 retry - cyan
|
||||
Color(0xFFC0A3F5), // 5 approved - violet
|
||||
Color(0xFFF0E07A), // 6 fast - yellow
|
||||
Color(0xFFF5A3D0), // 7 missing - pink
|
||||
Color(0xFFD6B08C), // 8 done - sand
|
||||
Color(0xFFF5A3A3), // 0 rejected - red
|
||||
Color(0xFFF5B37A), // 1 exhausted - orange
|
||||
Color(0xFF7FD4E8), // 2 retry - cyan
|
||||
Color(0xFFC0A3F5), // 3 approved - violet
|
||||
Color(0xFFF0E07A), // 4 fast - yellow
|
||||
Color(0xFFF5A3D0), // 5 missing - pink
|
||||
// Reserved fallback region for names not in [KNOWN], kept distinct from
|
||||
// the known entries so an unknown outcome never borrows a known colour.
|
||||
Color(0xFFD8C98A), // 9 fallback - khaki
|
||||
Color(0xFF9FD8C0), // 10 fallback - sea
|
||||
Color(0xFFD8A8C0), // 11 fallback - dusty rose
|
||||
Color(0xFFD8C98A), // 6 fallback - khaki
|
||||
Color(0xFF9FD8C0), // 7 fallback - sea
|
||||
Color(0xFFD8A8C0), // 8 fallback - dusty rose
|
||||
)
|
||||
|
||||
/** The known outcome names and their fixed palette index, in display order. */
|
||||
/** The known graph-only outcome names and their fixed palette index, in display order. */
|
||||
private val KNOWN: Map<String, Int> = linkedMapOf(
|
||||
"blocked" to 0,
|
||||
"rejected" to 1,
|
||||
"skipped" to 2,
|
||||
"exhausted" to 3,
|
||||
"retry" to 4,
|
||||
"approved" to 5,
|
||||
"fast" to 6,
|
||||
"missing" to 7,
|
||||
"done" to 8,
|
||||
"rejected" to 0,
|
||||
"exhausted" to 1,
|
||||
"retry" to 2,
|
||||
"approved" to 3,
|
||||
"fast" to 4,
|
||||
"missing" to 5,
|
||||
)
|
||||
|
||||
/** First palette index reserved for names that are not in [KNOWN]. */
|
||||
@@ -67,8 +62,9 @@ internal object GraphPalette {
|
||||
/**
|
||||
* The palette index for [outcome]. Pure and deterministic for every input
|
||||
* (including blank): known names get their curated slot, everything else a
|
||||
* stable slot inside the reserved fallback region. `success`/`error` resolve
|
||||
* to the theme roles in [outcomeColor] but still return a stable index here.
|
||||
* stable slot inside the reserved fallback region. A word that resolves to a
|
||||
* run state is coloured from the status palette by [outcomeColor] and does not
|
||||
* reach this palette.
|
||||
*/
|
||||
fun outcomeColorIndex(outcome: String): Int {
|
||||
KNOWN[outcome]?.let { return it }
|
||||
|
||||
@@ -85,8 +85,11 @@ import net.awan.pipelines.data.protocol.GraphSemantics
|
||||
import net.awan.pipelines.data.protocol.Protocol
|
||||
import net.awan.pipelines.data.protocol.RunGraphState
|
||||
import net.awan.pipelines.data.protocol.edges
|
||||
import net.awan.pipelines.ui.components.RunState
|
||||
import net.awan.pipelines.ui.components.hostResumed
|
||||
import net.awan.pipelines.ui.components.rememberLiveNowMillis
|
||||
import net.awan.pipelines.ui.components.runStateColor
|
||||
import net.awan.pipelines.ui.components.runStateOf
|
||||
import net.awan.pipelines.ui.formatDuration
|
||||
import net.awan.pipelines.ui.secondsSince
|
||||
import net.awan.pipelines.ui.theme.GRAPH_ACTIVE_HALO_GAP
|
||||
@@ -534,44 +537,51 @@ internal class GraphColors(
|
||||
/**
|
||||
* The graph's colours for [scheme], built in one place so every surface that must
|
||||
* agree with the graph (the graph itself and the timeline's step-outcome chips)
|
||||
* uses the same palette. The two terminal roles stay scheme roles so their
|
||||
* meaning is kept; every other outcome uses the one curated, legible
|
||||
* [GraphPalette] for both a stroke and its label text.
|
||||
* uses the same palette. The two terminal roles take the one owned run-status
|
||||
* colour (success green, failure red) so they can never disagree with the runs
|
||||
* list; every other status word is coloured by the status palette in
|
||||
* [outcomeColor], and the remaining graph-only flow outcomes use the one curated,
|
||||
* legible [GraphPalette] for both a stroke and its label text.
|
||||
*
|
||||
* Node and label surfaces are *tonal*: a raised surface tone ([scheme]'s
|
||||
* `surfaceContainerHigh`/`surfaceContainerHighest`) blended with a subtle tint of
|
||||
* the node's semantic colour (see [tonalFill]) rather than a flat fill, so a node
|
||||
* reads as raised card, not a terminal cell.
|
||||
*/
|
||||
internal fun graphColors(scheme: ColorScheme): GraphColors = GraphColors(
|
||||
// The two terminal roles stay scheme roles so their meaning is kept.
|
||||
success = scheme.tertiary,
|
||||
error = scheme.error,
|
||||
// Every other outcome uses the one curated, legible palette for both its
|
||||
// stroke and its label text, so a curve and its label always agree.
|
||||
palette = GraphPalette.colors,
|
||||
// Node fills differ by kind (see [GraphNodeKind]): model (neutral), ntfy
|
||||
// (amber), other/custom (green), and the two terminals (success/error). Each
|
||||
// is a tonal surface carrying a subtle tint of that kind's semantic hue.
|
||||
nodeFill = tonalFill(scheme.surfaceContainerHigh, scheme.onSurfaceVariant, NEUTRAL_TINT),
|
||||
nodeNtfyFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, KIND_TINT),
|
||||
nodeCustomFill = tonalFill(scheme.surfaceContainerHigh, scheme.primary, KIND_TINT),
|
||||
// A selected node inverts (light fill / dark text) plus a stronger border, so
|
||||
// selection reads in either appearance and never relies on colour.
|
||||
nodeFillActive = scheme.inverseSurface,
|
||||
nodeTextActive = scheme.inverseOnSurface,
|
||||
// The stage border is deliberately soft (a low-contrast outline variant), not
|
||||
// the hard original outline; terminals carry their outcome hue instead.
|
||||
nodeBorder = scheme.outlineVariant,
|
||||
nodeBorderActive = scheme.primary,
|
||||
nodeText = scheme.onSurface,
|
||||
terminalFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, TERMINAL_TINT),
|
||||
terminalErrorFill = tonalFill(scheme.surfaceContainerHigh, scheme.error, TERMINAL_TINT),
|
||||
// Edge outcome labels sit on a tonal chip (drawn as a rounded rect) rather than
|
||||
// raw text over the canvas.
|
||||
labelBackground = scheme.surfaceContainerHighest,
|
||||
labelText = scheme.onSurfaceVariant,
|
||||
)
|
||||
internal fun graphColors(scheme: ColorScheme): GraphColors {
|
||||
// The two terminal outcomes take the shared run-status colours so the graph
|
||||
// and the runs list can never disagree about success/failure.
|
||||
val success = runStateColor(RunState.Succeeded)
|
||||
val error = runStateColor(RunState.Failed)
|
||||
return GraphColors(
|
||||
success = success,
|
||||
error = error,
|
||||
// Every other graph-only outcome uses the one curated, legible palette for
|
||||
// both its stroke and its label text, so a curve and its label always agree.
|
||||
palette = GraphPalette.colors,
|
||||
// Node fills differ by kind (see [GraphNodeKind]): model (neutral), ntfy
|
||||
// (amber), other/custom (green), and the two terminals (success/error). Each
|
||||
// is a tonal surface carrying a subtle tint of that kind's semantic hue.
|
||||
nodeFill = tonalFill(scheme.surfaceContainerHigh, scheme.onSurfaceVariant, NEUTRAL_TINT),
|
||||
nodeNtfyFill = tonalFill(scheme.surfaceContainerHigh, scheme.tertiary, KIND_TINT),
|
||||
nodeCustomFill = tonalFill(scheme.surfaceContainerHigh, scheme.primary, KIND_TINT),
|
||||
// A selected node inverts (light fill / dark text) plus a stronger border, so
|
||||
// selection reads in either appearance and never relies on colour.
|
||||
nodeFillActive = scheme.inverseSurface,
|
||||
nodeTextActive = scheme.inverseOnSurface,
|
||||
// The stage border is deliberately soft (a low-contrast outline variant), not
|
||||
// the hard original outline; terminals carry their outcome hue instead.
|
||||
nodeBorder = scheme.outlineVariant,
|
||||
nodeBorderActive = scheme.primary,
|
||||
nodeText = scheme.onSurface,
|
||||
terminalFill = tonalFill(scheme.surfaceContainerHigh, success, TERMINAL_TINT),
|
||||
terminalErrorFill = tonalFill(scheme.surfaceContainerHigh, error, TERMINAL_TINT),
|
||||
// Edge outcome labels sit on a tonal chip (drawn as a rounded rect) rather than
|
||||
// raw text over the canvas.
|
||||
labelBackground = scheme.surfaceContainerHighest,
|
||||
labelText = scheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* [surface] blended with a [fraction] (0..1) of [accent], so a node/label fill
|
||||
@@ -1602,17 +1612,19 @@ private fun DrawScope.drawActiveHalo(
|
||||
}
|
||||
|
||||
/**
|
||||
* The colour for an outcome: the theme error role for `error`, a clearly
|
||||
* positive theme colour for `success`, and the curated [GraphPalette] entry for
|
||||
* everything else. One colour is used for both the edge stroke and its label
|
||||
* text (the palette is legible on the surface), so a curve and its label always
|
||||
* agree. `success`/`error` are the terminal roles and are never colour-only
|
||||
* signals (their labels name them). Pure and deterministic.
|
||||
* The colour for an outcome or stage status, from the one owned source: a word
|
||||
* that is a run state (`success`/`done`/`error`/`blocked`/`skipped`/`waiting`/
|
||||
* `running`/…) takes the shared status colour the operator already learned from
|
||||
* the runs list, so the same word is the same colour in the timeline, the graph,
|
||||
* the stage sheet and the peek; a graph-only flow outcome (`approved`, `retry`, …)
|
||||
* takes its curated [GraphPalette] entry. One colour serves both the edge stroke
|
||||
* and its label text (the palette is legible on the surface), so a curve and its
|
||||
* label always agree. Pure and deterministic.
|
||||
*/
|
||||
internal fun outcomeColor(outcome: String, colors: GraphColors): Color = when (outcome) {
|
||||
"error" -> colors.error
|
||||
"success" -> colors.success
|
||||
else -> colors.palette[GraphPalette.outcomeColorIndex(outcome)]
|
||||
internal fun outcomeColor(outcome: String, colors: GraphColors): Color {
|
||||
val state = runStateOf(outcome)
|
||||
if (state != RunState.Unknown) return runStateColor(state)
|
||||
return colors.palette[GraphPalette.outcomeColorIndex(outcome)]
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -46,13 +46,15 @@ enum class RunPresence(val label: String, val storageKey: String) {
|
||||
|
||||
/**
|
||||
* The statuses a run filter can select. The server's own run vocabulary
|
||||
* (internal/pipeline/runs.go: queued/running/succeeded/failed/canceled/
|
||||
* interrupted); the app-only `active` usage bucket and the `unknown` fallback
|
||||
* are deliberately not offered, so a status filter always names a real state.
|
||||
* (internal/pipeline/runs.go: queued/running/waiting/succeeded/failed/canceled/
|
||||
* interrupted); the app-only `active` usage bucket, the stage-outcome words
|
||||
* (`blocked`/`skipped`) and the `unknown` fallback are deliberately not offered,
|
||||
* so a status filter always names a real run state.
|
||||
*/
|
||||
internal val RUN_STATUS_FILTERS: List<RunState> = listOf(
|
||||
RunState.Queued,
|
||||
RunState.Running,
|
||||
RunState.Waiting,
|
||||
RunState.Succeeded,
|
||||
RunState.Failed,
|
||||
RunState.Canceled,
|
||||
|
||||
@@ -586,8 +586,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
|
||||
},
|
||||
|
||||
@@ -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 = """
|
||||
@@ -311,6 +350,58 @@ class ChatProtocolTest {
|
||||
assertNull(message.chatEvent)
|
||||
assertNull(message.chatSessions)
|
||||
assertNull(message.chatPermission)
|
||||
assertNull(message.chatClose)
|
||||
}
|
||||
|
||||
/**
|
||||
* The session list carries the server's closed state: a closed session decodes
|
||||
* with its flag and close time, and an open one stays open, so the app can
|
||||
* group finished chats as history without a second request.
|
||||
*/
|
||||
@Test
|
||||
fun chatSessionsParseTheClosedState() {
|
||||
val json = """
|
||||
{"type":"chat_sessions","chat_sessions":[
|
||||
{"id":"ses_open","title":"Active"},
|
||||
{"id":"ses_done","title":"Finished","closed":true,"closed_at":1792112367999}]}
|
||||
""".trimIndent()
|
||||
val sessions = PipelinesJson.decodeFromString(Message.serializer(), json).chatSessions!!
|
||||
assertEquals(false, sessions[0].closed)
|
||||
assertEquals(0L, sessions[0].closedAt)
|
||||
assertTrue(sessions[1].closed)
|
||||
assertEquals(1792112367999L, sessions[1].closedAt)
|
||||
}
|
||||
|
||||
/**
|
||||
* The close/reopen frames use the same builder the repository sends and carry
|
||||
* only the session id; the close reply's result (closed_at, interrupted)
|
||||
* round-trips, so the app can report that a turn was stopped.
|
||||
*/
|
||||
@Test
|
||||
fun chatCloseAndReopenFramesRoundTrip() {
|
||||
val close = ChatProtocol.closeRequest("ses_1")
|
||||
assertEquals(Protocol.CHAT_CLOSE, close.type)
|
||||
assertEquals("ses_1", close.chatQuery!!.sessionId)
|
||||
val decodedClose = PipelinesJson.decodeFromString(
|
||||
Message.serializer(),
|
||||
PipelinesJson.encodeToString(Message.serializer(), close.copy(id = "android-1")),
|
||||
)
|
||||
assertEquals(Protocol.CHAT_CLOSE, decodedClose.type)
|
||||
|
||||
val reopen = ChatProtocol.reopenRequest("ses_1")
|
||||
assertEquals(Protocol.CHAT_REOPEN, reopen.type)
|
||||
assertEquals("ses_1", reopen.chatQuery!!.sessionId)
|
||||
|
||||
val reply = """
|
||||
{"type":"chat_close","id":"android-1",
|
||||
"chat_session":{"id":"ses_1","closed":true,"closed_at":1792112367999},
|
||||
"chat_close":{"session_id":"ses_1","closed_at":1792112367999,"interrupted":true}}
|
||||
""".trimIndent()
|
||||
val decodedReply = PipelinesJson.decodeFromString(Message.serializer(), reply)
|
||||
assertEquals(true, decodedReply.chatSession!!.closed)
|
||||
assertEquals(1792112367999L, decodedReply.chatSession!!.closedAt)
|
||||
assertTrue(decodedReply.chatClose!!.interrupted)
|
||||
assertEquals(1792112367999L, decodedReply.chatClose!!.closedAt)
|
||||
}
|
||||
|
||||
private fun toolDuration(part: ChatPart): Long? {
|
||||
|
||||
@@ -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<SearchResult> = listOf(
|
||||
Protocol.SEARCH_KIND_PIPELINE,
|
||||
Protocol.SEARCH_KIND_VERSION,
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
package net.awan.pipelines.ui.chat
|
||||
|
||||
import net.awan.pipelines.data.protocol.ChatProtocol
|
||||
import net.awan.pipelines.data.protocol.ChatSession
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
|
||||
/**
|
||||
* Closing a chat: the server-side finish (shared by every client) marks the row
|
||||
* closed, keeps it as history, settles a running turn, and can be reversed by a
|
||||
* reopen or a prompt. Driven against [ChatStore] with no device or server.
|
||||
*/
|
||||
class ChatCloseTest {
|
||||
|
||||
private fun session(
|
||||
id: String,
|
||||
title: String = id,
|
||||
closed: Boolean = false,
|
||||
closedAt: Long = 0,
|
||||
) = ChatSession(
|
||||
id = id,
|
||||
title = title,
|
||||
tag = ChatProtocol.TAG_OPERATOR,
|
||||
directory = "/home/op",
|
||||
closed = closed,
|
||||
closedAt = closedAt,
|
||||
)
|
||||
|
||||
@Test
|
||||
fun closingMarksTheRowClosedAndKeepsItAsHistory() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a"), session("b")))
|
||||
store.sessionClosed("a", 1_700_000_000_000)
|
||||
|
||||
// Still in the server list (nothing deleted), but no longer active.
|
||||
assertEquals(listOf("a", "b"), store.value.sessions.map { it.id })
|
||||
assertEquals(listOf("b"), store.value.activeSessions.map { it.id })
|
||||
val closed = store.value.closedSessions.single()
|
||||
assertEquals("a", closed.id)
|
||||
assertTrue(closed.closed)
|
||||
assertEquals(1_700_000_000_000, closed.closedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun reopeningReturnsTheChatToTheActiveList() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a"), session("b")))
|
||||
store.sessionClosed("a", 1_700_000_000_000)
|
||||
store.sessionReopened("a")
|
||||
|
||||
assertEquals(listOf("a", "b"), store.value.activeSessions.map { it.id })
|
||||
assertTrue(store.value.closedSessions.isEmpty())
|
||||
assertFalse(store.value.sessions.first { it.id == "a" }.closed)
|
||||
assertEquals(0, store.value.sessions.first { it.id == "a" }.closedAt)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun closingSettlesARunningThreadAndMarksItClosed() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a")))
|
||||
store.open(session("a"))
|
||||
store.running("a", true)
|
||||
|
||||
store.sessionClosed("a", 1_700_000_000_000)
|
||||
|
||||
val thread = store.value.thread("a")!!
|
||||
assertFalse("the stopped turn must not still read as running", thread.running)
|
||||
assertTrue(thread.closed)
|
||||
// The conversation is kept: its history is not deleted.
|
||||
assertTrue(store.value.thread("a") != null)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aServerListRefreshCarriesTheClosedStateIntoTheStore() {
|
||||
val store = ChatStore()
|
||||
// The list arrives closed (the server is the source of truth).
|
||||
store.sessionsLoaded(listOf(session("a", closed = true, closedAt = 5), session("b")))
|
||||
|
||||
assertEquals(listOf("b"), store.value.activeSessions.map { it.id })
|
||||
assertEquals(listOf("a"), store.value.closedSessions.map { it.id })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun aRefreshMarksAnAlreadyOpenThreadClosed() {
|
||||
val store = ChatStore()
|
||||
store.sessionsLoaded(listOf(session("a")))
|
||||
store.open(session("a"))
|
||||
assertFalse(store.value.thread("a")!!.closed)
|
||||
|
||||
store.sessionsLoaded(listOf(session("a", closed = true, closedAt = 5)))
|
||||
assertTrue(store.value.thread("a")!!.closed)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun theRowStatusReadsClosedAndTheConfirmationSaysWhatCloseDoes() {
|
||||
assertEquals("Closed", sessionStatusLabel(session("a", closed = true), runningLocally = false))
|
||||
|
||||
val wording = closeChatConfirmation("Fix the parser")
|
||||
assertTrue("names the stop of a running turn", wording.contains("running is stopped"))
|
||||
assertTrue("says it affects every device", wording.contains("every device"))
|
||||
assertTrue("says nothing is deleted", wording.contains("Nothing is deleted"))
|
||||
assertTrue("says it can be reopened", wording.contains("reopen"))
|
||||
assertTrue("names the chat", wording.contains("Fix the parser"))
|
||||
}
|
||||
}
|
||||
@@ -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))
|
||||
}
|
||||
|
||||
|
||||
@@ -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<String, String>): 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")))
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
+27
-5
@@ -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
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
# Finishing a chat: a server-side close that keeps the history
|
||||
|
||||
## What this item changed
|
||||
|
||||
The Pipelines server and `android/`. Before this, the only way to get a chat out
|
||||
of the list was the app's device-local hide (`ChatOverrides.hidden`): the session
|
||||
stayed open on the server, other clients still showed it, and nothing recorded
|
||||
that the operator had finished with it.
|
||||
|
||||
- `internal/protocol/chat.go` adds the `chat_close` and `chat_reopen` request
|
||||
types, a `ChatCloseResult` (`session_id`, `closed_at`, `interrupted`) and
|
||||
additive `closed`/`closed_at` fields on the chat session; `internal/protocol/message.go`
|
||||
carries `ChatClose` on the outcome envelope (the requests themselves ride on
|
||||
`chat_query`, like `chat_messages`/`chat_interrupt`).
|
||||
- `internal/server/chat_close.go` (new) handles both: `chat_close` stops a turn
|
||||
in flight by reusing the broker interrupt the session's room owns (recording in
|
||||
the reply that a turn was stopped, so a stream is never left running into
|
||||
nothing), then sets `closed_at`; `chat_reopen` clears it. Both take a
|
||||
`chat_query` and echo the session plus its registry row. A session id that is
|
||||
not a recorded operator session — including a pipeline-owned run session — is
|
||||
refused before anything is written. Nothing is deleted.
|
||||
- `internal/server/chat_sessions.go` marks a listed session `closed`/`closed_at`
|
||||
from the registry, so every client sees the same state and a closed session
|
||||
stays listed.
|
||||
- `internal/server/chat_room.go` gains `turnInFlight`, so close only interrupts a
|
||||
session that actually has a turn running.
|
||||
- `internal/pipeline/operator_sessions.go` adds `closed_at` to
|
||||
`operator_sessions` (for a fresh database and by an idempotent
|
||||
`addColumnIfMissing` migration for an existing one), plus
|
||||
`CloseOperatorSession`, `ReopenOperatorSession` and `OperatorSession`, and
|
||||
clears the closed state on record and on touch, so simply prompting a closed
|
||||
session reopens it.
|
||||
- `android/`: `data/protocol/Chat.kt`/`Message.kt` (closed fields, the two
|
||||
requests), `PipelinesRepository.chatClose`/`chatReopen`, `ChatStore` (closed
|
||||
state, a `closedSessions` grouping, `setQueued`/`sessionReopened`),
|
||||
`ChatFormat` (a closed status label), `ChatListPane` (a `Closed` chip and
|
||||
section, Close/Reopen actions, a confirmation stating that close stops a
|
||||
running turn, marks the chat closed on every device and deletes nothing),
|
||||
`AppViewModel` (the close/reopen actions), and the rename of the local action
|
||||
to **Hide on this device** with a snackbar saying the chat stays on the server.
|
||||
- Tests: `internal/protocol/chat_test.go`, `internal/server/chat_close_test.go`,
|
||||
`internal/pipeline/operator_sessions_close_test.go`,
|
||||
`android/.../ChatCloseTest.kt` and the closed-state cases in
|
||||
`android/.../ChatProtocolTest.kt`.
|
||||
|
||||
No new dependency (only the already-declared material-icons-extended), the
|
||||
installer and the Docker files are untouched, and no run is started from the app.
|
||||
State: committed locally only, not deployed; the on-device close/second-client/
|
||||
reopen check is deferred to visual review.
|
||||
|
||||
## Shared documents this change makes stale
|
||||
|
||||
The note is written here rather than edited in place; the `docs-fold` writer
|
||||
should update these when it next folds notes.
|
||||
|
||||
- `docs/cli.md:306` — the `## Chat sessions` bullet for `chat_sessions` lists each
|
||||
session's `directory`, `tag` and recency and ends "A session is never marked
|
||||
`busy`". It should add that a closed session is still listed, marked
|
||||
`closed: true` with its `closed_at`, so a client groups or filters it as
|
||||
history rather than losing it.
|
||||
- `docs/cli.md:342` — after the `chat_adopt` bullet, add two bullets:
|
||||
`chat_close` takes a `chat_query` (`session_id`), stops any in-flight turn
|
||||
through the same interrupt `chat_interrupt` uses (the `chat_close` result's
|
||||
`interrupted` flag records that a turn was stopped), then sets `closed_at` in
|
||||
the operator-session registry; it answers with the closed session as
|
||||
`chat_session`, its registry row in `chat_sessions` and the `chat_close`
|
||||
result; an id that is not a recorded operator session — including a
|
||||
pipeline-owned run session — is refused before anything is written, and
|
||||
nothing is ever deleted. And `chat_reopen` clears the state again (the inverse,
|
||||
same `chat_query`); prompting a closed session also clears it.
|
||||
- `android/README.md:6326` — append a dated section recording the behaviour: the
|
||||
server-side close and reopen, the session and transcript surviving a close,
|
||||
the `Closed` chip/section and the `Closed` status line, the Close action and
|
||||
its confirmation wording, the Reopen action, the two ways a session reopens,
|
||||
and the rename of the local action to **Hide on this device** (device-only,
|
||||
with a snackbar saying the chat stays on the server) so the two are never
|
||||
confused. Include the verification evidence and the not-verified-on-device
|
||||
boundary (implementation verification is the build and the unit tests; visual
|
||||
review owns the device).
|
||||
- `internal/author/skill/references/operations.md:268` — the "Brokered OpenCode
|
||||
chat" preamble lists the declared `chat_*` surface; add `chat_close` and
|
||||
`chat_reopen`.
|
||||
- `internal/author/skill/references/operations.md:307` — the `chat_sessions`
|
||||
paragraph describes the `operator_sessions` shape (`session_id`, `directory`,
|
||||
`title`, `tag`, `created_at`, `last_used_at`); add `closed_at` and say that a
|
||||
closed session stays in the list marked `closed`/`closed_at`. Add a paragraph
|
||||
documenting `chat_close`/`chat_reopen` (interrupt a running turn, record the
|
||||
closed state, refuse a non-operator session, keep listing as history, reopen
|
||||
explicitly or by prompting), and add a dated evidence bullet naming
|
||||
`internal/server/chat_close_test.go`,
|
||||
`internal/pipeline/operator_sessions_close_test.go`,
|
||||
`internal/protocol/chat_test.go` and the app's `ChatCloseTest`, marking the
|
||||
on-device check as not run.
|
||||
|
||||
## Not stale
|
||||
|
||||
- No packaged template names the chat surface, so `internal/author/`'s templates
|
||||
need no change.
|
||||
- `internal/author/install.go`'s managed file inventory needs no change: this
|
||||
item adds no reference file.
|
||||
- `internal/author/skill/references/SKILL.md` stays a task-directed index; the
|
||||
close/reopen detail belongs in `operations.md`.
|
||||
- `android/AGENTS.md` already lists `ui/chat/` and its files, and
|
||||
`internal/server/AGENTS.md` already points at `internal/server/chat_*.go` and
|
||||
`internal/pipeline/`'s operator-session registry, so neither area map needs a
|
||||
new entry.
|
||||
@@ -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 <tool>`, or `Running <n> 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.
|
||||
@@ -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/<slug>.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.
|
||||
+8
-1
@@ -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/<slug>.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 `# <heading>` section is retained verbatim as evidence. The
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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 `# <heading>` 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 `# <heading>` 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
|
||||
```
|
||||
+6
-1
@@ -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/<slug>.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
|
||||
|
||||
@@ -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/<slug>.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
|
||||
|
||||
@@ -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/<slug>.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
|
||||
|
||||
@@ -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/<slug>.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; <the item's publishing rules>.
|
||||
never push; record a documentation note in `docs/notes/<slug>.md` rather than editing
|
||||
a shared document; <the item's publishing rules>.
|
||||
```
|
||||
|
||||
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/<slug>.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/<slug>.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 <draft.md>
|
||||
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/<slug>.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
|
||||
|
||||
@@ -2,6 +2,8 @@ package pipeline
|
||||
|
||||
import (
|
||||
"context"
|
||||
"database/sql"
|
||||
"errors"
|
||||
"time"
|
||||
)
|
||||
|
||||
@@ -23,6 +25,11 @@ type OperatorSession struct {
|
||||
Tag string
|
||||
CreatedAt int64
|
||||
UpdatedAt int64
|
||||
// ClosedAt is the epoch-millisecond time the operator finished with the
|
||||
// session, or 0 while it is open. It records the closed state on the server
|
||||
// so every client sees the same thing; the session and its history are never
|
||||
// deleted, and reopening clears it back to 0.
|
||||
ClosedAt int64
|
||||
}
|
||||
|
||||
// initOperatorSessions creates the operator-session registry. It is a table of
|
||||
@@ -30,44 +37,96 @@ type OperatorSession struct {
|
||||
// ownership (run_session_owners, SessionOwner) is untouched and the two
|
||||
// vocabularies cannot be confused. session_id is the primary key, so lookups and
|
||||
// the upsert use the index; operator_sessions_recent serves the recency order.
|
||||
// closed_at is added here for a fresh database and by migrateOperatorSessions for
|
||||
// one created before the closed state existed.
|
||||
func (s *Store) initOperatorSessions() error {
|
||||
_, err := s.db.Exec(`CREATE TABLE IF NOT EXISTS operator_sessions (
|
||||
session_id TEXT PRIMARY KEY, directory TEXT NOT NULL, title TEXT NOT NULL DEFAULT '',
|
||||
tag TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, last_used_at INTEGER NOT NULL);
|
||||
tag TEXT NOT NULL DEFAULT '', created_at INTEGER NOT NULL, last_used_at INTEGER NOT NULL,
|
||||
closed_at INTEGER NOT NULL DEFAULT 0);
|
||||
CREATE INDEX IF NOT EXISTS operator_sessions_recent ON operator_sessions(last_used_at DESC);`)
|
||||
return err
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return s.migrateOperatorSessions()
|
||||
}
|
||||
|
||||
// migrateOperatorSessions adds the closed_at column to a database created before
|
||||
// the closed state existed. Adding a column with a default leaves every existing
|
||||
// row valid and open (0), so an upgrade is idempotent across repeated Open calls
|
||||
// and no session is silently reported as closed.
|
||||
func (s *Store) migrateOperatorSessions() error {
|
||||
return s.addColumnIfMissing("operator_sessions", "closed_at", "INTEGER NOT NULL DEFAULT 0")
|
||||
}
|
||||
|
||||
// RecordOperatorSession upserts one operator chat session in a single statement:
|
||||
// a new id is inserted with its created_at and last_used_at set to now, and a
|
||||
// repeated id updates directory/title/tag and moves last_used_at to now while
|
||||
// preserving the original created_at. CreatedAt is therefore stable across
|
||||
// re-records.
|
||||
// re-records. Recording also clears any closed state: re-creating or adopting a
|
||||
// session is use, so it is open again.
|
||||
func (s *Store) RecordOperatorSession(ctx context.Context, sessionID, directory, title, tag string) error {
|
||||
now := time.Now().UnixMilli()
|
||||
_, err := s.db.ExecContext(ctx, `INSERT INTO operator_sessions(session_id,directory,title,tag,created_at,last_used_at)
|
||||
VALUES(?,?,?,?,?,?)
|
||||
ON CONFLICT(session_id) DO UPDATE SET directory=excluded.directory,title=excluded.title,tag=excluded.tag,last_used_at=excluded.last_used_at`,
|
||||
_, err := s.db.ExecContext(ctx, `INSERT INTO operator_sessions(session_id,directory,title,tag,created_at,last_used_at,closed_at)
|
||||
VALUES(?,?,?,?,?,?,0)
|
||||
ON CONFLICT(session_id) DO UPDATE SET directory=excluded.directory,title=excluded.title,tag=excluded.tag,last_used_at=excluded.last_used_at,closed_at=0`,
|
||||
sessionID, directory, title, tag, now, now)
|
||||
return err
|
||||
}
|
||||
|
||||
// TouchOperatorSession records that an operator session was just used, in one
|
||||
// UPDATE. A session id that is not an operator session updates no row and is not
|
||||
// an error: the statement is itself the presence check, so no second read is
|
||||
// UPDATE. It also clears the closed state, so simply prompting a closed session
|
||||
// reopens it. A session id that is not an operator session updates no row and is
|
||||
// not an error: the statement is itself the presence check, so no second read is
|
||||
// needed.
|
||||
func (s *Store) TouchOperatorSession(ctx context.Context, sessionID string) error {
|
||||
_, err := s.db.ExecContext(ctx, "UPDATE operator_sessions SET last_used_at=? WHERE session_id=?", time.Now().UnixMilli(), sessionID)
|
||||
_, err := s.db.ExecContext(ctx, "UPDATE operator_sessions SET last_used_at=?, closed_at=0 WHERE session_id=?", time.Now().UnixMilli(), sessionID)
|
||||
return err
|
||||
}
|
||||
|
||||
// CloseOperatorSession records that the operator finished with an operator
|
||||
// session, in one UPDATE that sets closed_at to now. Nothing is deleted: the row,
|
||||
// its history and the OpenCode session itself are untouched. A session id that is
|
||||
// not an operator session (for example a pipeline-owned run session) updates no
|
||||
// row and is not an error, so run sessions are never affected.
|
||||
func (s *Store) CloseOperatorSession(ctx context.Context, sessionID string) error {
|
||||
_, err := s.db.ExecContext(ctx, "UPDATE operator_sessions SET closed_at=? WHERE session_id=?", time.Now().UnixMilli(), sessionID)
|
||||
return err
|
||||
}
|
||||
|
||||
// ReopenOperatorSession clears the closed state of an operator session, in one
|
||||
// UPDATE that sets closed_at back to 0. A session id that is not an operator
|
||||
// session updates no row and is not an error.
|
||||
func (s *Store) ReopenOperatorSession(ctx context.Context, sessionID string) error {
|
||||
_, err := s.db.ExecContext(ctx, "UPDATE operator_sessions SET closed_at=0 WHERE session_id=?", sessionID)
|
||||
return err
|
||||
}
|
||||
|
||||
// OperatorSession returns one operator session by id. found is false when the id
|
||||
// is not a recorded operator session (so a pipeline-owned run session is never
|
||||
// returned). It is one indexed lookup and never mutates the row.
|
||||
func (s *Store) OperatorSession(ctx context.Context, sessionID string) (OperatorSession, bool, error) {
|
||||
var session OperatorSession
|
||||
row := s.db.QueryRowContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at,closed_at
|
||||
FROM operator_sessions WHERE session_id=? AND tag <> ''`, sessionID)
|
||||
if err := row.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt, &session.ClosedAt); err != nil {
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return OperatorSession{}, false, nil
|
||||
}
|
||||
return OperatorSession{}, false, err
|
||||
}
|
||||
return session, true, nil
|
||||
}
|
||||
|
||||
// OperatorSessions reports the operator's chat sessions, most-recently-used
|
||||
// first (ties broken by session id for a deterministic order), capped at
|
||||
// operatorSessionListLimit. Rows with no tag are omitted: a session with no
|
||||
// recorded tag is not an operator session and must never be listed. It is one
|
||||
// bounded statement; recency is never mutated here.
|
||||
// recorded tag is not an operator session and must never be listed. Closed
|
||||
// sessions are included: the app groups or filters them as history, so the
|
||||
// operator can still see and reopen what they finished. It is one bounded
|
||||
// statement; recency is never mutated here.
|
||||
func (s *Store) OperatorSessions(ctx context.Context) ([]OperatorSession, error) {
|
||||
rows, err := s.db.QueryContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at
|
||||
rows, err := s.db.QueryContext(ctx, `SELECT session_id,directory,title,tag,created_at,last_used_at,closed_at
|
||||
FROM operator_sessions WHERE tag <> '' ORDER BY last_used_at DESC, session_id LIMIT ?`, operatorSessionListLimit)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -76,7 +135,7 @@ FROM operator_sessions WHERE tag <> '' ORDER BY last_used_at DESC, session_id LI
|
||||
sessions := []OperatorSession{}
|
||||
for rows.Next() {
|
||||
var session OperatorSession
|
||||
if err := rows.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt); err != nil {
|
||||
if err := rows.Scan(&session.ID, &session.Directory, &session.Title, &session.Tag, &session.CreatedAt, &session.UpdatedAt, &session.ClosedAt); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
sessions = append(sessions, session)
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
package pipeline
|
||||
|
||||
import (
|
||||
"context"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// TestOperatorSessionsCloseReopenAndTouch proves the closed-state contract: a
|
||||
// close records closed_at and the session is still listed as history, an explicit
|
||||
// reopen clears it, a prompt (touch) clears it, re-recording clears it, and the
|
||||
// session, its history and its created_at are never deleted or rewritten.
|
||||
func TestOperatorSessionsCloseReopenAndTouch(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
store, err := Open(filepath.Join(t.TempDir(), "close.db"))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer store.Close()
|
||||
if err := store.RecordOperatorSession(ctx, "ses_a", "/work/a", "A", "operator"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
before, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
closed, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(closed) != 1 || closed[0].ClosedAt <= 0 {
|
||||
t.Fatalf("close did not record closed_at: %+v", closed)
|
||||
}
|
||||
if closed[0].ID != before[0].ID || closed[0].Directory != before[0].Directory ||
|
||||
closed[0].Title != before[0].Title || closed[0].Tag != before[0].Tag || closed[0].CreatedAt != before[0].CreatedAt {
|
||||
t.Fatalf("close changed the session beyond closed_at:\nbefore %+v\nafter %+v", before[0], closed[0])
|
||||
}
|
||||
one, found, err := store.OperatorSession(ctx, "ses_a")
|
||||
if err != nil || !found || one.ClosedAt <= 0 {
|
||||
t.Fatalf("OperatorSession = %+v found=%v err=%v", one, found, err)
|
||||
}
|
||||
if _, found, err := store.OperatorSession(ctx, "ses_run"); err != nil || found {
|
||||
t.Fatalf("a non-operator session was reported found=%v err=%v", found, err)
|
||||
}
|
||||
|
||||
if err := store.ReopenOperatorSession(ctx, "ses_a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt != 0 {
|
||||
t.Fatalf("explicit reopen did not clear closed_at: %+v %v", rows, err)
|
||||
}
|
||||
|
||||
// Prompting (touch) reopens too.
|
||||
if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := store.TouchOperatorSession(ctx, "ses_a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt != 0 {
|
||||
t.Fatalf("touch did not clear closed_at: %+v %v", rows, err)
|
||||
}
|
||||
|
||||
// Re-recording (create/adopt) reopens too.
|
||||
if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := store.RecordOperatorSession(ctx, "ses_a", "/work/a", "A", "operator"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt != 0 {
|
||||
t.Fatalf("re-record did not clear closed_at: %+v %v", rows, err)
|
||||
}
|
||||
|
||||
// Closing a session id that is not an operator session writes nothing.
|
||||
if err := store.CloseOperatorSession(ctx, "ses_run"); err != nil {
|
||||
t.Fatalf("closing a non-operator session errored: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOperatorSessionsMigrationAddsClosedAt proves an existing database created
|
||||
// before the closed state opens cleanly: the column is added with a default, so
|
||||
// every existing session stays open and Close/Reopen work afterwards.
|
||||
func TestOperatorSessionsMigrationAddsClosedAt(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
path := filepath.Join(t.TempDir(), "migrate.db")
|
||||
store, err := Open(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := store.RecordOperatorSession(ctx, "ses_old", "/work/old", "Old", "operator"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Simulate the pre-closed schema by dropping the column, then reopen.
|
||||
if _, err := store.db.ExecContext(ctx, "ALTER TABLE operator_sessions DROP COLUMN closed_at"); err != nil {
|
||||
t.Fatalf("drop closed_at: %v", err)
|
||||
}
|
||||
if err := store.Close(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
store, err = Open(path)
|
||||
if err != nil {
|
||||
t.Fatalf("Open after drop: %v", err)
|
||||
}
|
||||
defer store.Close()
|
||||
rows, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 1 || rows[0].ID != "ses_old" || rows[0].ClosedAt != 0 {
|
||||
t.Fatalf("migrated rows = %+v, want the old session open", rows)
|
||||
}
|
||||
if err := store.CloseOperatorSession(ctx, "ses_old"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if rows, err := store.OperatorSessions(ctx); err != nil || len(rows) != 1 || rows[0].ClosedAt <= 0 {
|
||||
t.Fatalf("close after migration failed: %+v %v", rows, err)
|
||||
}
|
||||
}
|
||||
+76
-14
@@ -26,6 +26,24 @@ const (
|
||||
ChatMessages = "chat_messages"
|
||||
ChatInterrupt = "chat_interrupt"
|
||||
ChatReply = "chat_reply"
|
||||
// ChatClose finishes an operator session and records it as closed on the
|
||||
// server: any in-flight turn is interrupted through the existing interrupt,
|
||||
// nothing is deleted (the session, its transcript and its history survive) and
|
||||
// the closed state is shared by every client because it lives in the
|
||||
// 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, 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
|
||||
@@ -49,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.
|
||||
@@ -111,11 +132,29 @@ 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
|
||||
// shared by every client (it lives in the operator-session registry, not on
|
||||
// one device). ClosedAt is the epoch-millisecond close time, 0 while open.
|
||||
// Additive/omitempty so older peers ignore them.
|
||||
Closed bool `json:"closed,omitempty"`
|
||||
ClosedAt int64 `json:"closed_at,omitempty"`
|
||||
}
|
||||
|
||||
// ChatCloseResult reports the outcome of a chat_close: the session id, the
|
||||
// epoch-millisecond time the closed state was recorded, and whether an
|
||||
// in-flight turn was interrupted to stop it. It is the record that a running
|
||||
// turn was stopped, so a stream is never left running into nothing.
|
||||
type ChatCloseResult struct {
|
||||
SessionID string `json:"session_id"`
|
||||
ClosedAt int64 `json:"closed_at"`
|
||||
Interrupted bool `json:"interrupted,omitempty"`
|
||||
}
|
||||
|
||||
// ChatCreateRequest is the chat_create request body: a title and an optional
|
||||
@@ -144,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
|
||||
@@ -225,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.
|
||||
@@ -258,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
|
||||
@@ -271,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"`
|
||||
}
|
||||
|
||||
@@ -22,10 +22,18 @@ func chatSamples() []struct {
|
||||
Directory: "/work", ParentID: "ses_0", Tag: ChatSessionTagOperator, CreatedAt: 1792112366711, UpdatedAt: 1792112367999,
|
||||
}},
|
||||
{"session_busy", ChatSession{ID: "ses_2", Title: "held", Busy: true}},
|
||||
{"session_closed", ChatSession{ID: "ses_3", Title: "done", Closed: true, ClosedAt: 1792112367999}},
|
||||
{"close_result", ChatCloseResult{SessionID: "ses_3", ClosedAt: 1792112367999, Interrupted: true}},
|
||||
{"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{
|
||||
@@ -64,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"}},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -166,6 +178,7 @@ func TestChatEnvelopeRoundTrip(t *testing.T) {
|
||||
},
|
||||
ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject},
|
||||
ChatDirectories: []string{"/home/operator", "/work/project"},
|
||||
ChatClose: &ChatCloseResult{SessionID: "ses_1", ClosedAt: 1792112367999, Interrupted: true},
|
||||
}
|
||||
encoded, err := json.Marshal(message)
|
||||
if err != nil {
|
||||
@@ -188,7 +201,8 @@ func TestChatEnvelopeRoundTrip(t *testing.T) {
|
||||
!reflect.DeepEqual(decoded.ChatEvent, message.ChatEvent) ||
|
||||
!reflect.DeepEqual(decoded.ChatPermission, message.ChatPermission) ||
|
||||
!reflect.DeepEqual(decoded.ChatReply, message.ChatReply) ||
|
||||
!reflect.DeepEqual(decoded.ChatDirectories, message.ChatDirectories) {
|
||||
!reflect.DeepEqual(decoded.ChatDirectories, message.ChatDirectories) ||
|
||||
!reflect.DeepEqual(decoded.ChatClose, message.ChatClose) {
|
||||
t.Fatalf("chat payloads lost: %+v", decoded)
|
||||
}
|
||||
}
|
||||
@@ -198,7 +212,7 @@ func TestChatFieldsOmittedWhenUnused(t *testing.T) {
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_adopt", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_permission", "chat_reply", "chat_directories"} {
|
||||
for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_adopt", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_permission", "chat_reply", "chat_directories", "chat_close"} {
|
||||
if strings.Contains(string(minimal), absent) {
|
||||
t.Fatalf("absent %q must be omitted: %s", absent, minimal)
|
||||
}
|
||||
|
||||
@@ -166,6 +166,16 @@ type Message struct {
|
||||
ChatEvent *ChatEventFrame `json:"chat_event,omitempty"`
|
||||
ChatPermission *ChatPermissionFrame `json:"chat_permission,omitempty"`
|
||||
ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"`
|
||||
// ChatClose carries the outcome of a chat_close; the close and reopen
|
||||
// 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
|
||||
|
||||
+23
-5
@@ -44,12 +44,21 @@ type operatorRegistry interface {
|
||||
TouchOperatorSession(ctx context.Context, sessionID string) error
|
||||
OperatorSessions(ctx context.Context) ([]pipeline.OperatorSession, error)
|
||||
OperatorDirectories(ctx context.Context, limit int) ([]string, error)
|
||||
// OperatorSession returns one recorded operator session by id (found false
|
||||
// when the id is not an operator session), so chat_close/chat_reopen can echo
|
||||
// the updated row and refuse a session that is not theirs.
|
||||
OperatorSession(ctx context.Context, sessionID string) (pipeline.OperatorSession, bool, error)
|
||||
// CloseOperatorSession records the closed state; ReopenOperatorSession clears
|
||||
// it. Neither deletes anything, and neither touches a pipeline-owned run
|
||||
// session (which has no operator_sessions row).
|
||||
CloseOperatorSession(ctx context.Context, sessionID string) error
|
||||
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 {
|
||||
@@ -68,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
|
||||
@@ -78,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)
|
||||
@@ -89,6 +101,12 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker
|
||||
case protocol.ChatDirectories:
|
||||
handleChatDirectories(ctx, request, registry, write)
|
||||
return true
|
||||
case protocol.ChatClose:
|
||||
handleChatClose(ctx, request, broker, hub, registry, write)
|
||||
return true
|
||||
case protocol.ChatReopen:
|
||||
handleChatReopen(ctx, request, registry, write)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -1,65 +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
|
||||
}
|
||||
|
||||
// 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
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
|
||||
"git.a-wan.net/alan/pipelines/internal/opencode"
|
||||
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
|
||||
// handleChatClose finishes an operator chat session and records it as closed on
|
||||
// the server. It stops a turn that is running by reusing the existing interrupt
|
||||
// (so a stream is never left running into nothing, and the result records that a
|
||||
// turn was stopped), then sets the closed state in the operator-session
|
||||
// registry. Nothing is deleted: the session, its transcript and its history
|
||||
// survive, and every client sees the closed state because it lives in the
|
||||
// registry, not on one device. A session id that is not a recorded operator
|
||||
// session is refused before anything is written, so a pipeline-owned run session
|
||||
// is never touched.
|
||||
func handleChatClose(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
|
||||
}
|
||||
if registry == nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "operator session registry is not configured on this server"})
|
||||
return
|
||||
}
|
||||
query := request.ChatQuery
|
||||
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
|
||||
}
|
||||
sessionID := query.SessionID
|
||||
if _, found, err := registry.OperatorSession(ctx, sessionID); err != nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
||||
return
|
||||
} else if !found {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " is not an operator chat session"})
|
||||
return
|
||||
}
|
||||
// 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. 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()})
|
||||
return
|
||||
}
|
||||
}
|
||||
if err := registry.CloseOperatorSession(ctx, sessionID); err != nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
||||
return
|
||||
}
|
||||
session, found, err := registry.OperatorSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
||||
return
|
||||
}
|
||||
if !found {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " was closed but is no longer an operator session"})
|
||||
return
|
||||
}
|
||||
wire := chatSessionFromOperator(session)
|
||||
response := protocol.Message{
|
||||
Type: protocol.ChatClose,
|
||||
ID: request.ID,
|
||||
ChatSession: &wire,
|
||||
ChatClose: &protocol.ChatCloseResult{SessionID: sessionID, ClosedAt: session.ClosedAt, Interrupted: interrupted},
|
||||
}
|
||||
// Echo the registry row on the list field so a client can splice it into
|
||||
// chat_sessions without a re-list.
|
||||
response.ChatSessions = []protocol.ChatSession{wire}
|
||||
_ = write(response)
|
||||
}
|
||||
|
||||
// handleChatReopen clears the closed state of an operator chat session so it
|
||||
// returns to the active list. Nothing is created or deleted; it is the inverse of
|
||||
// chat_close. Prompting a closed session also reopens it (the store clears the
|
||||
// closed state on touch), so both an explicit reopen and simply sending another
|
||||
// message work. A session id that is not a recorded operator session is refused.
|
||||
func handleChatReopen(ctx context.Context, request protocol.Message, registry operatorRegistry, write func(protocol.Message) error) {
|
||||
if registry == nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "operator session registry is not configured on this server"})
|
||||
return
|
||||
}
|
||||
query := request.ChatQuery
|
||||
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
|
||||
}
|
||||
sessionID := query.SessionID
|
||||
if _, found, err := registry.OperatorSession(ctx, sessionID); err != nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
||||
return
|
||||
} else if !found {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " is not an operator chat session"})
|
||||
return
|
||||
}
|
||||
if err := registry.ReopenOperatorSession(ctx, sessionID); err != nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
||||
return
|
||||
}
|
||||
session, found, err := registry.OperatorSession(ctx, sessionID)
|
||||
if err != nil {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()})
|
||||
return
|
||||
}
|
||||
if !found {
|
||||
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " is no longer an operator session"})
|
||||
return
|
||||
}
|
||||
wire := chatSessionFromOperator(session)
|
||||
response := protocol.Message{
|
||||
Type: protocol.ChatReopen,
|
||||
ID: request.ID,
|
||||
ChatSession: &wire,
|
||||
}
|
||||
response.ChatSessions = []protocol.ChatSession{wire}
|
||||
_ = write(response)
|
||||
}
|
||||
|
||||
// chatSessionFromOperator projects one registry row to the wire ChatSession the
|
||||
// app lists, so close/reopen and chat_sessions agree on the closed fields. The
|
||||
// id is always set; title/directory/tag are copied verbatim, and the closed
|
||||
// state comes from closed_at.
|
||||
func chatSessionFromOperator(session pipeline.OperatorSession) protocol.ChatSession {
|
||||
out := protocol.ChatSession{
|
||||
ID: session.ID,
|
||||
Title: strings.TrimSpace(session.Title),
|
||||
Directory: session.Directory,
|
||||
Tag: session.Tag,
|
||||
CreatedAt: session.CreatedAt,
|
||||
UpdatedAt: session.UpdatedAt,
|
||||
}
|
||||
if session.ClosedAt > 0 {
|
||||
out.Closed = true
|
||||
out.ClosedAt = session.ClosedAt
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,313 @@
|
||||
package server
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/coder/websocket/wsjson"
|
||||
|
||||
"git.a-wan.net/alan/pipelines/internal/protocol"
|
||||
)
|
||||
|
||||
// TestChatCloseRecordsClosedState is the close-records-state evidence: a
|
||||
// chat_close on a recorded operator session answers with the closed session, sets
|
||||
// closed_at in the registry and leaves the session listed (as closed) by
|
||||
// chat_sessions, so every client sees the same state.
|
||||
func TestChatCloseRecordsClosedState(t *testing.T) {
|
||||
store := newOperatorStore(t)
|
||||
broker := scriptedChat()
|
||||
broker.sessions = []protocol.ChatSession{{ID: "ses_1", Title: "A", Directory: "/work/a"}}
|
||||
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
||||
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var response protocol.Message
|
||||
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.ChatClose || response.ID != "cl1" {
|
||||
t.Fatalf("chat_close response = %+v", response)
|
||||
}
|
||||
if response.ChatSession == nil || !response.ChatSession.Closed || response.ChatSession.ClosedAt <= 0 {
|
||||
t.Fatalf("closed session not reported: %+v", response.ChatSession)
|
||||
}
|
||||
if response.ChatClose == nil || response.ChatClose.SessionID != "ses_1" || response.ChatClose.ClosedAt <= 0 {
|
||||
t.Fatalf("chat_close result = %+v", response.ChatClose)
|
||||
}
|
||||
if response.ChatClose.Interrupted {
|
||||
t.Fatalf("idle session reported an interrupted turn: %+v", response.ChatClose)
|
||||
}
|
||||
if _, interrupts, _ := broker.counts(); interrupts != 0 {
|
||||
t.Fatalf("idle close interrupted a turn: %d", interrupts)
|
||||
}
|
||||
rows, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 1 || rows[0].ClosedAt <= 0 {
|
||||
t.Fatalf("registry did not record the closed state: %+v", rows)
|
||||
}
|
||||
|
||||
// The list still carries the session, marked closed, so it is reachable as
|
||||
// history rather than disappearing.
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "l1"}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 1 {
|
||||
t.Fatalf("chat_sessions = %+v", response)
|
||||
}
|
||||
if !response.ChatSessions[0].Closed || response.ChatSessions[0].ClosedAt <= 0 {
|
||||
t.Fatalf("closed session not listed as closed: %+v", response.ChatSessions[0])
|
||||
}
|
||||
}
|
||||
|
||||
// TestChatCloseStopsRunningTurn is the close-stops-a-running-turn evidence: a
|
||||
// prompt holds the session (its stream is live), and chat_close from another
|
||||
// connection interrupts it through the existing broker interrupt and reports that
|
||||
// a turn was stopped.
|
||||
func TestChatCloseStopsRunningTurn(t *testing.T) {
|
||||
store := newOperatorStore(t)
|
||||
broker := scriptedChat()
|
||||
broker.block = true
|
||||
broker.started = make(chan struct{})
|
||||
broker.done = make(chan struct{})
|
||||
ctx, _, conns := dialChatConns(t, Options{Chat: broker, OperatorRegistry: store}, 2)
|
||||
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// Start a long-running turn on the first connection.
|
||||
if err := wsjson.Write(ctx, conns[0], protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "long running"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var ack protocol.Message
|
||||
if err := wsjson.Read(ctx, conns[0], &ack); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ack.Type != protocol.ChatPrompt {
|
||||
t.Fatalf("prompt ack = %+v", ack)
|
||||
}
|
||||
<-broker.started
|
||||
|
||||
// Close from the second connection; it must interrupt the running turn.
|
||||
if err := wsjson.Write(ctx, conns[1], protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var response protocol.Message
|
||||
if err := wsjson.Read(ctx, conns[1], &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.ChatClose || response.ID != "cl1" {
|
||||
t.Fatalf("chat_close response = %+v", response)
|
||||
}
|
||||
if response.ChatClose == nil || !response.ChatClose.Interrupted {
|
||||
t.Fatalf("close did not record a stopped turn: %+v", response.ChatClose)
|
||||
}
|
||||
if _, interrupts, _ := broker.counts(); interrupts != 1 {
|
||||
t.Fatalf("interrupts = %d, want 1", interrupts)
|
||||
}
|
||||
rows, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 1 || rows[0].ClosedAt <= 0 {
|
||||
t.Fatalf("registry did not record the closed state: %+v", rows)
|
||||
}
|
||||
}
|
||||
|
||||
// TestChatCloseKeepsSessionAndMessages pins that closing deletes nothing: the
|
||||
// registry row survives (only its closed_at changes) and the session's history is
|
||||
// still readable afterwards.
|
||||
func TestChatCloseKeepsSessionAndMessages(t *testing.T) {
|
||||
store := newOperatorStore(t)
|
||||
broker := scriptedChat()
|
||||
broker.messages = []protocol.ChatMessage{{ID: "m1", SessionID: "ses_1", Role: protocol.ChatRoleUser}}
|
||||
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
||||
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
before, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var response protocol.Message
|
||||
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.ChatClose {
|
||||
t.Fatalf("close failed: %+v", response)
|
||||
}
|
||||
after, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(after) != 1 || after[0].ID != before[0].ID || after[0].Directory != before[0].Directory ||
|
||||
after[0].Title != before[0].Title || after[0].Tag != before[0].Tag || after[0].CreatedAt != before[0].CreatedAt {
|
||||
t.Fatalf("close changed the session beyond closed_at:\nbefore %+v\nafter %+v", before[0], after[0])
|
||||
}
|
||||
// The transcript is still readable.
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "ms1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.ChatMessages || len(response.ChatMessages) != 1 || response.ChatMessages[0].ID != "m1" {
|
||||
t.Fatalf("history lost after close: %+v", response)
|
||||
}
|
||||
if calls, _, _ := broker.messageQuery(); calls != 1 {
|
||||
t.Fatalf("message reads = %d, want 1", calls)
|
||||
}
|
||||
}
|
||||
|
||||
// TestChatReopenClearsClosedState pins that chat_reopen is the inverse of
|
||||
// chat_close: the closed state is cleared and the session is listed as active
|
||||
// again.
|
||||
func TestChatReopenClearsClosedState(t *testing.T) {
|
||||
store := newOperatorStore(t)
|
||||
broker := scriptedChat()
|
||||
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
||||
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := store.CloseOperatorSession(ctx, "ses_1"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReopen, ID: "op1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var response protocol.Message
|
||||
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.ChatReopen || response.ID != "op1" || response.ChatSession == nil {
|
||||
t.Fatalf("chat_reopen response = %+v", response)
|
||||
}
|
||||
if response.ChatSession.Closed || response.ChatSession.ClosedAt != 0 {
|
||||
t.Fatalf("reopened session still closed: %+v", response.ChatSession)
|
||||
}
|
||||
rows, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 1 || rows[0].ClosedAt != 0 {
|
||||
t.Fatalf("registry still closed after reopen: %+v", rows)
|
||||
}
|
||||
}
|
||||
|
||||
// TestChatPromptReopensClosedSession pins the second reopen path: simply
|
||||
// prompting a closed session clears its closed state, so the operator never has
|
||||
// to make an explicit reopen request.
|
||||
func TestChatPromptReopensClosedSession(t *testing.T) {
|
||||
store := newOperatorStore(t)
|
||||
broker := scriptedChat()
|
||||
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
||||
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := store.CloseOperatorSession(ctx, "ses_1"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "resume"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var ack protocol.Message
|
||||
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if ack.Type != protocol.ChatPrompt {
|
||||
t.Fatalf("prompt ack = %+v", ack)
|
||||
}
|
||||
_ = readChatTurn(t, ctx, conn)
|
||||
rows, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 1 || rows[0].ClosedAt != 0 {
|
||||
t.Fatalf("prompting did not clear the closed state: %+v", rows)
|
||||
}
|
||||
}
|
||||
|
||||
// TestChatCloseRefusesNonOperatorSession pins that a pipeline-owned run session
|
||||
// (which has no operator_sessions row) is refused and nothing is written, so the
|
||||
// close never touches the sessions the pipelines own.
|
||||
func TestChatCloseRefusesNonOperatorSession(t *testing.T) {
|
||||
store := newOperatorStore(t)
|
||||
broker := scriptedChat()
|
||||
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_run"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var response protocol.Message
|
||||
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.Error || !strings.Contains(response.Error, "not an operator") {
|
||||
t.Fatalf("non-operator session not refused: %+v", response)
|
||||
}
|
||||
if _, interrupts, _ := broker.counts(); interrupts != 0 {
|
||||
t.Fatalf("refused close still interrupted: %d", interrupts)
|
||||
}
|
||||
rows, err := store.OperatorSessions(ctx)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(rows) != 0 {
|
||||
t.Fatalf("refused close wrote a registry row: %+v", rows)
|
||||
}
|
||||
}
|
||||
|
||||
// TestChatCloseRejectsInvalidInput pins that a missing/invalid session id and an
|
||||
// unconfigured broker/registry are answered with an error before any write.
|
||||
func TestChatCloseRejectsInvalidInput(t *testing.T) {
|
||||
store := newOperatorStore(t)
|
||||
broker := scriptedChat()
|
||||
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
||||
for _, query := range []*protocol.ChatQuery{nil, {}, {SessionID: "not-a-session"}} {
|
||||
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "bad", ChatQuery: query}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var response protocol.Message
|
||||
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.Error || response.ID != "bad" {
|
||||
t.Fatalf("query %+v not rejected: %+v", query, response)
|
||||
}
|
||||
}
|
||||
|
||||
// No registry configured: refuse rather than close nothing.
|
||||
noRegCtx, cancelNoReg, noRegConn := dialChatOptions(t, Options{Chat: broker})
|
||||
defer cancelNoReg()
|
||||
if err := wsjson.Write(noRegCtx, noRegConn, protocol.Message{Type: protocol.ChatClose, ID: "nr", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
var response protocol.Message
|
||||
if err := wsjson.Read(noRegCtx, noRegConn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.Error || !strings.Contains(response.Error, "registry") {
|
||||
t.Fatalf("close without registry = %+v", response)
|
||||
}
|
||||
|
||||
// No broker configured: the existing "not configured" error.
|
||||
noBrokerCtx, cancelNoBroker, noBrokerConn := dialChatOptions(t, Options{OperatorRegistry: store})
|
||||
defer cancelNoBroker()
|
||||
if err := wsjson.Write(noBrokerCtx, noBrokerConn, protocol.Message{Type: protocol.ChatClose, ID: "nb", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := wsjson.Read(noBrokerCtx, noBrokerConn, &response); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") {
|
||||
t.Fatalf("close without broker = %+v", response)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
+73
-15
@@ -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
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
@@ -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
|
||||
@@ -74,7 +74,12 @@ func handleChatSessions(ctx context.Context, request protocol.Message, broker ch
|
||||
session.Tag = operator.Tag
|
||||
session.CreatedAt = operator.CreatedAt
|
||||
session.UpdatedAt = operator.UpdatedAt
|
||||
session.Busy = hub.busyForOther(operator.ID, clientID)
|
||||
// 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. 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
|
||||
response.ChatSessions = append(response.ChatSessions, session)
|
||||
}
|
||||
_ = write(response)
|
||||
|
||||
+67
-156
@@ -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})
|
||||
}
|
||||
}
|
||||
|
||||
+29
-111
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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__":
|
||||
|
||||
Reference in New Issue
Block a user