Merge main into slash-commands: combine the composer's slash commands with the

server-side chat close

What was combined:

- main brought the server-side close (chat_close/chat_reopen over the protocol,
  PipelinesRepository.chatClose/chatReopen, ChatStore.sessionClosed/sessionReopened
  and active/closed session projections, the list's Close chat… confirmation and
  the Closed chip), plus the destinations-pill overlay and the omni-search and
  status-label work from the lanes that landed beside this one.
- this branch brought the composer's slash commands: parsing, the filtered offer
  list with Enter/tap/D-pad, the shared prompt path, /new in the current
  directory, the local /rename, /stop, /help and the unknown-command offer, with
  local command lines rendered outside the model's conversation.

Resolution (the one place the two sides disagreed):

The branch's /close reported that no real session close existed, because none did
when it was written. main now has one, so /close delegates to it instead:
AppViewModel.SessionChatCommandHost.finishSession calls closeChatSession, which
uses the server's own chat_close (a running turn is stopped, the session is marked
closed for every client, the history is kept), and then chatStore.close returns the
operator to the list. A failure is reported on the list, where the list's own close
reports it. The now-false "this build has no real session close yet" line and its
CHAT_CLOSE_UNAVAILABLE constant are removed, /close's offer summary says it
finishes the session for every client, and its test now drives the real store
close (sessionClosed + close) and asserts the row is closed, kept as history and
off the pane.

Checks run after resolving, on the merged tree (HEAD = this merge):
`--offline --no-daemon :app:assembleDebug` BUILD SUCCESSFUL, and
`:app:testDebugUnitTest` BUILD SUCCESSFUL with 646 tests, 0 failures (including
ChatCommandsTest.closeDelegatesToTheRealServerCloseAndReturnsToTheList). DimensTest
still holds: no raw dimension was added outside the token files. The packaged
templates and packaged authoring skill references are unaffected — this is an
Android-app-only change with no protocol, server, installer or Docker change — so
none of them needed updating.

Documentation now stale (not edited here; one writer folds shared docs):
android/README.md's chat section describes the composer and the session list
without the slash commands (vocabulary, offer list, unknown-command guard) and
without the composer's /close path to the server close.
This commit is contained in:
2026-10-18 00:24:41 +01:00
46 changed files with 2111 additions and 265 deletions
@@ -333,6 +333,26 @@ 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.")
@@ -33,6 +33,26 @@ data class ChatSession(
// 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
@@ -288,6 +308,24 @@ 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
@@ -68,6 +68,11 @@ 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"
@@ -688,5 +693,8 @@ data class Message(
@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,
)
@@ -41,7 +41,6 @@ import net.awan.pipelines.data.transport.ServerUrl
import net.awan.pipelines.notify.NoRunAlerts
import net.awan.pipelines.notify.RunAlertSink
import net.awan.pipelines.notify.runAlerts
import net.awan.pipelines.ui.chat.CHAT_CLOSE_UNAVAILABLE
import net.awan.pipelines.ui.chat.ChatAttachment
import net.awan.pipelines.ui.chat.ChatCommandHost
import net.awan.pipelines.ui.chat.ChatSessionOverrides
@@ -1157,6 +1156,9 @@ class AppViewModel(
// 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)
@@ -1202,8 +1204,8 @@ class AppViewModel(
* The real effects behind a slash command. `/new` creates in the current
* session's directory and switches to it (the old one stays open, listed, with
* its history); `/rename` uses the device's own rename; `/stop` interrupts;
* `/close` reports that this build has no real close instead of hiding the
* session. Nothing here is ever a prompt.
* `/close` finishes the session for every client through the server's own
* close and returns to the list. Nothing here is ever a prompt.
*/
private inner class SessionChatCommandHost(private val sessionId: String) : ChatCommandHost {
override fun startSession(directory: String) {
@@ -1228,9 +1230,13 @@ class AppViewModel(
}
override fun finishSession() {
// No session close exists in this revision: the honest answer, never
// the local hide dressed up as one.
chatStore.notice(sessionId, CHAT_CLOSE_UNAVAILABLE, failed = true)
// The server's own close: any running turn is stopped and the session
// is marked closed for every client, with its history kept. Then the
// conversation leaves the pane, so the operator is back at the list,
// where the closed chat sits as history. A failure is reported on the
// list — the same place the list's own close reports it.
closeChatSession(sessionId)
chatStore.close(sessionId)
}
override fun renameSession(title: String) {
@@ -1284,6 +1290,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)
@@ -32,6 +32,7 @@ import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
@@ -60,19 +61,27 @@ import net.awan.pipelines.ui.chat.ChatScreen
import net.awan.pipelines.ui.components.AttentionIndicator
import net.awan.pipelines.ui.components.AttentionSheet
import net.awan.pipelines.ui.components.ConnectionBanner
import net.awan.pipelines.ui.components.LocalPillBottomInset
import net.awan.pipelines.ui.components.MotionStandard
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.spec
import net.awan.pipelines.ui.screens.SettingsScreen
import net.awan.pipelines.ui.theme.ATTENTION_CHIP_RESERVE
import net.awan.pipelines.ui.theme.DESTINATION_PILL_RESERVE
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_S
/** One destination the floating pill holds: its nav [route], the accessible [label] and its glyph. */
internal data class TopDestination(val route: String, val label: String, val icon: ImageVector)
private val destinations = listOf(
/**
* The pill's destinations, in display order. Templates is deliberately absent: it
* is configuration, reached from the Settings page instead, so the pill holds only
* the surfaces a person moves between constantly. The pill's width derives from
* this list (its icon row), never a fixed value, so removing a destination only
* narrows it.
*/
internal val destinations = listOf(
TopDestination("pipelines", "Pipelines", Icons.Default.AccountTree),
TopDestination("templates", "Templates", TemplatesIcon),
TopDestination("runs", "Runs", Icons.Default.History),
TopDestination("chat", "Chat", Icons.AutoMirrored.Filled.Chat),
TopDestination("settings", "Settings", Icons.Default.Settings),
@@ -272,74 +281,78 @@ fun PipelinesApp(
// screens' app bars (a Material 3 TopAppBar applies the top safe-area inset),
// which removed the duplicate top band. The bottom is owned by each screen's
// Scaffold, and the floating pill explicitly clears the safe area (system
// bars, cutout, gesture area and IME) via windowInsetsPadding. The Column
// reserves DESTINATION_PILL_RESERVE at the bottom so no scrollable content is
// permanently hidden behind the pill; while the pill is hidden (an open
// conversation, see [destinationPillVisible]) that reservation is dropped too,
// so the composer sits at the true bottom instead of over an empty band.
// bars, cutout, gesture area and IME) via windowInsetsPadding.
//
// The pill is a true overlay: it is drawn in its own bottom-anchored layer over
// the content and never takes layout space, so the content keeps its full
// height. Nothing is positioned by the pill; its bottom clearance
// ([pillScrollInset], published through [LocalPillBottomInset]) is applied
// inside each scrollable screen's own scroll content, so scrolling to the end
// still reveals the last row clear of the pill, and while the pill is hidden
// (an open conversation, see [destinationPillVisible]) that clearance is zero
// so a hidden pill leaves no empty band. See [contentPillPadding].
val bannerVisible = connectionState !is ConnectionState.Connected
Scaffold(contentWindowInsets = WindowInsets(0, 0, 0, 0)) { padding ->
Box(Modifier.fillMaxSize().padding(padding)) {
Column(Modifier.fillMaxSize().padding(bottom = destinationPillReserve(pillVisible) + ATTENTION_CHIP_RESERVE)) {
ConnectionBanner(
state = connectionState,
configuredUrl = configuredUrl,
onReconnect = vm::reconnect,
)
NavHost(
navController = navController,
startDestination = "pipelines",
// While the banner is visible it owns the status-bar inset, so
// the inner app bars below must not apply it a second time.
modifier = Modifier
.weight(1f)
.then(
if (bannerVisible) {
Modifier.consumeWindowInsets(
paneSafeArea().only(WindowInsetsSides.Top),
)
} else {
Modifier
},
),
) {
composable("pipelines") {
PipelineDestination(
vm = vm,
wide = wide,
selection = pipelineSelection,
onSelectionChange = { pipelineSelection = it },
listState = pipelineListState,
onOpenRun = { runId ->
runSelection = PaneSelection(
pane = MasterPane.Detail,
itemId = runId,
)
navController.navigate("runs") { launchSingleTop = true }
},
)
}
composable("runs") {
RunsDestination(
vm = vm,
wide = wide,
selection = runSelection,
onSelectionChange = { runSelection = it },
pendingNav = runSearchNav,
onPendingNavResolved = { runSearchNav = null },
listState = runListState,
decisionRequest = decisionRequest,
onDecisionRequestHandled = { decisionRequest = null },
)
}
composable("chat") {
ChatScreen(vm = vm, wide = wide)
}
composable("templates") {
TemplatesDestination(vm = vm, wide = wide, listState = templateListState)
}
composable("settings") {
SettingsScreen(vm, wide = wide)
CompositionLocalProvider(LocalPillBottomInset provides pillScrollInset(pillVisible)) {
Column(Modifier.fillMaxSize().padding(bottom = contentPillPadding(pillVisible))) {
ConnectionBanner(
state = connectionState,
configuredUrl = configuredUrl,
onReconnect = vm::reconnect,
)
NavHost(
navController = navController,
startDestination = "pipelines",
// While the banner is visible it owns the status-bar inset, so
// the inner app bars below must not apply it a second time.
modifier = Modifier
.weight(1f)
.then(
if (bannerVisible) {
Modifier.consumeWindowInsets(
paneSafeArea().only(WindowInsetsSides.Top),
)
} else {
Modifier
},
),
) {
composable("pipelines") {
PipelineDestination(
vm = vm,
wide = wide,
selection = pipelineSelection,
onSelectionChange = { pipelineSelection = it },
listState = pipelineListState,
onOpenRun = { runId ->
runSelection = PaneSelection(
pane = MasterPane.Detail,
itemId = runId,
)
navController.navigate("runs") { launchSingleTop = true }
},
)
}
composable("runs") {
RunsDestination(
vm = vm,
wide = wide,
selection = runSelection,
onSelectionChange = { runSelection = it },
pendingNav = runSearchNav,
onPendingNavResolved = { runSearchNav = null },
listState = runListState,
decisionRequest = decisionRequest,
onDecisionRequestHandled = { decisionRequest = null },
)
}
composable("chat") {
ChatScreen(vm = vm, wide = wide)
}
composable("settings") {
SettingsDestination(vm = vm, wide = wide, listState = templateListState)
}
}
}
}
@@ -362,21 +375,29 @@ fun PipelinesApp(
// Composed after the NavHost, so while the field is open Back (button
// or gesture) dismisses the morph before any pane's own Back handler.
BackHandler(enabled = searchState.open) { dismissSearch() }
// The results panel and the destination bar share one bottom-anchored,
// inset-clearing column. `paneSafeArea` (WindowInsets.safeDrawing) is
// applied once here: the panel then takes exactly the height the IME and
// navigation bar leave (weight, `fill = false` so a short panel wraps)
// and scrolls inside it, and the input always sits directly below the
// panel and above the keyboard. The activity declares `adjustResize`
// and the app is edge-to-edge, so the Compose window inset is the only
// source of the IME geometry and it is applied once, here.
// The results panel, the attention chip and the destination bar share
// one bottom-anchored, inset-clearing column — the overlay layer, drawn
// above the content and never part of its layout. `paneSafeArea`
// (WindowInsets.safeDrawing) is applied once here, so the pill clears the
// system bars, cutout, gesture area and IME: the panel then takes exactly
// the height the IME and navigation bar leave (weight, `fill = false` so
// a short panel wraps) and scrolls inside it, and the input always sits
// directly below the panel and above the keyboard. The activity declares
// `adjustResize` and the app is edge-to-edge, so the Compose window inset
// is the only source of the IME geometry and it is applied once, here.
//
// The overlay's resting place is the window width's in [destinationPillAlignment]:
// horizontally centred on a narrow window, anchored to the bottom-right
// corner on a wide one. Its margin comes from the named [SPACING_L], so the
// corner placement adds no new number. That rule positions the pill; the
// attention chip above it keeps its own bottom-right place at every width.
Column(
modifier = Modifier
.fillMaxSize()
.windowInsetsPadding(paneSafeArea())
.padding(end = 16.dp, bottom = 16.dp),
.padding(end = if (wide) SPACING_L else 0.dp, bottom = SPACING_L),
verticalArrangement = Arrangement.Bottom,
horizontalAlignment = Alignment.End,
horizontalAlignment = destinationPillAlignment(wide),
) {
if (searchState.open) {
SearchResultsPanel(
@@ -389,13 +410,17 @@ fun PipelinesApp(
modifier = Modifier
.fillMaxWidth()
.weight(1f, fill = false)
.padding(bottom = 16.dp),
.padding(bottom = SPACING_L),
)
}
// The attention chip is not part of the pill's placement rule: it
// keeps its own bottom-right resting place at every width (as it
// had before the pill became width-dependent), so only the pill
// follows [destinationPillAlignment].
AttentionIndicator(
entries = attention,
onClick = { attentionOpen = true },
modifier = Modifier.padding(bottom = SPACING_S),
modifier = Modifier.align(Alignment.End).padding(bottom = SPACING_S),
)
// The pill stands down while a conversation is open; the search
// field it morphs into is unreachable there anyway (the field opens
@@ -469,14 +494,40 @@ internal fun destinationPillVisible(currentRoute: String?, conversationOpen: Boo
!(currentRoute == CHAT_ROUTE && conversationOpen)
/**
* The bottom space the content reserves for the pill: the named
* [DESTINATION_PILL_RESERVE] while the pill is drawn, and none while it is
* hidden, so a hidden pill leaves no empty band at the end of scrollable content
* and the composer sits at the true bottom. Derived from [pillVisible] alone, so
* the reservation and the drawn pill can never disagree into a frame with a
* drawn pill over content it does not clear, or a reserved gap behind a hidden
* one — which is what keeps the content from jumping as the pill appears and
* disappears.
* Where the bottom overlay — the destination pill and the attention chip above it
* — rests in the window: horizontally centred on a **narrow** window and anchored
* to the bottom-right **corner** on a **wide** one. The overlay is drawn above the
* content and never takes layout space either way, so this is purely where it
* sits. A pure function of the window width, so the one arrangement rule is
* unit-testable and no screen hardcodes a width.
*/
internal fun destinationPillReserve(pillVisible: Boolean): Dp =
if (pillVisible) DESTINATION_PILL_RESERVE else 0.dp
internal fun destinationPillAlignment(wide: Boolean): Alignment.Horizontal =
if (wide) Alignment.End else Alignment.CenterHorizontally
/**
* The bottom padding the app's content column applies for the pill: none, whether
* the pill is [pillVisible] or not. The pill is an overlay drawn above the
* content, so it must never size or offset it — the content keeps its own full
* height and the pill's clearance lives in each scrollable's own scroll content
* (see [pillScrollInset]). The value is a function of the drawn state (both of
* which the unit test pins at zero) rather than left implicit in an absent
* modifier, so a later change that reintroduces a reserved band here fails the
* test.
*/
internal fun contentPillPadding(pillVisible: Boolean): Dp = 0.dp
/**
* The trailing bottom space a scrollable screen keeps so its last row scrolls clear
* of the floating bottom stack — the destination pill and the attention chip above
* it — built from the named [DESTINATION_PILL_RESERVE] and [ATTENTION_CHIP_RESERVE]
* while the pill is drawn, and none while it is hidden (an open conversation, see
* [destinationPillVisible]) so a hidden pill leaves no empty band at the end of a
* list. Published to the content through `LocalPillBottomInset` and applied inside
* each scrollable's own scroll content, never as layout padding on the content. It
* is derived from [pillVisible] alone, so the clearance and the drawn pill can
* never disagree into a frame with a drawn pill over content it does not clear, or
* a reserved gap behind a hidden one — which is what keeps a list from jumping as
* the pill appears and disappears.
*/
internal fun pillScrollInset(pillVisible: Boolean): Dp =
if (pillVisible) DESTINATION_PILL_RESERVE + ATTENTION_CHIP_RESERVE else 0.dp
@@ -0,0 +1,89 @@
package net.awan.pipelines.ui
import androidx.activity.compose.PredictiveBackHandler
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Settings
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import kotlinx.coroutines.flow.collect
import net.awan.pipelines.ui.components.SlidingPaneStack
import net.awan.pipelines.ui.components.rememberPaneContent
import net.awan.pipelines.ui.screens.SettingsScreen
import net.awan.pipelines.ui.screens.TemplateDetailScreen
import net.awan.pipelines.ui.screens.TemplateGalleryScreen
/**
* The Settings destination: the same shared pane stack the other destinations
* use, with the settings page as pane 0 and the templates gallery it opens from
* its Templates row as pane 1 and the selected template's detail as pane 2.
* Templates is configuration, so it is one of the settings destinations rather
* than a floating-pill entry; the gallery is the existing [TemplateGalleryScreen]
* (and its detail the existing [TemplateDetailScreen]), so no second templates
* surface is built. Its selection is saved state, so it survives rotation,
* configuration change and process death; the covered-pane strip, the back gesture
* and the pane's own back control all step exactly one level via [settingsBack].
* Nothing here starts a run.
*/
@Composable
internal fun SettingsDestination(
vm: AppViewModel,
wide: Boolean,
listState: LazyListState,
) {
var selection by rememberSaveable(stateSaver = SettingsSelectionSaver) {
mutableStateOf(SettingsSelection())
}
val depth = selection.depth
val onBack: () -> Unit = { selection = settingsBack(selection) }
PredictiveBackHandler(enabled = depth >= 1) { progress ->
// Consume the gesture; on completion perform exactly one Back step.
progress.collect { }
onBack()
}
SlidingPaneStack(
depth = depth,
wide = wide,
onPopTo = { level -> selection = settingsPopTo(selection, level) },
compactLabel = "Settings",
compactIcon = Icons.Filled.Settings,
backContentDescription = { level ->
if (level == 0) "Back to settings" else "Back to templates"
},
pane = { level, covered, paneModifier ->
when (level) {
0 -> SettingsScreen(
vm = vm,
onOpenTemplates = { selection = openTemplatesGallery(selection) },
wide = wide,
modifier = paneModifier,
covered = covered,
)
1 -> TemplateGalleryScreen(
vm = vm,
wide = wide,
onOpen = { key -> selection = openTemplateDetail(selection, key) },
listState = listState,
modifier = paneModifier,
covered = covered,
)
2 -> rememberPaneContent(selection.templateKey)?.let { key ->
TemplateDetailScreen(
vm = vm,
templateKey = key,
onBack = onBack,
wide = wide,
modifier = paneModifier,
covered = covered,
)
}
}
},
)
}
@@ -0,0 +1,86 @@
package net.awan.pipelines.ui
import androidx.compose.runtime.saveable.Saver
/**
* Which pane of the Settings destination's sliding stack is rightmost: the
* settings page itself (level 0), the templates gallery opened from its Templates
* row (level 1) or the selected template's detail (level 2). Templates is
* configuration, so it is one of the settings destinations reached from the
* Settings page rather than an entry in the floating destination pill; modelling
* the stack here is what gives the gallery the same covered-pane strip and
* one-level Back step the other destinations use.
*/
internal enum class SettingsPane(val level: Int) {
Settings(0),
Gallery(1),
Template(2),
}
/**
* The Settings destination's saved pane selection. The only state beyond the
* rightmost pane is the open template's key, so the whole selection is
* Bundle-able primitives and survives rotation, configuration change and process
* death. Geometry (peek widths, insets) is deliberately not part of the model; it
* is derived from layout by the shared stack.
*/
internal data class SettingsSelection(
val pane: SettingsPane = SettingsPane.Settings,
val templateKey: String? = null,
) {
/** How many panes are stacked: 0 settings, 1 gallery, 2 template detail. */
val depth: Int
get() = pane.level
}
/** The Settings page's Templates row opens the gallery as its own pane. */
internal fun openTemplatesGallery(selection: SettingsSelection): SettingsSelection =
selection.copy(pane = SettingsPane.Gallery, templateKey = null)
/** A gallery card opens the selected template's detail as the next pane. */
internal fun openTemplateDetail(selection: SettingsSelection, key: String): SettingsSelection =
selection.copy(pane = SettingsPane.Template, templateKey = key)
/**
* Exactly one pane level of Back, so the back gesture, the covered strip's tap and
* the detail's own back control all step the same single level: detail → gallery →
* settings. At settings there is nothing to close and the selection is unchanged,
* so the caller lets Back leave the destination.
*/
internal fun settingsBack(selection: SettingsSelection): SettingsSelection = when (selection.pane) {
SettingsPane.Settings -> selection
SettingsPane.Gallery -> selection.copy(pane = SettingsPane.Settings, templateKey = null)
SettingsPane.Template -> selection.copy(pane = SettingsPane.Gallery, templateKey = null)
}
/**
* The selection after tapping a covered pane's strip at [level]: every pane to its
* right is closed. Level 0 closes back to the settings page, level 1 closes the
* template detail back to the gallery, and a [level] at or beyond the current
* depth is a no-op. Peeks exist only on a wide window; narrow windows use
* Back/gesture for the same one-level step.
*/
internal fun settingsPopTo(selection: SettingsSelection, level: Int): SettingsSelection = when {
level <= 0 -> SettingsSelection()
level == 1 -> selection.copy(pane = SettingsPane.Gallery, templateKey = null)
else -> selection
}
/**
* Encodes a [SettingsSelection] as Bundle-able primitives. Paired with
* [decodeSettingsSelection].
*/
internal fun encodeSettingsSelection(selection: SettingsSelection): List<Any> =
listOf(selection.pane.name, selection.templateKey ?: "")
/** Restores a [SettingsSelection] encoded by [encodeSettingsSelection]. */
internal fun decodeSettingsSelection(encoded: List<Any>): SettingsSelection = SettingsSelection(
pane = SettingsPane.valueOf(encoded[0] as String),
templateKey = (encoded[1] as String).takeIf { it.isNotEmpty() },
)
/** Saves/restores a [SettingsSelection] across configuration change and process death. */
internal val SettingsSelectionSaver: Saver<SettingsSelection, List<Any>> = Saver(
save = { encodeSettingsSelection(it) },
restore = { decodeSettingsSelection(it) },
)
@@ -1,70 +0,0 @@
package net.awan.pipelines.ui
import androidx.activity.compose.PredictiveBackHandler
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Modifier
import kotlinx.coroutines.flow.collect
import net.awan.pipelines.ui.components.SlidingPaneStack
import net.awan.pipelines.ui.components.rememberPaneContent
import net.awan.pipelines.ui.screens.TemplateDetailScreen
import net.awan.pipelines.ui.screens.TemplateGalleryScreen
/**
* The Templates destination: the same shared pane stack, with the template
* gallery as pane 0 and the selected template's detail as pane 1. The selected
* template key is the saved state, so it survives rotation, configuration change
* and process death; Back/the peek pop one level. Nothing here starts a run.
*/
@Composable
internal fun TemplatesDestination(
vm: AppViewModel,
wide: Boolean,
listState: LazyListState,
) {
var selectedKey by rememberSaveable { mutableStateOf<String?>(null) }
val depth = if (selectedKey == null) 0 else 1
val onBack: () -> Unit = { selectedKey = null }
PredictiveBackHandler(enabled = depth >= 1) { progress ->
progress.collect { }
onBack()
}
SlidingPaneStack(
depth = depth,
wide = wide,
onPopTo = { level -> if (level <= 0) selectedKey = null },
compactLabel = "Templates",
compactIcon = TemplatesIcon,
backContentDescription = { level ->
if (level == 0) "Back to templates" else "Back to template"
},
pane = { level, covered, paneModifier ->
when (level) {
0 -> TemplateGalleryScreen(
vm = vm,
wide = wide,
onOpen = { key -> selectedKey = key },
listState = listState,
modifier = paneModifier,
covered = covered,
)
1 -> rememberPaneContent(selectedKey)?.let { key ->
TemplateDetailScreen(
vm = vm,
templateKey = key,
onBack = onBack,
wide = wide,
modifier = paneModifier,
covered = covered,
)
}
}
},
)
}
@@ -25,15 +25,15 @@ internal const val CHAT_COMMAND_HELP = "help"
* terminal's own vocabulary is the model here (`:status`, `:logs`, …): a command
* acts on the chat surface itself and is never sent to the agent.
*
* `/close` is shown as unavailable in this revision: the server has no request
* that finishes a session for every client yet, and the app will not pretend the
* local "remove from list" is that close.
* `/close` is the server's own close (`chat_close`, shared by every client), not
* the local "remove from list": the chat is finished for every device, its
* history is kept, and it can be reopened.
*/
internal val CHAT_COMMANDS: List<ChatCommand> = listOf(
ChatCommand(CHAT_COMMAND_NEW, "Start a fresh session in this directory", "/new"),
ChatCommand(
CHAT_COMMAND_CLOSE,
"Finish this session for every client (not available in this build)",
"Finish this session for every client, keeping its history",
"/close",
),
ChatCommand(CHAT_COMMAND_RENAME, "Rename this session on this device", "/rename <title>", takesArgument = true),
@@ -211,8 +211,3 @@ internal fun runChatSlashCommand(text: String, thread: ChatThread, host: ChatCom
is ChatCommandEffect.Report -> host.notify(effect.text, failed = true, offer = effect.offer)
}
}
/** What `/close` says in this revision, where no real session close exists. */
internal const val CHAT_CLOSE_UNAVAILABLE =
"Can't finish this session: this build has no real session close yet, so nothing was " +
"changed. The session stays open and listed; no local hide was used instead."
@@ -3,6 +3,7 @@ package net.awan.pipelines.ui.chat
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
@@ -33,6 +34,7 @@ import net.awan.pipelines.ui.AppViewModel
import net.awan.pipelines.ui.components.ErrorState
import net.awan.pipelines.ui.components.ListRow
import net.awan.pipelines.ui.components.LoadingState
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
import net.awan.pipelines.ui.theme.pipelinesText
@@ -85,7 +87,10 @@ internal fun NewChatPane(
color = MaterialTheme.colorScheme.onSurfaceVariant,
modifier = Modifier.padding(horizontal = CHAT_GUTTER, vertical = CHAT_ITEM_GAP),
)
LazyColumn(Modifier.weight(1f).fillMaxWidth()) {
LazyColumn(
modifier = Modifier.weight(1f).fillMaxWidth(),
contentPadding = pillContentPadding(PaddingValues()),
) {
items(choices, key = { it.createDirectory }) { choice ->
DirectoryRow(
choice = choice,
@@ -252,11 +252,20 @@ private const val OPERATOR_TAG_LABEL = "Operator"
* prompt from any client, so the session stays writable everywhere.
*/
internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String =
sessionStatusLabel(runningLocally)
sessionStatusLabel(runningLocally, session.closed)
/** The status of a conversation from its own running flag (see [sessionStatusLabel]). */
internal fun sessionStatusLabel(runningLocally: Boolean): String =
if (runningLocally) "Running" else "Idle"
/**
* 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"
else -> "Idle"
}
/**
* The activity a session row signals beyond its open/tag/directory state. An
@@ -298,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.running),
activity = sessionStatusLabel(thread.running, thread.closed),
directory = thread.directory,
model = thread.model,
)
@@ -388,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
@@ -4,6 +4,7 @@ import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
@@ -55,6 +56,7 @@ import net.awan.pipelines.ui.components.LabelChip
import net.awan.pipelines.ui.components.ListRow
import net.awan.pipelines.ui.components.LoadingState
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.theme.ICON_BUTTON_SMALL_DP
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
import net.awan.pipelines.ui.theme.SPACING_M
@@ -94,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
@@ -115,6 +119,7 @@ internal fun ChatListPane(
}
}
var renaming by remember { mutableStateOf<ChatSession?>(null) }
var closing by remember { mutableStateOf<ChatSession?>(null) }
Scaffold(
modifier = modifier,
@@ -169,7 +174,10 @@ internal fun ChatListPane(
// drift hundreds of pixels from its title, the same constraint the
// other lists and detail bodies use; narrow windows fill as before.
else -> DetailTabBody(wide, Modifier.fillMaxSize()) { listModifier ->
LazyColumn(listModifier) {
LazyColumn(
modifier = listModifier,
contentPadding = pillContentPadding(PaddingValues()),
) {
if (groups.size > 1) {
// More than one directory: one section per repository so
// same-directory chats sit together, each keeping the
@@ -177,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) {
@@ -211,6 +228,16 @@ internal fun ChatListPane(
},
)
}
closing?.let { session ->
CloseChatDialog(
session = session,
onDismiss = { closing = null },
onConfirm = {
vm.closeChatSession(session.id)
closing = null
},
)
}
}
/**
@@ -251,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,
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) },
)
}
@@ -295,7 +325,9 @@ private fun SessionRow(
active: Boolean,
onClick: () -> Unit,
onRename: () -> Unit,
onRemove: () -> Unit,
onClose: () -> Unit,
onReopen: () -> Unit,
onHide: () -> Unit,
) {
val texts = pipelinesText()
val running = thread?.running == true
@@ -316,10 +348,20 @@ 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(sessionWorkLabel(session.busy, thread))
@@ -330,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)) {
@@ -350,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
@@ -396,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.
@@ -71,6 +71,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,
@@ -274,6 +280,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 }
}
/**
@@ -356,6 +377,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
@@ -457,9 +479,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
@@ -481,6 +505,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 -------------------------------------------------
/**
@@ -506,6 +568,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
@@ -517,6 +580,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 },
@@ -868,6 +932,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)
}
@@ -0,0 +1,53 @@
package net.awan.pipelines.ui.components
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
import androidx.compose.runtime.compositionLocalOf
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalLayoutDirection
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
/**
* The floating destination pill's clearance at the bottom of the content, as the
* app shell computes it for the current window and route (see
* `pillScrollInset`). It is published around the content so a scrollable screen
* can add it to its own scroll content's bottom padding and let its last row
* scroll clear of the pill, without the pill ever taking or positioning layout
* space. Defaults to zero, so a screen composed outside the app shell (a preview,
* a test) keeps exactly its own padding.
*/
internal val LocalPillBottomInset = compositionLocalOf { 0.dp }
/**
* [base] with the floating pill's clearance added at the bottom, for a scroll
* container's `contentPadding`. It adds the clearance **inside** the scroll
* content, so the container keeps its full height and its last row can still be
* scrolled into view above the pill; it is deliberately not a layout padding on
* the container, which would shrink the viewport and hide the row behind the pill
* instead. Returns [base] unchanged when no pill is drawn.
*/
@Composable
internal fun pillContentPadding(base: PaddingValues): PaddingValues {
val inset = LocalPillBottomInset.current
if (inset == 0.dp) return base
val direction = LocalLayoutDirection.current
return PaddingValues(
start = base.calculateLeftPadding(direction),
top = base.calculateTopPadding(),
end = base.calculateRightPadding(direction),
bottom = base.calculateBottomPadding() + inset,
)
}
/**
* Adds the floating pill's clearance as bottom padding on a scrollable's **own
* content** (a `Column` inside `verticalScroll`, or any content whose end must
* clear the pill), for the cases a `LazyColumn`'s `contentPadding` cannot reach.
* Like [pillContentPadding] it is content padding, not a layout inset, so the
* container keeps its full height and only its last content scrolls clear of the
* pill. A no-op when no pill is drawn.
*/
@Composable
internal fun Modifier.pillBottomPadding(): Modifier = padding(bottom = LocalPillBottomInset.current)
@@ -32,6 +32,7 @@ import net.awan.pipelines.data.protocol.Graph
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.copyText
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberSectionExpansion
import net.awan.pipelines.ui.theme.ICON_INLINE_DP
import net.awan.pipelines.ui.theme.SPACING_L
@@ -71,7 +72,7 @@ internal fun PipelineSourceView(
LazyColumn(
modifier = modifier.fillMaxSize(),
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "source-actions") {
Row(
@@ -48,6 +48,7 @@ import net.awan.pipelines.ui.components.KeyValueRow
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.SectionHeader
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillBottomPadding
import net.awan.pipelines.ui.STAGE_RUN_LABEL_LINES
import net.awan.pipelines.ui.displayMap
import net.awan.pipelines.ui.fileChangeLine
@@ -520,7 +521,8 @@ private fun StageDetailBody(
Column(
modifier = columnModifier
.verticalScroll(rememberScrollState())
.padding(horizontal = SPACING_L, vertical = SPACING_S),
.padding(horizontal = SPACING_L, vertical = SPACING_S)
.pillBottomPadding(),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
// A run parked on this stage surfaces its decision here, at the top of
@@ -755,7 +757,8 @@ private fun StageSectionBody(
Column(
modifier = columnModifier
.verticalScroll(rememberScrollState())
.padding(horizontal = SPACING_L, vertical = SPACING_L),
.padding(horizontal = SPACING_L, vertical = SPACING_L)
.pillBottomPadding(),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
KeyValueRow("Stage", GraphSemantics.nodeLabel(stageKey))
@@ -52,6 +52,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.detailLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.pipelineDetailTabs
import net.awan.pipelines.ui.components.rememberPaneContent
import net.awan.pipelines.ui.formatLocalTimestamp
@@ -200,7 +201,7 @@ private fun PipelineSummaryTab(detail: PipelineDetail, wide: Boolean, modifier:
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "pipeline-summary") {
Column(
@@ -256,7 +257,7 @@ private fun PipelineGraphTab(
val text = pipelinesText()
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "pipeline-graph") {
Column(
@@ -55,6 +55,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.formatLocalTimestamp
import net.awan.pipelines.ui.stageCountText
@@ -227,7 +228,7 @@ fun PipelineListScreen(
LazyColumn(
state = listState,
modifier = listModifier,
contentPadding = PaddingValues(vertical = SPACING_S),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_S)),
) {
items(items, key = { it.id }) { pipeline ->
PipelineRow(
@@ -20,6 +20,7 @@ import net.awan.pipelines.ui.LoadState
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberSectionExpansion
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_S
@@ -45,7 +46,7 @@ internal fun RunEvidenceTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "evidence-reload") {
Row(
@@ -10,6 +10,7 @@ import kotlinx.serialization.json.JsonElement
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberSectionExpansion
import net.awan.pipelines.ui.displayText
import net.awan.pipelines.ui.theme.SPACING_L
@@ -35,7 +36,7 @@ internal fun RunFieldSectionsTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
if (entries.isEmpty()) {
item(key = "$keyPrefix-empty") {
@@ -12,6 +12,7 @@ import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import net.awan.pipelines.data.protocol.RunDetail
import net.awan.pipelines.data.protocol.RunGraphState
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.graph.WorkflowGraph
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_S
@@ -39,7 +40,7 @@ internal fun RunGraphTab(
val timeline = remember(run.steps) { runTimeline(run.steps) }
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "run-graph") {
Column(
@@ -68,6 +68,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.rememberLiveNowMillis
import net.awan.pipelines.ui.components.runStateColor
import net.awan.pipelines.ui.components.runStateOf
@@ -330,7 +331,7 @@ private fun RunHistoryContent(
LazyColumn(
state = listState,
modifier = listModifier,
contentPadding = PaddingValues(bottom = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(bottom = SPACING_L)),
) {
entries.forEach { entry ->
when (entry) {
@@ -20,6 +20,7 @@ import net.awan.pipelines.ui.RUN_VIEW_TITLE_LINES
import net.awan.pipelines.ui.components.CodeBlock
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.KeyValueRow
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.StatusChip
import net.awan.pipelines.ui.components.collapsibleSection
import net.awan.pipelines.ui.components.rememberLiveNowMillis
@@ -68,7 +69,7 @@ internal fun RunSummaryTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
// The artifacts gallery still leads the summary, but inside one
// collapsed section: its header alone carries the run's capture
@@ -27,6 +27,7 @@ import net.awan.pipelines.data.protocol.RunDetail
import net.awan.pipelines.ui.components.ColoredChip
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.RunStatusIcon
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.runStateIcon
import net.awan.pipelines.ui.components.runStateOf
import net.awan.pipelines.ui.graph.graphColors
@@ -60,7 +61,7 @@ internal fun RunTimelineTab(
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
if (timeline.entries.isEmpty()) {
item(key = "timeline-empty") {
@@ -1,9 +1,11 @@
package net.awan.pipelines.ui.screens
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.WindowInsetsSides
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.only
import androidx.compose.foundation.layout.padding
@@ -11,6 +13,8 @@ import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
import androidx.compose.material.icons.filled.Settings
import androidx.compose.material.icons.filled.WarningAmber
import androidx.compose.material3.Button
import androidx.compose.material3.Card
@@ -26,18 +30,32 @@ import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.unit.dp
import androidx.lifecycle.compose.collectAsStateWithLifecycle
import net.awan.pipelines.data.transport.ConnectionState
import net.awan.pipelines.ui.AppViewModel
import net.awan.pipelines.ui.TemplatesIcon
import net.awan.pipelines.ui.components.DetailTabBody
import net.awan.pipelines.ui.components.PaneIdentity
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillBottomPadding
import net.awan.pipelines.ui.theme.SPACING_L
import net.awan.pipelines.ui.theme.SPACING_M
import net.awan.pipelines.ui.theme.SPACING_XS
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier, wide: Boolean = false) {
fun SettingsScreen(
vm: AppViewModel,
onOpenTemplates: () -> Unit,
modifier: Modifier = Modifier,
wide: Boolean = false,
covered: Boolean = false,
) {
val serverUrl by vm.serverUrlDraft.collectAsStateWithLifecycle()
val workspace by vm.workspaceDraft.collectAsStateWithLifecycle()
val urlError by vm.urlError.collectAsStateWithLifecycle()
@@ -47,6 +65,17 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier, wide: Boolea
val configuredWorkspace by vm.configuredWorkspace.collectAsStateWithLifecycle()
val workspaceError by vm.workspaceError.collectAsStateWithLifecycle()
if (covered) {
// A covered pane shows only its compact identity, never its fields
// squeezed into the peek strip (the same rule as the other destinations).
PaneIdentity(
title = "Settings",
icon = Icons.Filled.Settings,
modifier = modifier.fillMaxSize(),
)
return
}
Scaffold(
modifier = modifier,
contentWindowInsets = paneSafeArea(),
@@ -75,6 +104,7 @@ fun SettingsScreen(vm: AppViewModel, modifier: Modifier = Modifier, wide: Boolea
onDisconnect = vm::disconnect,
onReconnect = vm::reconnect,
onSaveWorkspace = vm::saveWorkspace,
onOpenTemplates = onOpenTemplates,
)
}
}
@@ -98,15 +128,19 @@ private fun SettingsContent(
onDisconnect: () -> Unit,
onReconnect: () -> Unit,
onSaveWorkspace: () -> Unit,
onOpenTemplates: () -> Unit,
) {
// The settings body keeps the app's comfortable reading width on a wide
// window (centred) instead of letting a helper line run the whole 2000px.
// The floating pill is an overlay, so the scrolled body adds its clearance to
// its own scroll content and its last control scrolls clear of the pill.
DetailTabBody(wide, padding) { columnModifier ->
Column(
modifier = columnModifier
.verticalScroll(rememberScrollState())
.padding(16.dp),
verticalArrangement = Arrangement.spacedBy(12.dp),
.padding(SPACING_L)
.pillBottomPadding(),
verticalArrangement = Arrangement.spacedBy(SPACING_M),
) {
Text("Connection", style = MaterialTheme.typography.titleMedium)
@@ -163,6 +197,51 @@ private fun SettingsContent(
)
Button(onClick = onSaveWorkspace, enabled = workspaceError == null) { Text("Save workspace") }
Text("Saved workspace: ${configuredWorkspace.ifBlank { "(none)" }}")
Text("Templates", style = MaterialTheme.typography.titleMedium)
// The templates gallery is configuration, so it lives here rather than in
// the floating pill. The row is the settings page's idiom: a section
// label followed by a card, with a leading glyph and a forward chevron.
Card(
colors = CardDefaults.cardColors(
containerColor = MaterialTheme.colorScheme.surfaceContainerHigh,
),
modifier = Modifier
.fillMaxWidth()
.clickable(
role = Role.Button,
onClickLabel = "Open templates",
onClick = onOpenTemplates,
),
) {
Row(
modifier = Modifier.fillMaxWidth().padding(SPACING_L),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.spacedBy(SPACING_M),
) {
Icon(
imageVector = TemplatesIcon,
contentDescription = null,
tint = MaterialTheme.colorScheme.onSurfaceVariant,
)
Column(
modifier = Modifier.weight(1f),
verticalArrangement = Arrangement.spacedBy(SPACING_XS),
) {
Text("Browse templates", style = MaterialTheme.typography.bodyLarge)
Text(
text = "Reusable pipeline definitions offered by the server.",
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurfaceVariant,
)
}
Icon(
imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
contentDescription = null,
)
}
}
}
}
}
@@ -50,6 +50,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.clampTabIndex
import net.awan.pipelines.ui.components.detailLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.components.pipelineDetailTabs
import net.awan.pipelines.ui.graph.PipelineSourceView
import net.awan.pipelines.ui.graph.WorkflowGraph
@@ -161,7 +162,7 @@ private fun TemplateSummaryTab(entry: TemplateEntry, wide: Boolean, modifier: Mo
DetailTabBody(wide, modifier) { columnModifier ->
LazyColumn(
modifier = columnModifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "template-summary") {
Column(
@@ -232,7 +233,7 @@ private fun TemplateGraphTab(entry: TemplateEntry, modifier: Modifier) {
}
LazyColumn(
modifier = modifier,
contentPadding = PaddingValues(vertical = SPACING_L),
contentPadding = pillContentPadding(PaddingValues(vertical = SPACING_L)),
) {
item(key = "template-graph") {
Column(
@@ -49,6 +49,7 @@ import net.awan.pipelines.ui.components.StateCrossfade
import net.awan.pipelines.ui.components.animateListItem
import net.awan.pipelines.ui.components.listLoadPhase
import net.awan.pipelines.ui.components.paneSafeArea
import net.awan.pipelines.ui.components.pillContentPadding
import net.awan.pipelines.ui.templateCard
import net.awan.pipelines.ui.templateGridColumns
import net.awan.pipelines.ui.templateStageCountLabel
@@ -151,7 +152,7 @@ private fun TemplateGrid(
LazyColumn(
state = listState,
modifier = Modifier.fillMaxSize(),
contentPadding = PaddingValues(SPACING_L),
contentPadding = pillContentPadding(PaddingValues(SPACING_L)),
verticalArrangement = Arrangement.spacedBy(SPACING_S),
) {
items(rows, key = { it.first().key }) { row ->
@@ -76,17 +76,21 @@ internal val MIN_COVERED_PANE_WIDTH_DP = 112.dp
// ---- Destination pill (ui/PipelinesApp.kt) ---------------------------------
/**
* Bottom space reserved by the floating destination pill, so content is never
* permanently hidden behind it (pill height + its margins + a small gap).
* The trailing bottom space a scrollable screen keeps at the end of its own scroll
* content so its last row is never permanently hidden behind the floating
* destination pill (pill height + its margins + a small gap). The pill itself is
* an overlay and takes no layout space; this is clearance inside the scroll
* content, applied through `LocalPillBottomInset`.
*/
internal val DESTINATION_PILL_RESERVE = 88.dp
/**
* Bottom space the floating attention chip occupies above the destination pill:
* the chip's own height (its single label line plus its vertical padding) plus the
* gap below it. Reserved at the bottom of the content whether or not a chip is
* present, so the chip can never be laid out over a row, a field or a button and
* the content does not jump as it appears and clears.
* gap below it. Added to a scrollable's trailing space alongside
* [DESTINATION_PILL_RESERVE] while the pill is drawn, so the chip can never be laid
* out over a row, a field or a button and the content does not jump as it appears
* and clears.
*/
internal val ATTENTION_CHIP_RESERVE = SPACING_XXL + SPACING_M
@@ -350,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,6 +1,8 @@
package net.awan.pipelines.ui
import androidx.compose.ui.Alignment
import androidx.compose.ui.unit.Dp
import net.awan.pipelines.ui.theme.ATTENTION_CHIP_RESERVE
import net.awan.pipelines.ui.theme.DESTINATION_PILL_RESERVE
import org.junit.Assert.assertEquals
import org.junit.Assert.assertFalse
@@ -9,6 +11,31 @@ import org.junit.Test
class PipelinesNavTest {
@Test
fun thePillDoesNotHoldTemplates() {
// Templates is configuration and moved to the Settings page; the pill keeps
// only the surfaces a person moves between constantly.
assertFalse(destinations.any { it.route == "templates" })
}
@Test
fun thePillKeepsItsRemainingDestinationsInOrder() {
// The pill's width derives from exactly this list, so removing a
// destination only narrows it.
assertEquals(
listOf("pipelines", "runs", "chat", "settings"),
destinations.map { it.route },
)
}
@Test
fun thePillIsCentredOnANarrowWindowAndOnTheRightCornerOnAWideOne() {
// The overlay is bottom-anchored; only its horizontal arrangement follows
// the window width: centred when narrow, the right corner when wide.
assertEquals(Alignment.CenterHorizontally, destinationPillAlignment(wide = false))
assertEquals(Alignment.End, destinationPillAlignment(wide = true))
}
@Test
fun listRoutesSelectTheirOwnDestination() {
assertTrue(destinationSelected("pipelines", "pipelines"))
@@ -59,7 +86,7 @@ class PipelinesNavTest {
// the chat list keeps it, and so does every other destination.
assertFalse(destinationPillVisible("chat", conversationOpen = true))
assertTrue(destinationPillVisible("chat", conversationOpen = false))
for (route in listOf("pipelines", "templates", "runs", "settings", null)) {
for (route in listOf("pipelines", "runs", "settings", null)) {
assertTrue(destinationPillVisible(route, conversationOpen = false))
}
// A conversation only exists on the chat route; even if the flag were set
@@ -68,24 +95,38 @@ class PipelinesNavTest {
}
@Test
fun theReserveTracksTheDrawnPillSoContentNeitherJumpsNorLeavesAGap() {
// Drawn: content reserves the named pill space and clears it. Hidden: no
// reservation, so there is no empty band where the pill used to be.
assertDp(DESTINATION_PILL_RESERVE.value, destinationPillReserve(pillVisible = true))
assertDp(0f, destinationPillReserve(pillVisible = false))
// One predicate drives both, so the space can never disagree with the
// pill: reserved exactly when drawn, gone exactly when hidden.
fun theContentKeepsItsOwnHeightBecauseThePillIsAnOverlay() {
// The pill floats above the content and never takes layout space, so the
// content column's own bottom padding for it is zero — whether the pill is
// drawn or hidden — and a scrollable list's last row scrolls under the pill
// rather than the whole content being shortened by it.
assertDp(0f, contentPillPadding(pillVisible = true))
assertDp(0f, contentPillPadding(pillVisible = false))
}
@Test
fun theScrollInsetTracksTheDrawnPillSoAListNeitherJumpsNorHidesItsLastRow() {
// Drawn: a scrollable keeps the named pill + attention-chip space at the
// end of its own scroll content and its last row scrolls clear of the whole
// floating bottom stack. Hidden: no clearance, so there is no empty band
// where the pill used to be.
val drawnInset = DESTINATION_PILL_RESERVE + ATTENTION_CHIP_RESERVE
assertDp(drawnInset.value, pillScrollInset(pillVisible = true))
assertDp(0f, pillScrollInset(pillVisible = false))
// One predicate drives both the drawing and the clearance, so the space can
// never disagree with the pill: cleared exactly when drawn, gone exactly
// when hidden.
for (route in listOf("pipelines", "chat", "runs", "settings", null)) {
for (open in listOf(false, true)) {
val drawn = destinationPillVisible(route, open)
val reserve = destinationPillReserve(drawn)
val inset = pillScrollInset(drawn)
assertTrue(
"reserve held behind a hidden pill on $route (open=$open)",
drawn || reserve.value == 0f,
"scroll clearance held behind a hidden pill on $route (open=$open)",
drawn || inset.value == 0f,
)
assertTrue(
"content not cleared of a drawn pill on $route (open=$open)",
!drawn || reserve.value == DESTINATION_PILL_RESERVE.value,
"list not cleared of a drawn pill on $route (open=$open)",
!drawn || inset.value == drawnInset.value,
)
}
}
@@ -0,0 +1,74 @@
package net.awan.pipelines.ui
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNull
import org.junit.Test
/**
* The Settings destination's one-level navigation: its Templates row opens the
* gallery as its own pane, a gallery card opens the template detail as the next
* pane, and Back (the gesture, the covered strip's tap and the detail's own back
* control) steps exactly one pane at a time — detail → gallery → settings. Pure,
* so none of this needs a device.
*/
class SettingsSelectionTest {
@Test
fun theTemplatesRowOpensTheGalleryAsItsOwnPane() {
val opened = openTemplatesGallery(SettingsSelection())
assertEquals(SettingsPane.Gallery, opened.pane)
assertEquals(1, opened.depth)
assertNull(opened.templateKey)
}
@Test
fun aGalleryCardOpensTheSelectedTemplatesDetailPane() {
val opened = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
assertEquals(SettingsPane.Template, opened.pane)
assertEquals(2, opened.depth)
assertEquals("three-stage", opened.templateKey)
}
@Test
fun backStepsExactlyOnePaneAndClearsTheTemplateKey() {
val detail = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
val gallery = settingsBack(detail)
assertEquals(SettingsPane.Gallery, gallery.pane)
assertEquals(1, gallery.depth)
assertNull(gallery.templateKey)
val settings = settingsBack(gallery)
assertEquals(SettingsPane.Settings, settings.pane)
assertEquals(0, settings.depth)
}
@Test
fun backAtSettingsLeavesTheSelectionSoBackCanLeaveTheDestination() {
assertEquals(SettingsSelection(), settingsBack(SettingsSelection()))
}
@Test
fun tappingACoveredStripPopsEveryPaneToItsRight() {
val detail = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
// The settings strip closes everything back to the settings page.
assertEquals(SettingsSelection(), settingsPopTo(detail, level = 0))
// The gallery strip closes only the template detail above it.
assertEquals(
SettingsSelection(pane = SettingsPane.Gallery),
settingsPopTo(detail, level = 1),
)
// A strip at or beyond the current depth has nothing to its right.
assertEquals(detail, settingsPopTo(detail, level = 2))
}
@Test
fun theSelectionSurvivesThroughItsSaverPayload() {
val detail = openTemplateDetail(openTemplatesGallery(SettingsSelection()), "three-stage")
assertEquals(detail, decodeSettingsSelection(encodeSettingsSelection(detail)))
assertEquals(
SettingsSelection(),
decodeSettingsSelection(encodeSettingsSelection(SettingsSelection())),
)
}
}
@@ -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"))
}
}
@@ -184,23 +184,34 @@ class ChatCommandsTest {
}
@Test
fun closeDelegatesToTheRealCloseWhichThisRevisionDoesNotHave() {
fun closeDelegatesToTheRealServerCloseAndReturnsToTheList() {
val store = ChatStore()
store.sessionsLoaded(listOf(session("old")))
store.open(session("old"))
store.sessionsLoaded(listOf(session("old", "Old chat")))
store.open(session("old", "Old chat"))
store.history("old", listOf(message("m1", ChatProtocol.ROLE_USER, "kept")))
val host = object : ChatCommandHost by RecordingHost() {
override fun finishSession() {
store.notice("old", CHAT_CLOSE_UNAVAILABLE, failed = true)
// The real close: mark the session closed for every client — the
// conversation and its history are kept — then leave it for the
// list. Nothing is hidden.
store.sessionClosed("old", closedAt = 42)
val kept = store.value.thread("old")!!
assertTrue(kept.closed)
assertEquals(listOf("m1"), kept.messages.map { it.id })
store.close("old")
}
}
runChatSlashCommand("/close", store.value.thread("old")!!, host)
// The close is reported plainly and nothing is faked with the local hide.
assertTrue(store.value.thread("old")!!.notices.single().text.contains("no real session close"))
assertTrue(store.value.open.any { it.sessionId == "old" })
// Closed for every client and kept as history, exactly as the list's own
// close does — never the local hide dressed up as one.
assertTrue(store.value.sessions.single { it.id == "old" }.closed)
assertTrue(store.value.closedSessions.any { it.id == "old" })
assertTrue(store.value.visibleSessions.any { it.id == "old" })
// Its conversation has left the pane: the operator is back at the list.
assertTrue(store.value.open.none { it.sessionId == "old" })
assertNull(store.value.activeId)
}
@Test
+106
View File
@@ -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.
+148
View File
@@ -0,0 +1,148 @@
# The destinations pill: a true overlay, centred narrow and right when wide
## What this item changed
`android/` only, the app shell's floating destination pill and where Templates lives.
- `ui/PipelinesApp.kt` — the pill is a true overlay. The content `Column` no longer
reserves the pill's height (`destinationPillReserve` and the `ATTENTION_CHIP_RESERVE`
padding on it are gone); `contentPillPadding(pillVisible)` is the named zero it applies,
zero whether the pill is drawn or hidden. The pill and the attention chip stay in their
own bottom-anchored overlay `Column`, already a sibling of the content in the `Box`, so
nothing positions the content. The one placement rule is
`destinationPillAlignment(wide)` — `Alignment.CenterHorizontally` on a narrow window,
`Alignment.End` on a wide one — with the corner margin from the named `SPACING_L`; the
attention chip keeps its own bottom-right place at every width via
`Modifier.align(Alignment.End)`. `destinations` is now pipelines/runs/chat/settings
(Templates removed), and the `settings` route is `SettingsDestination`.
- `ui/components/PillInset.kt` (new) — `LocalPillBottomInset` plus `pillContentPadding`
(for a scroll container's `contentPadding`) and `Modifier.pillBottomPadding` (for a
scrollable `Column`'s own content). They add `pillScrollInset(pillVisible)` — the named
`DESTINATION_PILL_RESERVE` + `ATTENTION_CHIP_RESERVE` while the pill is drawn, zero while
it is hidden — **inside** the scroll content, never as layout padding on the container,
so the content keeps its full height, a hidden pill leaves no empty band, and the last row
still scrolls clear of the pill. Applied in the lists, the graph/source/stage panes, the
chat list and create panes, the run tabs and history, the pipeline list/detail and the
template gallery/detail.
- `ui/SettingsDestination.kt` (new) — the Settings destination as the shared
`SlidingPaneStack`: pane 0 `SettingsScreen`, pane 1 the existing `TemplateGalleryScreen`,
pane 2 the existing `TemplateDetailScreen`, with `PredictiveBackHandler`.
- `ui/SettingsSelection.kt` (new) — the pure, Bundle-able pane model
(`SettingsPane`/`SettingsSelection`, `openTemplatesGallery`, `openTemplateDetail`,
`settingsBack`, `settingsPopTo`, `encodeSettingsSelection`/`decodeSettingsSelection` and
the saver): one-level Back (detail → gallery → settings) and a covered-pane pop.
- `ui/screens/SettingsScreen.kt` — gains the Templates row (section label, card with the
`TemplatesIcon` glyph, title, description and a forward chevron) that opens the gallery;
the screen's own body takes `pillBottomPadding()`.
- `ui/TemplatesDestination.kt` — deleted (its gallery is now the settings stack's pane 1).
- `ui/theme/Dimens.kt` — the docs of `DESTINATION_PILL_RESERVE` and
`ATTENTION_CHIP_RESERVE` now describe scroll-content clearance rather than a reserved
layout band. No new token, no new hardcoded dimension.
- Tests — `PipelinesNavTest` (the pill holds no `templates` route, the remaining
destinations and their order, the narrow/wide alignment, the content's padding is zero
and the scroll inset tracks the drawn pill) and `SettingsSelectionTest` (the Templates
row opens the gallery, a card opens the detail, Back steps one pane, a covered strip pops,
the saver round-trips). This re-lands the intent of `a2043f9` ("move Templates from the
floating pill to Settings"), whose commit never reached main.
## Shared documents this change makes stale
`android/README.md` documents the app's surfaces this item changed. The note is written here
rather than edited in place; the `docs-fold` writer should update it.
- `android/README.md:107` — the bullet "A **Templates** destination (its own top-level pill
between Pipelines and Runs, with its own gallery glyph rather than the Pipelines workflow
tree): a measured gallery of cards…" should read "The **Templates** gallery, reached from
a **Templates** row on the Settings page (not a floating-pill destination — it is
configuration, so it lives with the other settings; its own gallery glyph rather than the
Pipelines workflow tree): a measured gallery of cards…". The rest of the bullet (the
cards, the stage count, the column count, the detail pane) is still true.
- `android/README.md` — append the dated section below at the end of the file, after the
last record (`## Run title readability: whole in the run view, two lines in the list
(17 Oct 2026)`). Insert it verbatim; its build counts and the APK name are that run's
dated evidence, not current values.
```markdown
## The destinations pill: a true overlay, centred narrow and right when wide (18 Oct 2026)
The floating destination pill no longer takes layout space. It is drawn in the
bottom overlay above the content and its resting place follows the window width:
horizontally centred at the bottom on a **narrow** window, anchored to the
**bottom-right corner** on a **wide** one. Templates leaves the pill for the
Settings page. `android/` only; no new dependency (still only the declared
`material-icons-extended`), no Pipelines server/Go/installer/Docker file touched
and no run started from the app; the build and unit tests only, no device command
run.
- **An overlay, not a layout band.** `PipelinesApp`'s content `Column` no longer
reserves the pill's height (`destinationPillReserve` and its
`ATTENTION_CHIP_RESERVE` padding are gone). The pill and the attention chip stay
in their own bottom-anchored overlay `Column` — already a sibling of the content
in the `Box`, so nothing about them positions the content. `contentPillPadding(pillVisible)`
is the named zero it applies (zero whether the pill is drawn or hidden); a unit
test pins both states.
- **Trailing space moves into each scrollable.** A hidden pill must leave no empty
band, but scrolling to the end must still reveal the last row clear of the pill.
`pillScrollInset(pillVisible)` (the named `DESTINATION_PILL_RESERVE` +
`ATTENTION_CHIP_RESERVE` while drawn, zero while hidden) is published around the
content through the new `LocalPillBottomInset`, and `pillContentPadding` /
`Modifier.pillBottomPadding` add it to a screen's **own scroll content** (every
list, grid and scrolling detail/stage/settings body), never as layout padding on
the container — so the content keeps its full height and only its end clears the
pill.
- **Centred narrow, right corner when wide.** `destinationPillAlignment(wide)` is
the one pure rule (`Alignment.CenterHorizontally` narrow, `Alignment.End` wide);
the corner margin is the named `SPACING_L`, so no new number is introduced. The
pill still clears the safe area (system bars, cutout, gesture area and IME) via
`windowInsetsPadding(paneSafeArea())`, so it never covers the keyboard or an open
composer, and it still stands down while a conversation is open.
- **Templates leaves the pill for Settings.** `destinations` is now
pipelines/runs/chat/settings, so the pill's width (its icon row) simply narrows.
The `settings` route is the shared `SlidingPaneStack` (`SettingsDestination`):
pane 0 the Settings page, pane 1 the existing `TemplateGalleryScreen`, pane 2 the
existing `TemplateDetailScreen`. `SettingsSelection` is the pure, Bundle-able
pane model with one-level Back (detail → gallery → settings) and a
covered-pane pop. `SettingsScreen` gains a Templates row (section label + card
with the `TemplatesIcon` glyph, title, description and forward chevron). This
re-lands the intent of `a2043f9` ("move Templates from the floating pill to
Settings"), whose commit never reached main.
Tests: the 64 result XMLs (plus Gradle's `binary` results directory) aggregate to
**593 tests, 0 failures, 0 errors, 0 skipped**. New/updated pure tests —
`PipelinesNavTest` (11, incl. the pill holds no `templates` route, the remaining
destinations and their order, the narrow/wide alignment, the content's padding is
zero, and the scroll inset tracks the drawn pill) and `SettingsSelectionTest` (6,
the Templates row opens the gallery, a card opens the detail, Back steps one pane,
a covered strip pops and the saver round-trips).
Evidence (macOS, `JAVA_HOME=/Applications/Android Studio.app/Contents/jbr/Contents/Home`,
`ANDROID_HOME=/Users/alan/Library/Android/sdk`, Gradle 8.11.1, `--offline`,
`--no-daemon`, built at `a297fb6` = `main`'s tip with this item's working changes):
- `<gradle> --offline --no-daemon :app:assembleDebug :app:testDebugUnitTest` →
`BUILD SUCCESSFUL`; the 64 result XMLs aggregate to 593 tests, 0 failures, 0
errors, 0 skipped; `app-debug.apk` 18,657,246 bytes, sha256
`c60f9b269368b51d4bc1f43b95b0970210d803e4fe0dc4add8db39e3b3821f51`.
- **APK publish.** Copied to this run's artifacts directory as
`pipelines-debug-wip-a297fb6.apk`, served at
`http://10.0.0.75:8080/artifacts/327/3/pipelines-debug-wip-a297fb6.apk`
(`HTTP/1.1 200 OK`, `Content-Type: application/vnd.android.package-archive`, the
downloaded bytes sha256-matching the local file).
Not verified in this pass: how the centred/right pill actually renders and that a
scrolled list's last row clears it — that needs the device, which this
build-and-unit-test pass did not use; visual review owns the operator's Pixel 9
Pro XL.
```
## Not stale
- No packaged OpenCode skill reference documents this app surface. The references in
`internal/author/skill/references/` describe the server, the CLI and the pipeline
authoring model; none names the app's destination pill, its destinations or the
templates gallery.
- No packaged template (`examples/*.md`) and no `internal/author/` managed file names
them either, so `internal/author/install.go`'s inventory needs no change.
- `android/AGENTS.md` already describes `ui/PipelinesApp.kt` as "the app shell:
destinations, the floating pill, the omni-search morph" and lists `ui/screens/`, so
it needs no change.
+72 -13
View File
@@ -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)
}
}
+28
View File
@@ -26,6 +26,17 @@ 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
@@ -127,6 +138,23 @@ type ChatSession struct {
// 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
+6 -2
View File
@@ -22,6 +22,8 @@ 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}},
@@ -176,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 {
@@ -198,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)
}
}
@@ -208,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)
}
+4
View File
@@ -166,6 +166,10 @@ 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
+15
View File
@@ -44,6 +44,15 @@ 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. Its only role
@@ -92,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
}
+144
View File
@@ -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
}
+313
View File
@@ -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)
}
}
+13
View File
@@ -303,6 +303,19 @@ func (h *chatHub) finishTurnLocked(room *chatRoom) {
}
}
// 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) {
+6
View File
@@ -74,6 +74,12 @@ func handleChatSessions(ctx context.Context, request protocol.Message, broker ch
session.Tag = operator.Tag
session.CreatedAt = operator.CreatedAt
session.UpdatedAt = operator.UpdatedAt
// The closed state comes from the registry, so every client sees the same
// thing; a closed session stays in the list (the app groups it as history)
// rather than disappearing. 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)