diff --git a/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt index 284f038e..a06126ef 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/PipelinesRepository.kt @@ -1,5 +1,6 @@ package net.awan.pipelines.data +import android.os.Build import java.util.UUID import java.util.concurrent.ConcurrentHashMap import kotlinx.coroutines.flow.SharedFlow @@ -27,6 +28,17 @@ import net.awan.pipelines.data.transport.PipelinesClient import net.awan.pipelines.data.transport.ProtocolException import net.awan.pipelines.data.transport.ServerUrl +/** + * The default label this device reports: its model name, so other clients can + * attribute a message to "Pixel 9 Pro XL". A build without a usable model (or a + * local unit test where the framework stub has none) falls back to a generic + * label rather than sending a blank one. + */ +private fun defaultClientLabel(): String { + val model = runCatching { Build.MODEL }.getOrNull()?.trim().orEmpty() + return model.ifBlank { "Android device" } +} + /** Run history plus the server's aggregate usage statistics. */ data class RunHistory(val runs: List, val usage: UsageStats?) @@ -38,6 +50,13 @@ data class RunHistory(val runs: List, val usage: UsageStats?) class PipelinesRepository( private val client: PipelinesClient, private val settings: SettingsRepository, + /** + * The label this device sends with its prompts and approval answers, so every + * other client can attribute a user message to the device that sent it and see + * which device answered an approval. Defaults to the device model; injectable + * so a unit test does not depend on the build. + */ + val clientLabel: String = defaultClientLabel(), ) { val connectionState = client.state @@ -241,9 +260,9 @@ class PipelinesRepository( // directly and never holds its credentials. ---- /** - * Lists the sessions this server owns, with the `busy` flag the phone renders - * read-only. The server already returns operator sessions only, so the app - * never filters this list by ownership. + * Lists the sessions this server owns. The server already returns operator + * sessions only, so the app never filters this list by ownership; a session is + * never marked read-only. */ suspend fun chatSessions(): List = client.call(Message(type = Protocol.CHAT_SESSIONS)).chatSessions ?: emptyList() @@ -284,15 +303,29 @@ class PipelinesRepository( } /** - * Sends one prompt with its attached file URIs; the server echoes an ack and - * then pushes chat_event frames. The attachments travel only here, with the - * prompt the operator actually sent — never on their own. + * Attaches this connection to [sessionId]'s shared live stream, so it sees + * every frame any client's turn produces — the other devices' prompts and the + * turn's streaming output — and can answer a shared approval. Best-effort: an + * older server that does not know `chat_subscribe` simply answers an error + * frame, which the caller ignores while history still loads. */ - suspend fun chatPrompt(sessionId: String, text: String, files: List = emptyList()) { + suspend fun chatSubscribe(sessionId: String) { + if (sessionId.isBlank()) return + client.call(ChatProtocol.subscribeRequest(sessionId)) + } + + /** + * Sends one prompt with its attached file URIs; the server echoes an ack and + * then pushes chat_event frames. The prompt carries this device's label so the + * other clients can attribute it. The attachments travel only here, with the + * prompt the operator actually sent — never on their own. Returns true when the + * server queued the prompt behind an in-flight turn. + */ + suspend fun chatPrompt(sessionId: String, text: String, files: List = emptyList()): Boolean { if (sessionId.isBlank()) throw ProtocolException("Select a chat session first.") val trimmed = text.trim() if (trimmed.isEmpty()) throw ProtocolException("Enter a message before sending.") - client.call(ChatProtocol.promptRequest(sessionId, trimmed, files)) + return client.call(ChatProtocol.promptRequest(sessionId, trimmed, files, clientLabel)).chatQueued } suspend fun chatInterrupt(sessionId: String) { @@ -304,7 +337,7 @@ class PipelinesRepository( if (sessionId.isBlank() || requestId.isBlank()) { throw ProtocolException("A pending permission request is required.") } - client.call(ChatProtocol.replyRequest(sessionId, requestId, decision, message)) + client.call(ChatProtocol.replyRequest(sessionId, requestId, decision, message, clientLabel)) } private fun requireConfigured() { diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt index c3f8b35d..d903e35e 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Chat.kt @@ -30,8 +30,8 @@ data class ChatSession( @SerialName("created_at") val createdAt: Long = 0, @SerialName("updated_at") val updatedAt: Long = 0, // Another client holds the session, or the server itself owns it as an active - // run: the phone shows it read-only instead of letting two clients write the - // same conversation. + // run. Kept for wire compatibility; the server no longer sets it, and a + // session is never read-only for a client. val busy: Boolean = false, ) @@ -55,6 +55,10 @@ data class ChatPromptRequest( val model: String = "", val agent: String = "", val files: List = emptyList(), + // The sending device's human-readable label (a device name), so every other + // client can attribute the message; the server sanitises it and falls back to + // a generic label when it is blank. + val client: String = "", ) /** One stored turn: a user turn is a single text part, an assistant turn holds text/reasoning/tool parts. */ @@ -66,6 +70,9 @@ data class ChatMessage( val model: String = "", val agent: String = "", @SerialName("created_at") val createdAt: Long = 0, + // The sending device's label on a user turn the server echoed, so a resumed + // transcript still says who sent the message. Empty on an assistant turn. + val client: String = "", val parts: List = emptyList(), ) @@ -138,6 +145,9 @@ data class ChatEventFrame( val part: ChatPart? = null, val step: ChatStep? = null, val usage: ChatUsage? = null, + // The sending device's label on a `user` frame (another client's prompt), so + // the transcript can say who sent it. Empty on the agent's own frames. + val client: String = "", ) @Serializable @@ -174,6 +184,9 @@ data class ChatPermissionFrame( val message: String = "", val resolved: Boolean = false, val decision: String = "", + // The label of the client whose answer resolved the request, so every other + // client can show which device answered. + @SerialName("resolved_by") val resolvedBy: String = "", ) @Serializable @@ -189,6 +202,8 @@ data class ChatReplyRequest( @SerialName("request_id") val requestId: String = "", val decision: String = "", val message: String = "", + // The answering device's label, recorded with the resolution. + val client: String = "", ) /** Chat part/kind/state/reply constants, mirroring `internal/protocol/chat.go`. */ @@ -207,6 +222,13 @@ object ChatProtocol { const val EVENT_STEP = "step" const val EVENT_USAGE = "usage" + /** + * A prompt another client sent, echoed live to this client so it appears in + * the transcript attributed to the sending device. The sender never receives + * its own frame (it already has the message locally). + */ + const val EVENT_USER = "user" + const val STEP_STARTED = "started" const val STEP_ENDED = "ended" @@ -241,10 +263,21 @@ object ChatProtocol { * shape a text-only prompt has always sent). Built here (not inline in the * repository) so production and its unit test share the one wire shape. */ - fun promptRequest(sessionId: String, text: String, files: List = emptyList()): Message = + fun promptRequest(sessionId: String, text: String, files: List = emptyList(), client: String = ""): Message = Message( type = Protocol.CHAT_PROMPT, - chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files), + chatPrompt = ChatPromptRequest(sessionId = sessionId, text = text, files = files, client = client), + ) + + /** + * The `chat_subscribe` frame that attaches this connection to [sessionId]'s + * shared live stream, so the client sees every frame any client's turn + * produces. Built here so production and its unit test share the one shape. + */ + fun subscribeRequest(sessionId: String): Message = + Message( + type = Protocol.CHAT_SUBSCRIBE, + chatSubscribe = ChatQuery(sessionId = sessionId), ) /** @@ -261,7 +294,7 @@ object ChatProtocol { * inline in the repository) so the approval card's actions and their unit * test share the one wire shape. */ - fun replyRequest(sessionId: String, requestId: String, decision: String, message: String = ""): Message = + fun replyRequest(sessionId: String, requestId: String, decision: String, message: String = "", client: String = ""): Message = Message( type = Protocol.CHAT_REPLY, chatReply = ChatReplyRequest( @@ -269,6 +302,7 @@ object ChatProtocol { requestId = requestId, decision = decision, message = message, + client = client, ), ) } diff --git a/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt b/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt index 4817181b..14ef3c06 100644 --- a/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt +++ b/android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt @@ -68,6 +68,9 @@ object Protocol { const val CHAT_MESSAGES = "chat_messages" const val CHAT_INTERRUPT = "chat_interrupt" const val CHAT_REPLY = "chat_reply" + // Attaches this connection to one session's shared live stream, so every + // client watching a session receives every frame any client's turn produces. + const val CHAT_SUBSCRIBE = "chat_subscribe" // The operator's directory choices for a new chat (home first, then the // directories of previous operator sessions, most recently used first). const val CHAT_DIRECTORIES = "chat_directories" @@ -676,6 +679,11 @@ data class Message( @SerialName("chat_create") val chatCreate: ChatCreateRequest? = null, @SerialName("chat_query") val chatQuery: ChatQuery? = null, @SerialName("chat_prompt") val chatPrompt: ChatPromptRequest? = null, + // A chat_prompt response with this set was accepted into the session's queue + // because a turn is already in flight; the composer shows queued/steering + // instead of blocking input. + @SerialName("chat_queued") val chatQueued: Boolean = false, + @SerialName("chat_subscribe") val chatSubscribe: ChatQuery? = null, @SerialName("chat_messages") val chatMessages: List? = null, @SerialName("chat_event") val chatEvent: ChatEventFrame? = null, @SerialName("chat_permission") val chatPermission: ChatPermissionFrame? = null, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt index 80f01734..cece0a60 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/AppViewModel.kt @@ -1025,6 +1025,10 @@ class AppViewModel( fun loadChatHistory(sessionId: String) { viewModelScope.launch { + // Watch the session's shared stream so frames from any client's turn + // arrive live. Best-effort: an older server answers an error frame, + // which must not stop the history from loading. + runCatching { repository.chatSubscribe(sessionId) } chatStore.historyLoading(sessionId) try { chatStore.history(sessionId, repository.chatMessages(sessionId, CHAT_HISTORY_LIMIT)) @@ -1054,7 +1058,11 @@ class AppViewModel( chatStore.running(sessionId, true) viewModelScope.launch { try { - repository.chatPrompt(sessionId, text, attachmentFiles(attachments)) + val queued = repository.chatPrompt(sessionId, text, attachmentFiles(attachments)) + // The server accepted the prompt (queued or sent); a queued prompt + // is one waiting behind an in-flight turn, and the composer says so + // instead of blocking input. + chatStore.setQueued(sessionId, queued) } catch (t: Throwable) { if (t is CancellationException) throw t val message = ErrorMessages.describe(t) @@ -1062,6 +1070,7 @@ class AppViewModel( chatStore.failed(sessionId, message) chatStore.restoreAttachments(sessionId, attachments, message) chatStore.running(sessionId, false) + chatStore.setQueued(sessionId, false) } } } diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt index f67967f1..4c6e21b6 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatComposer.kt @@ -51,9 +51,9 @@ internal fun ChatComposer( } Surface(color = MaterialTheme.colorScheme.surfaceContainer) { Column(Modifier.fillMaxWidth().padding(CHAT_GUTTER)) { - if (thread.readOnly) { + if (thread.queued) { Text( - text = "Another client holds this session; it is read-only here.", + text = "Queued — it will send when the current turn finishes.", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(bottom = CHAT_ITEM_GAP), @@ -65,14 +65,12 @@ internal fun ChatComposer( Row(verticalAlignment = Alignment.Bottom, horizontalArrangement = Arrangement.spacedBy(CHAT_COMPOSER_GAP)) { IconButton( onClick = { picker.launch(arrayOf("*/*")) }, - enabled = !thread.readOnly, ) { Icon(Icons.Default.AttachFile, contentDescription = "Attach file") } OutlinedTextField( value = thread.draft, onValueChange = onDraft, - enabled = !thread.readOnly, placeholder = { Text("Message the agent…") }, minLines = 1, maxLines = 6, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt index 7d51f576..c01ee5a7 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatConversationPane.kt @@ -213,11 +213,7 @@ internal fun ChatConversationPane( onRetry = { vm.loadChatHistory(thread.sessionId) }, ) thread.messages.isEmpty() && !thread.running && approval == null -> EmptyState( - message = if (thread.readOnly) { - "This chat is read-only while another client holds the session." - } else { - "This chat has no messages yet. Ask something below." - }, + message = "This chat has no messages yet. Ask something below.", ) else -> ChatTranscript( thread = thread, diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt index d50c87cc..37fb28c5 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatFormat.kt @@ -125,23 +125,17 @@ internal fun chatHeaderMeta(thread: ChatThread): String = listOfNotNull( private const val OPERATOR_TAG_LABEL = "Operator" /** - * The status a session row shows. A locally-running turn is reported as - * `Running`; otherwise the server's `busy` flag is `Busy · read-only` (another - * client holds it, so the composer is disabled), else `Idle`. - * - * This is the same precedence [ChatThread.readOnly] applies: a turn we started is - * `Running` and writable, never the read-only the server's own `busy` flag alone - * would imply. + * The status a session row shows: `Running` while this client has a turn in + * flight, else `Idle`. A session is never reported `Busy` or read-only because + * another client is watching it — the server fans the stream out and accepts a + * prompt from any client, so the session stays writable everywhere. */ internal fun sessionStatusLabel(session: ChatSession, runningLocally: Boolean): String = - sessionStatusLabel(session.busy, runningLocally) + sessionStatusLabel(runningLocally) -/** The status of a conversation from its own model flags (see [sessionStatusLabel]). */ -internal fun sessionStatusLabel(busy: Boolean, runningLocally: Boolean): String = when { - runningLocally -> "Running" - busy -> "Busy · read-only" - else -> "Idle" -} +/** The status of a conversation from its own running flag (see [sessionStatusLabel]). */ +internal fun sessionStatusLabel(runningLocally: Boolean): String = + if (runningLocally) "Running" else "Idle" /** * The activity a session row signals beyond its open/tag/directory state. An @@ -183,7 +177,7 @@ internal data class ConversationHeader( internal fun conversationHeader(thread: ChatThread): ConversationHeader = ConversationHeader( title = sessionTitle(ChatSession(id = thread.sessionId, title = thread.title)), kind = sessionTagLabel(thread.tag), - activity = sessionStatusLabel(thread.busy, thread.running), + activity = sessionStatusLabel(thread.running), directory = thread.directory, model = thread.model, ) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt index a3d80f75..4657b49d 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatStore.kt @@ -94,24 +94,26 @@ data class ChatThread( * settle in place optimistically and survives a chat switch. */ val permissionAnswer: String = "", + /** + * The last prompt this client sent was accepted into the session's queue + * behind an in-flight turn (the server acknowledged it as queued), so the + * composer can say so instead of blocking. Cleared as soon as the turn's + * frames arrive or the thread settles. + */ + val queued: Boolean = false, ) { /** - * Read-only while another client holds the session: the composer must never - * write to it. A turn we started ourselves keeps the session writable even - * though the server reports it busy (the server owns it as our active run), - * so the one rule here agrees with [sessionStatusLabel]'s `Running` case. + * At least one attachment is flagged; the prompt must not be sent with it. */ - val readOnly: Boolean get() = busy && !running - - /** At least one attachment is flagged; the prompt must not be sent with it. */ val hasAttachmentErrors: Boolean get() = attachments.any { it.error != null } /** - * Whether the composer's send action is allowed. A message with a flagged - * attachment is never sent: the operator must remove or re-attach it first, - * so the file is never silently dropped. + * Whether the composer's send action is allowed. A session is never read-only: + * another client may watch the same conversation without blocking this one. A + * message with a flagged attachment is never sent, so the file is never + * silently dropped. */ - val canSend: Boolean get() = !readOnly && draft.isNotBlank() && !hasAttachmentErrors + val canSend: Boolean get() = draft.isNotBlank() && !hasAttachmentErrors /** * Non-negative elapsed time of an in-flight turn at [nowMillis], or 0 once it @@ -593,6 +595,13 @@ class ChatStore( fun running(sessionId: String, running: Boolean) = update(sessionId) { setRunning(it, running) } + /** + * Records that the operator's last prompt was accepted into the session's + * queue (true) or sent immediately (false), so the composer can say "Queued" + * while it waits for the in-flight turn without blocking input. + */ + fun setQueued(sessionId: String, queued: Boolean) = update(sessionId) { it.copy(queued = queued) } + /** * The stream resumed (the socket reconnected): every frame that was feeding an * in-flight turn is gone, so no thread keeps claiming to run until a fresh @@ -707,7 +716,11 @@ class ChatStore( if (frame.sessionId.isBlank()) return ensureThread(frame.sessionId) markUnread(frame.sessionId) + // Any frame for the session means the turn has moved on, so a prompt we + // had queued is no longer waiting. + update(frame.sessionId) { if (it.queued) it.copy(queued = false) else it } when (frame.kind) { + ChatProtocol.EVENT_USER -> applyRemoteUser(frame) ChatProtocol.PART_TEXT, ChatProtocol.PART_REASONING -> applyDelta(frame) ChatProtocol.PART_TOOL -> applyTool(frame) ChatProtocol.EVENT_STEP -> { @@ -718,6 +731,28 @@ class ChatStore( } } + /** + * Folds a user turn another client sent into the transcript, in place, once. + * The server never echoes this client's own prompts, so the sender's own + * message is never duplicated; the [ChatMessage.client] label says which + * device sent it. + */ + private fun applyRemoteUser(frame: ChatEventFrame) { + val text = frame.part?.text.orEmpty() + if (frame.messageId.isEmpty() || text.isEmpty()) return + update(frame.sessionId) { thread -> + if (thread.messages.any { it.id == frame.messageId }) return@update thread + val message = ChatMessage( + id = frame.messageId, + sessionId = frame.sessionId, + role = ChatProtocol.ROLE_USER, + client = frame.client, + parts = listOf(ChatPart(type = ChatProtocol.PART_TEXT, text = text)), + ) + thread.copy(messages = thread.messages + message) + } + } + /** * Creates a placeholder thread for a session that is not open, so a frame for * a background chat is kept instead of dropped. A no-op when it already exists. diff --git a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt index ddb3f115..3d9e9a77 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/chat/ChatTranscript.kt @@ -352,6 +352,16 @@ private fun MessageItem( SelectionContainer { Column(Modifier.padding(CHAT_GUTTER)) { if (isUser) { + // A user turn another device sent is attributed to it, so + // the transcript says who sent the message. Our own + // messages carry no label. + if (message.client.isNotBlank()) { + Text( + text = message.client, + style = MaterialTheme.typography.labelSmall, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } UserParts(message.parts) } else { AssistantParts( diff --git a/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt b/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt index ef8d96f4..27910576 100644 --- a/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/data/protocol/ChatProtocolTest.kt @@ -45,6 +45,45 @@ class ChatProtocolTest { assertTrue(!sessions[1].busy) } + @Test + fun chatMultiClientFieldsRoundTrip() { + // The client label the prompt carries, the queued acknowledgement, the + // subscribe request and the shared-answer fields of a permission frame. + val prompt = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_prompt","chat_prompt":{"session_id":"ses_1","text":"hi","client":"Pixel 9 Pro XL"}}""", + ) + assertEquals("Pixel 9 Pro XL", prompt.chatPrompt!!.client) + + val ack = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_prompt","id":"a1","chat_queued":true}""", + ) + assertTrue(ack.chatQueued) + + val subscribe = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_subscribe","chat_subscribe":{"session_id":"ses_1"}}""", + ) + assertEquals(Protocol.CHAT_SUBSCRIBE, subscribe.type) + assertEquals("ses_1", subscribe.chatSubscribe!!.sessionId) + + val userFrame = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_event","chat_event":{"session_id":"ses_1","message_id":"usr_1","kind":"user","client":"Pixel 10 Pro Fold","part":{"type":"text","text":"from the fold"}}}""", + ) + assertEquals(ChatProtocol.EVENT_USER, userFrame.chatEvent!!.kind) + assertEquals("Pixel 10 Pro Fold", userFrame.chatEvent!!.client) + + val resolved = PipelinesJson.decodeFromString( + Message.serializer(), + """{"type":"chat_permission","chat_permission":{"session_id":"ses_1","request_id":"req_1","resolved":true,"decision":"once","resolved_by":"Pixel 9"}}""", + ) + assertTrue(resolved.chatPermission!!.resolved) + assertEquals("once", resolved.chatPermission!!.decision) + assertEquals("Pixel 9", resolved.chatPermission!!.resolvedBy) + } + @Test fun chatMessagesParseTextReasoningAndToolParts() { val json = """ diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt index 7991e473..74b7bd13 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/ChatFormatTest.kt @@ -65,12 +65,11 @@ class ChatFormatTest { } @Test - fun sessionStatusReportsRunningBusyAndIdle() { + fun sessionStatusIsRunningOrIdleNeverReadOnly() { assertEquals("Running", sessionStatusLabel(ChatSession(id = "s"), runningLocally = true)) - assertEquals( - "Busy · read-only", - sessionStatusLabel(ChatSession(id = "s", busy = true), runningLocally = false), - ) + // The server no longer marks a session Busy for another client, and a + // session is never read-only: the stale flag cannot produce that label. + assertEquals("Idle", sessionStatusLabel(ChatSession(id = "s", busy = true), runningLocally = false)) assertEquals("Idle", sessionStatusLabel(ChatSession(id = "s"), runningLocally = false)) } diff --git a/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt index eaf2bfa1..0c94115f 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/chat/MultiChatStateTest.kt @@ -113,19 +113,15 @@ class MultiChatStateTest { } @Test - fun busySessionIsReadOnlyAndCannotSend() { + fun busySessionStaysWritable() { val store = ChatStore() + // Another client watching the session never makes it read-only: the + // server fans the stream out and accepts a prompt from any client. store.open(session("a", busy = true)) store.draft("a", "unsent") val thread = store.value.thread("a")!! - assertTrue(thread.readOnly) - assertFalse(thread.canSend) - - // The server can clear busy later; the chat then becomes writable again. - store.sessionsLoaded(listOf(session("a", busy = false))) - store.draft("a", "unsent") - assertFalse(store.value.thread("a")!!.readOnly) - assertTrue(store.value.thread("a")!!.canSend) + assertTrue(thread.canSend) + assertTrue(thread.busy) } @Test @@ -192,10 +188,9 @@ class MultiChatStateTest { val store = ChatStore() store.open(session("a", busy = true)) store.running("a", true) - // Our own turn keeps the session writable even though the server reports it busy. + // A turn in flight (ours or another client's) keeps the session writable. store.draft("a", "next prompt") val thread = store.value.thread("a")!! - assertFalse(thread.readOnly) assertTrue(thread.canSend) } @@ -229,4 +224,78 @@ class MultiChatStateTest { assertFalse(store.value.open.any { it.sessionId == "a" }) assertTrue(store.value.open.any { it.sessionId == "b" }) } + + @Test + fun remoteUserFrameIsFoldedOnceAndAttributed() { + val store = ChatStore() + store.open(session("a")) + // The operator's own message, appended locally when sent. + store.appendLocalUserMessage("a", "mine") + // Another client's prompt arrives live, attributed to that device. + val frame = ChatEventFrame( + sessionId = "a", + messageId = "usr_7", + kind = ChatProtocol.EVENT_USER, + client = "Pixel 10 Pro Fold", + part = ChatPart(type = ChatProtocol.PART_TEXT, text = "from the fold"), + ) + store.event(frame) + val messages = store.value.thread("a")!!.messages + assertEquals(2, messages.size) + assertEquals("mine", messages[0].parts.single().text) + assertEquals(ChatProtocol.ROLE_USER, messages[1].role) + assertEquals("Pixel 10 Pro Fold", messages[1].client) + assertEquals("from the fold", messages[1].parts.single().text) + + // A replayed frame (e.g. after a reconnect) is folded once, not twice. + store.event(frame) + assertEquals(2, store.value.thread("a")!!.messages.size) + } + + @Test + fun remoteAnswerClearsTheApprovalCard() { + val store = ChatStore() + store.open(session("a")) + store.permission(ChatPermissionFrame(sessionId = "a", requestId = "req_1", action = "bash")) + val open = approvalCard(store.value.thread("a")!!.permission, store.value.thread("a")!!.permissionAnswer)!! + assertTrue("the card is answerable while the request is open", open.actionable) + + // Another client answered: the server pushes the resolved frame, which + // clears this client's card and shows the outcome without ever disabling + // it while the first answer was in flight. + store.permission( + ChatPermissionFrame( + sessionId = "a", + requestId = "req_1", + action = "bash", + resolved = true, + decision = ChatProtocol.DECISION_ONCE, + resolvedBy = "Pixel 9 Pro XL", + ), + ) + val thread = store.value.thread("a")!! + val cleared = approvalCard(thread.permission, thread.permissionAnswer)!! + assertFalse("a resolved request offers no controls", cleared.actionable) + assertEquals(ApprovalState.RESOLVED, cleared.state) + assertEquals(ChatProtocol.DECISION_ONCE, cleared.decision) + } + + @Test + fun queuedPromptIsShownUntilTheTurnStreams() { + val store = ChatStore() + store.open(session("a")) + store.setQueued("a", true) + assertTrue(store.value.thread("a")!!.queued) + // The queued turn's first frame means it is running, so the marker clears. + store.event( + ChatEventFrame( + sessionId = "a", + messageId = "m1", + kind = ChatProtocol.PART_TEXT, + delta = "hi", + part = ChatPart(type = ChatProtocol.PART_TEXT, id = "m1#0"), + ), + ) + assertFalse(store.value.thread("a")!!.queued) + } } diff --git a/docs/cli.md b/docs/cli.md index ada999b2..996962c5 100644 --- a/docs/cli.md +++ b/docs/cli.md @@ -304,12 +304,31 @@ The brokered OpenCode chat exposes the operator's own sessions, separate from th sessions pipeline runs create. The protocol types are: - `chat_sessions` lists the operator's own sessions only, ordered - most-recently-used first. Each carries its `directory`, its `tag`, its `busy` - state (another connection currently holds it) and its recency. A session with + most-recently-used first. Each carries its `directory`, its `tag` and its + recency. A session with no recorded tag is never listed, and no pipeline stage session is ever listed: stage sessions are still recorded in `run_steps`/`run_session_owners` for the run that owns them. The list is fail-closed: with no registry and no - store it returns an empty list, never the endpoint's whole session list. + store it returns an empty list, never the endpoint's whole session list. A + session is never marked `busy`: any number of clients may watch and write one. +- `chat_subscribe` attaches a connection to one session's shared live stream (body + `session_id`) and replays the session's still-pending approval requests, so every + client that watches a session sees every frame any client's turn produces — the + other devices' prompts and the turn's streaming output — and can answer a shared + approval. Attaching is idempotent per connection; the subscription is released + when the connection ends. +- `chat_prompt` may come from any client. A prompt whose session already has a turn + in flight is accepted into that session's bounded queue (currently 8) and + acknowledged with `chat_queued: true`; the agent never receives two interleaved + turns. The prompt is echoed to the other watching clients as a `chat_event` of + kind `user`, carried with the sender's `client` label (a device name), while the + sender's own transcript keeps its local copy. +- `chat_reply` is exactly-once: the first answer to a pending request wins, is + recorded with the answering client's label and is pushed back to every watching + client as the same `chat_permission` frame with `resolved: true`, `decision` and + `resolved_by`, so each card clears and shows the outcome. A later answer is + refused as already answered (naming the client that won), never silently ignored + and never delivered to the agent twice. - `chat_create` takes a `title` (default "New chat") and a `directory` (default `~`, the operator's home; `~`, an omitted or empty value and a `~/...` value all resolve to the home directory). A relative or missing directory is @@ -357,8 +376,11 @@ password file as a reference). The stored tag is exactly `operator`; the display label `Operator` is derived from it, so there is no second tag vocabulary. Chat uses the server's one OpenCode -transport, and every existing chat guarantee (retained-state bounds, the -permission/approval flow, interruption, one broker call per list) is unchanged. +transport. A session's stream is fanned out to every client watching it, prompts +are serialised per session (queued behind the in-flight turn rather than +rejected), and approvals are shared and exactly-once; the retained-state bounds, +the resync-on-reconnect path, the exclusion of a run's own session and +per-connection write serialisation are unchanged. The operator-session registry, filter, directory defaulting and the list bound are covered by the `pipeline`, `opencode` and `server` unit tests. The live end-to-end diff --git a/internal/protocol/chat.go b/internal/protocol/chat.go index bd39f8f0..c364eb37 100644 --- a/internal/protocol/chat.go +++ b/internal/protocol/chat.go @@ -26,6 +26,13 @@ const ( ChatMessages = "chat_messages" ChatInterrupt = "chat_interrupt" ChatReply = "chat_reply" + // ChatSubscribe attaches a connection to one session's shared live stream so + // it receives every frame any client's turn produces (its own and the other + // devices'), not only the frames of a turn it prompted itself. Any number of + // clients may watch one session; the session is never read-only. The request + // body is a ChatQuery naming the session and the response echoes the request + // id once the subscription is attached. + ChatSubscribe = "chat_subscribe" // ChatDirectories is the request/response type for the operator's directory // choices: the home directory plus the directories of previous operator // sessions, most recently used first, deduplicated and bounded. It is a @@ -49,13 +56,16 @@ const ( ) // ChatEvent.Kind values pushed on the chat_event stream. Step and usage carry -// no ChatPart; they report turn progress and the turn's totals. +// no ChatPart; they report turn progress and the turn's totals. User carries the +// text of a prompt another client sent, so a transcript can show it live; it is +// never sent back to the client that sent the prompt. const ( ChatEventText = ChatPartText ChatEventReasoning = ChatPartReasoning ChatEventTool = ChatPartTool ChatEventStep = "step" ChatEventUsage = "usage" + ChatEventUser = "user" ) // ChatStep.Status values, mirroring the OpenCode session.step events. @@ -111,10 +121,11 @@ type ChatSession struct { Tag string `json:"tag,omitempty"` CreatedAt int64 `json:"created_at,omitempty"` UpdatedAt int64 `json:"updated_at,omitempty"` - // Busy marks a session another client currently holds (or one the server - // itself owns as an active run), so the phone can show it read-only instead - // of letting two clients silently write the same conversation. It is - // additive and optional: older peers ignore it. + // Busy is retained for wire compatibility only: it is never set by this + // server. A session is never read-only, any number of clients may watch and + // write it, and only a turn is serialised (a waiting prompt is acknowledged + // as queued on its own client instead of marking the session Busy). Older + // peers still parse the field; newer ones ignore it. Busy bool `json:"busy,omitempty"` } @@ -144,26 +155,34 @@ type ChatQuery struct { // ChatPromptRequest is the chat_prompt request body: the text to send, with an // optional model/agent override and attached file URIs. The matching response is -// the inbox envelope, which the server folds into a ChatMessage. +// the inbox envelope, which the server folds into a ChatMessage. Client is the +// sending device's human-readable label so every other client can attribute the +// message; the server sanitises it and falls back to a generic label when it is +// blank. type ChatPromptRequest struct { SessionID string `json:"session_id"` Text string `json:"text"` Model string `json:"model,omitempty"` Agent string `json:"agent,omitempty"` Files []string `json:"files,omitempty"` + Client string `json:"client,omitempty"` } // ChatMessage is one stored turn returned by chat_messages. A user turn is a // single text part; an assistant turn holds the text, reasoning and tool parts // the phone renders. Parts corresponds to the OpenCode content array. type ChatMessage struct { - ID string `json:"id"` - SessionID string `json:"session_id"` - Role string `json:"role"` - Model string `json:"model,omitempty"` - Agent string `json:"agent,omitempty"` - CreatedAt int64 `json:"created_at,omitempty"` - Parts []ChatPart `json:"parts"` + ID string `json:"id"` + SessionID string `json:"session_id"` + Role string `json:"role"` + Model string `json:"model,omitempty"` + Agent string `json:"agent,omitempty"` + CreatedAt int64 `json:"created_at,omitempty"` + // Client is the sending device's label on a user turn the server echoed, so a + // resumed transcript still says who sent the message. It is empty on an + // assistant turn. + Client string `json:"client,omitempty"` + Parts []ChatPart `json:"parts"` } // ChatPart is one element of a ChatMessage. Type selects the meaning: text and @@ -225,6 +244,9 @@ type ChatEventFrame struct { Part *ChatPart `json:"part,omitempty"` Step *ChatStep `json:"step,omitempty"` Usage *ChatUsage `json:"usage,omitempty"` + // Client is the sending device's label on a user frame (ChatEventUser), so a + // transcript can say who sent the message. It is empty on assistant frames. + Client string `json:"client,omitempty"` } // ChatStep is a progress marker for the current step of a turn. @@ -258,6 +280,15 @@ type ChatPermissionFrame struct { Metadata map[string]any `json:"metadata,omitempty"` Source *ChatPermissionSource `json:"source,omitempty"` Message string `json:"message,omitempty"` + // Resolved, Decision and ResolvedBy report the shared, exactly-once outcome + // of a request any client may answer: once the first answer is recorded the + // server pushes the same frame back to every watching client with Resolved + // set, the Decision it recorded and the label of the client that gave it, so + // their cards clear and show the outcome instead of offering a stale choice. + // They are empty on a still-pending request. + Resolved bool `json:"resolved,omitempty"` + Decision string `json:"decision,omitempty"` + ResolvedBy string `json:"resolved_by,omitempty"` } // ChatPermissionSource identifies what raised a permission request, matching the @@ -271,10 +302,13 @@ type ChatPermissionSource struct { // ChatReplyRequest is the chat_reply request body: the phone's decision on a // pending permission request, mirroring -// POST /api/session/{id}/permission/{requestID}/reply. +// POST /api/session/{id}/permission/{requestID}/reply. Client is the answering +// device's label, recorded with the resolution so every other client can see +// which device answered. type ChatReplyRequest struct { SessionID string `json:"session_id"` RequestID string `json:"request_id"` Decision string `json:"decision"` Message string `json:"message,omitempty"` + Client string `json:"client,omitempty"` } diff --git a/internal/protocol/chat_test.go b/internal/protocol/chat_test.go index 5c02e6cc..5415dded 100644 --- a/internal/protocol/chat_test.go +++ b/internal/protocol/chat_test.go @@ -25,7 +25,13 @@ func chatSamples() []struct { {"create", ChatCreateRequest{Title: "demo", Directory: "/work"}}, {"adopt", ChatAdoptRequest{SessionID: "ses_1"}}, {"query", ChatQuery{SessionID: "ses_1", Limit: 50}}, - {"prompt", ChatPromptRequest{SessionID: "ses_1", Text: "hello", Model: "m", Agent: "build", Files: []string{"file:///tmp/a.png"}}}, + {"prompt", ChatPromptRequest{SessionID: "ses_1", Text: "hello", Model: "m", Agent: "build", Files: []string{"file:///tmp/a.png"}, Client: "Pixel 9 Pro XL"}}, + {"prompt_queued_ack", Message{Type: ChatPrompt, ID: "a1", ChatQueued: true}}, + {"subscribe", ChatQuery{SessionID: "ses_1"}}, + {"event_user", ChatEventFrame{ + SessionID: "ses_1", MessageID: "usr_1", Kind: ChatEventUser, Client: "Pixel 10 Pro Fold", + Part: &ChatPart{Type: ChatPartText, ID: "usr", Text: "from the fold"}, + }}, {"message", ChatMessage{ ID: "msg_1", SessionID: "ses_1", Role: ChatRoleAssistant, Model: "m", Agent: "build", CreatedAt: 1792112366711, Parts: []ChatPart{ @@ -64,7 +70,11 @@ func chatSamples() []struct { Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"}, Message: "wants to run a command", }}, - {"reply", ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionOnce, Message: "ok"}}, + {"permission_resolved", ChatPermissionFrame{ + SessionID: "ses_1", RequestID: "per_1", Action: "bash", + Resolved: true, Decision: ChatDecisionOnce, ResolvedBy: "Pixel 9 Pro XL", + }}, + {"reply", ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionOnce, Message: "ok", Client: "Pixel 9 Pro XL"}}, } } diff --git a/internal/protocol/message.go b/internal/protocol/message.go index 0ca03db2..2616acf5 100644 --- a/internal/protocol/message.go +++ b/internal/protocol/message.go @@ -166,6 +166,12 @@ type Message struct { ChatEvent *ChatEventFrame `json:"chat_event,omitempty"` ChatPermission *ChatPermissionFrame `json:"chat_permission,omitempty"` ChatReply *ChatReplyRequest `json:"chat_reply,omitempty"` + // ChatSubscribe attaches this connection to one session's shared stream; the + // body names the session like ChatQuery. A chat_prompt response sets + // ChatQueued when the prompt had to wait for an in-flight turn and was + // accepted into the session's queue instead of being sent immediately. + ChatSubscribe *ChatQuery `json:"chat_subscribe,omitempty"` + ChatQueued bool `json:"chat_queued,omitempty"` // ChatDirectories carries the operator's directory choices on a // chat_directories response (home first, then recent operator-session // directories, deduplicated and bounded). Additive/omitempty so older peers diff --git a/internal/server/chat.go b/internal/server/chat.go index 6112c876..ccc8d6cb 100644 --- a/internal/server/chat.go +++ b/internal/server/chat.go @@ -46,10 +46,10 @@ type operatorRegistry interface { OperatorDirectories(ctx context.Context, limit int) ([]string, error) } -// chatClientToken returns an unguessable per-connection identity. It attributes -// a session claim so two clients on the same server cannot silently write the -// same conversation; a fresh token per connection means a reconnected client is -// a new writer and must re-claim. +// chatClientToken returns an unguessable per-connection identity. Its only role +// is to key a connection's chat-room subscriptions and to exclude the sender from +// its own fan-out; it carries no ownership. A fresh token per connection means a +// reconnected client is a new identity and simply reattaches. func chatClientToken() string { var b [8]byte if _, err := rand.Read(b[:]); err != nil { @@ -68,6 +68,9 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker case protocol.ChatPrompt: handleChatPrompt(ctx, request, broker, hub, registry, clientID, write) return true + case protocol.ChatSubscribe: + handleChatSubscribe(request, broker, hub, clientID, write) + return true case protocol.ChatMessages: handleChatMessages(ctx, request, broker, hub, write) return true @@ -78,7 +81,7 @@ func handleChat(ctx context.Context, request protocol.Message, broker chatBroker handleChatSimple(ctx, request, broker, hub, write) return true case protocol.ChatSessions: - handleChatSessions(ctx, request, broker, hub, registry, clientID, write) + handleChatSessions(ctx, request, broker, hub, registry, write) return true case protocol.ChatCreate: handleChatCreate(ctx, request, broker, registry, write) diff --git a/internal/server/chat_claims.go b/internal/server/chat_claims.go deleted file mode 100644 index ccc1792e..00000000 --- a/internal/server/chat_claims.go +++ /dev/null @@ -1,65 +0,0 @@ -package server - -// claim reserves sessionID for clientID. It reports true when the session is -// free or already held by the same client (so a client may re-prompt its own -// session) and false when another client holds it. The claim map is bounded by -// chatMaxTurns with oldest-eviction so a stuck client cannot grow it without -// limit. -func (h *chatHub) claim(sessionID, clientID string) bool { - if sessionID == "" || clientID == "" { - return false - } - h.mu.Lock() - defer h.mu.Unlock() - if h.claims == nil { - h.claims = map[string]string{} - } - if holder, ok := h.claims[sessionID]; ok { - return holder == clientID - } - h.evictClaimsLocked() - h.claims[sessionID] = clientID - h.claimOrder = append(h.claimOrder, sessionID) - return true -} - -// release drops the same client's claim on sessionID; a claim held by a -// different client is left untouched so a stale release cannot free a live one. -func (h *chatHub) release(sessionID, clientID string) { - h.mu.Lock() - defer h.mu.Unlock() - if holder, ok := h.claims[sessionID]; !ok || holder != clientID { - return - } - delete(h.claims, sessionID) - for i, id := range h.claimOrder { - if id == sessionID { - h.claimOrder = append(h.claimOrder[:i], h.claimOrder[i+1:]...) - break - } - } -} - -// busyForOther reports whether another client currently holds sessionID. -func (h *chatHub) busyForOther(sessionID, clientID string) bool { - h.mu.Lock() - defer h.mu.Unlock() - holder, ok := h.claims[sessionID] - return ok && holder != clientID -} - -// evictClaimsLocked drops the oldest claim when the cap is reached, keeping the -// claim map bounded like the retained turns. Callers must hold h.mu. -func (h *chatHub) evictClaimsLocked() { - if len(h.claims) < chatMaxTurns { - return - } - for len(h.claimOrder) > 0 { - oldest := h.claimOrder[0] - h.claimOrder = h.claimOrder[1:] - if _, ok := h.claims[oldest]; ok { - delete(h.claims, oldest) - return - } - } -} diff --git a/internal/server/chat_commands.go b/internal/server/chat_commands.go index 58600e58..2d160373 100644 --- a/internal/server/chat_commands.go +++ b/internal/server/chat_commands.go @@ -68,9 +68,27 @@ func handleChatSimple(ctx context.Context, request protocol.Message, broker chat _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid permission decision is required"}) return } + // A pending approval is shared and exactly-once: the first answer wins and is + // recorded with the client that gave it, and a later answer is refused as + // already answered rather than reaching the agent twice. + label := sanitizeChatClientLabel(reply.Client) + if hub != nil { + if prior, ok := hub.reservePermission(reply.SessionID, reply.RequestID, label); !ok { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: permissionRefusal(prior, reply.RequestID)}) + return + } + } if err := broker.Reply(ctx, *reply); err != nil { + if hub != nil { + hub.releasePermission(reply.SessionID, reply.RequestID) + } _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) return } _ = write(protocol.Message{Type: protocol.ChatReply, ID: request.ID}) + if hub != nil { + // Push the resolution to every client watching the session so each card + // clears and shows the outcome and which device answered. + hub.confirmPermission(reply.SessionID, reply.RequestID, label, reply.Decision) + } } diff --git a/internal/server/chat_hub.go b/internal/server/chat_hub.go index f265b56f..b04105b7 100644 --- a/internal/server/chat_hub.go +++ b/internal/server/chat_hub.go @@ -1,7 +1,9 @@ package server import ( + "context" "log" + "strconv" "sync" "time" @@ -22,15 +24,18 @@ const chatMaxTurns = 128 // chatHub retains the accumulated turn state per session, independently of any // single connection, so a reconnecting client can re-sync what it missed. State // is keyed by session and then by message id (a session holds many turns), and -// is capped at chatRetainedLimit. +// is capped at chatRetainedLimit. It also owns the per-session live rooms: the +// one broker stream, the prompt queue and the fan-out to every attached client. type chatHub struct { - mu sync.Mutex - turns map[string]*chatTurn - now func() time.Time - // claims maps a session to the client currently writing it so a second - // client is rejected; claimOrder bounds the map like chatMaxTurns. - claims map[string]string - claimOrder []string + mu sync.Mutex + turns map[string]*chatTurn + rooms map[string]*chatRoom + baseCtx context.Context + registry operatorRegistry + now func() time.Time + // userSeq is a monotonic source of ids for the user turns the server echoes + // to the other clients, so each retained user message has a stable id. + userSeq int } // chatPart is the retained form of one part. Text and reasoning deltas append to @@ -40,12 +45,16 @@ type chatPart struct { text []byte } -// chatMessage is one retained assistant turn. Its parts keep the exact ids the -// supporting chat_event frames carried, so a resume preserves attribution. +// chatMessage is one retained turn. Its parts keep the exact ids the supporting +// chat_event frames carried, so a resume preserves attribution. Role and client +// are carried for a user turn the server echoed (a prompt another client sent), +// so a resumed transcript still says who sent it. type chatMessage struct { - id string - order []string - parts map[string]*chatPart + id string + role string + client string + order []string + parts map[string]*chatPart } type chatTurn struct { @@ -62,10 +71,33 @@ type chatTurn struct { // bounds it to chatPermissionRetainedLimit. permissions map[string]struct{} permissionOrder []string + // resolutions records the shared exactly-once answers to permission requests, + // keyed by request id, so a second answer is refused and the recorded outcome + // survives the clients that gave it; resolutionOrder bounds it to + // chatPermissionRetainedLimit like the dedup set above. + resolutions map[string]*chatResolution + resolutionOrder []string +} + +// chatResolution is the shared answer to one permission request. answered is +// false while the first answer is still being delivered to the agent, so a +// concurrent second answer is refused without ever reaching the agent twice. +type chatResolution struct { + client string + decision string + answered bool } func newChatHub() *chatHub { - return &chatHub{turns: map[string]*chatTurn{}, now: time.Now} + return &chatHub{turns: map[string]*chatTurn{}, rooms: map[string]*chatRoom{}, baseCtx: context.Background(), now: time.Now} +} + +// nextUserMessageID mints a stable id for one echoed user turn. +func (h *chatHub) nextUserMessageID() string { + h.mu.Lock() + defer h.mu.Unlock() + h.userSeq++ + return "usr_" + strconv.Itoa(h.userSeq) } func (h *chatHub) clock() time.Time { @@ -100,11 +132,33 @@ func (h *chatHub) apply(frame protocol.ChatEventFrame) { } message := turn.messages[frame.MessageID] if message == nil { - message = &chatMessage{id: frame.MessageID, parts: map[string]*chatPart{}} + role := protocol.ChatRoleAssistant + client := "" + if frame.Kind == protocol.ChatEventUser { + role = protocol.ChatRoleUser + client = frame.Client + } + message = &chatMessage{id: frame.MessageID, role: role, client: client, parts: map[string]*chatPart{}} turn.order = append(turn.order, frame.MessageID) turn.messages[frame.MessageID] = message + } else if message.client == "" && frame.Kind == protocol.ChatEventUser { + message.client = frame.Client } switch frame.Kind { + case protocol.ChatEventUser: + if frame.Part == nil || frame.Part.ID == "" || frame.Part.Text == "" || turn.overflow { + return + } + if !turn.retain(len(frame.Part.Text)) { + return + } + part, ok := message.parts[frame.Part.ID] + if !ok { + part = &chatPart{part: protocol.ChatPart{Type: protocol.ChatPartText, ID: frame.Part.ID}} + message.order = append(message.order, frame.Part.ID) + message.parts[frame.Part.ID] = part + } + part.text = append(part.text, frame.Part.Text...) case protocol.ChatEventText, protocol.ChatEventReasoning: id := "" if frame.Part != nil { @@ -255,6 +309,10 @@ func (h *chatHub) snapshot(sessionID string) []protocol.ChatMessage { continue } out := protocol.ChatMessage{ID: id, SessionID: sessionID, Role: protocol.ChatRoleAssistant} + if message.role != "" { + out.Role = message.role + } + out.Client = message.client for _, partID := range message.order { if part, ok := message.parts[partID]; ok { piece := part.part diff --git a/internal/server/chat_multiclient_test.go b/internal/server/chat_multiclient_test.go new file mode 100644 index 00000000..43d373a5 --- /dev/null +++ b/internal/server/chat_multiclient_test.go @@ -0,0 +1,472 @@ +package server + +import ( + "context" + "errors" + "net/http/httptest" + "strings" + "sync" + "testing" + "time" + + "github.com/coder/websocket" + "github.com/coder/websocket/wsjson" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// channelChat is a broker whose stream is driven frame-by-frame from a channel, +// so a test can hold a turn in flight and prove prompt serialisation, fan-out and +// exactly-once approval behaviour without a real OpenCode service. +type channelChat struct { + mu sync.Mutex + prompts []string + perm []protocol.ChatPermissionFrame + replies []protocol.ChatReplyRequest + frames chan protocol.ChatEventFrame + ready chan struct{} + once sync.Once + // promptErrAt, when nonzero, is the 1-based index of the Prompt call that + // fails, so a test can prove a broker failure is reported to the client that + // sent the prompt. + promptErrAt int +} + +func newChannelChat() *channelChat { + return &channelChat{frames: make(chan protocol.ChatEventFrame, 32), ready: make(chan struct{})} +} + +func (c *channelChat) Prompt(_ context.Context, _, text string) error { + c.mu.Lock() + c.prompts = append(c.prompts, text) + fail := c.promptErrAt != 0 && len(c.prompts) == c.promptErrAt + c.mu.Unlock() + if fail { + return errors.New("broker rejected the prompt") + } + return nil +} + +func (c *channelChat) Stream(ctx context.Context, _ string, ready func(), emit func(protocol.ChatEventFrame) error) error { + c.once.Do(func() { + close(c.ready) + if ready != nil { + ready() + } + }) + for { + select { + case <-ctx.Done(): + return ctx.Err() + case frame := <-c.frames: + if err := emit(frame); err != nil { + return err + } + } + } +} + +func (c *channelChat) Interrupt(context.Context, string) error { return nil } + +func (c *channelChat) Messages(context.Context, string, int) ([]protocol.ChatMessage, error) { + return nil, nil +} + +func (c *channelChat) Sessions(context.Context) ([]protocol.ChatSession, error) { return nil, nil } + +func (c *channelChat) Create(_ context.Context, title, directory string) (protocol.ChatSession, error) { + return protocol.ChatSession{ID: "ses_created", Title: title, Directory: directory}, nil +} + +func (c *channelChat) Session(context.Context, string) (protocol.ChatSession, bool, error) { + return protocol.ChatSession{}, false, nil +} + +func (c *channelChat) Permissions(context.Context, string) ([]protocol.ChatPermissionFrame, error) { + c.mu.Lock() + defer c.mu.Unlock() + return append([]protocol.ChatPermissionFrame(nil), c.perm...), nil +} + +func (c *channelChat) Reply(_ context.Context, request protocol.ChatReplyRequest) error { + c.mu.Lock() + c.replies = append(c.replies, request) + c.mu.Unlock() + return nil +} + +func (c *channelChat) push(frame protocol.ChatEventFrame) { + c.frames <- frame +} + +func (c *channelChat) promptCount() int { + c.mu.Lock() + defer c.mu.Unlock() + return len(c.prompts) +} + +func (c *channelChat) promptTexts() []string { + c.mu.Lock() + defer c.mu.Unlock() + return append([]string(nil), c.prompts...) +} + +func (c *channelChat) replyCount() int { + c.mu.Lock() + defer c.mu.Unlock() + return len(c.replies) +} + +// dialChatServer starts one server and dials n connections, returning the server +// so a test can reconnect a dropped client to the same hub. +func dialChatServer(t *testing.T, options Options, n int) (context.Context, context.CancelFunc, *httptest.Server, []*websocket.Conn) { + t.Helper() + ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) + srv := httptest.NewServer(HandlerWithOptions(ctx, options)) + t.Cleanup(func() { srv.Close(); cancel() }) + conns := make([]*websocket.Conn, 0, n) + for i := 0; i < n; i++ { + conns = append(conns, dialChatConn(t, ctx, srv)) + } + return ctx, cancel, srv, conns +} + +func dialChatConn(t *testing.T, ctx context.Context, srv *httptest.Server) *websocket.Conn { + t.Helper() + conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { conn.CloseNow() }) + return conn +} + +// readUntil reads messages until one of type want arrives, failing on a server +// error frame; interleaved push frames are skipped. +func readUntil(t *testing.T, ctx context.Context, conn *websocket.Conn, want string) protocol.Message { + t.Helper() + for { + var message protocol.Message + if err := wsjson.Read(ctx, conn, &message); err != nil { + t.Fatalf("read (waiting for %s): %v", want, err) + } + if message.Type == protocol.Error { + t.Fatalf("server error frame while waiting for %s: %s", want, message.Error) + } + if message.Type == want { + return message + } + } +} + +// nextEvent reads the next chat_event frame strictly, so a test can assert the +// order of the turn's frames. +func nextEvent(t *testing.T, ctx context.Context, conn *websocket.Conn) protocol.ChatEventFrame { + t.Helper() + for { + var message protocol.Message + if err := wsjson.Read(ctx, conn, &message); err != nil { + t.Fatalf("read event: %v", err) + } + if message.Type == protocol.Error { + t.Fatalf("server error frame: %s", message.Error) + } + if message.Type == protocol.ChatEvent && message.ChatEvent != nil { + return *message.ChatEvent + } + } +} + +// nextPermission reads the next chat_permission frame for requestID. +func nextPermission(t *testing.T, ctx context.Context, conn *websocket.Conn, requestID string) protocol.ChatPermissionFrame { + t.Helper() + for { + var message protocol.Message + if err := wsjson.Read(ctx, conn, &message); err != nil { + t.Fatalf("read permission: %v", err) + } + if message.Type == protocol.Error { + t.Fatalf("server error frame: %s", message.Error) + } + if message.Type == protocol.ChatPermission && message.ChatPermission != nil && message.ChatPermission.RequestID == requestID { + return *message.ChatPermission + } + } +} + +func writeChat(t *testing.T, ctx context.Context, conn *websocket.Conn, message protocol.Message) { + t.Helper() + if err := wsjson.Write(ctx, conn, message); err != nil { + t.Fatal(err) + } +} + +// TestChatFanoutToSeveralClients is the multi-client acceptance test: a prompt +// from one client is accepted, its user turn is pushed live to the other client +// attributed to the sending device, and the turn's streaming frames reach every +// watching client, not only the one that prompted. +func TestChatFanoutToSeveralClients(t *testing.T) { + broker := newChannelChat() + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // The tablet watches the session before anything is sent. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatSubscribe, ID: "s1", ChatSubscribe: &protocol.ChatQuery{SessionID: "ses_1"}}) + readUntil(t, ctx, tablet, protocol.ChatSubscribe) + + // The phone prompts. Its ack is not a queue acknowledgement. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "from the phone", Client: "Pixel 9"}}) + ack := readUntil(t, ctx, phone, protocol.ChatPrompt) + if ack.ID != "p1" || ack.ChatQueued { + t.Fatalf("phone prompt ack = %+v, want accepted (not queued)", ack) + } + + // The tablet sees the phone's message, attributed to the phone. + userFrame := nextEvent(t, ctx, tablet) + if userFrame.Kind != protocol.ChatEventUser || userFrame.Client != "Pixel 9" || userFrame.Part == nil || userFrame.Part.Text != "from the phone" { + t.Fatalf("tablet user frame = %+v, want the phone's message attributed to Pixel 9", userFrame) + } + + // The turn's streaming output reaches both clients in order. + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: "hel", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: "lo", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}}) + + for _, client := range []struct { + name string + conn *websocket.Conn + }{{"phone", phone}, {"tablet", tablet}} { + var text strings.Builder + for i := 0; i < 2; i++ { + frame := nextEvent(t, ctx, client.conn) + if frame.Kind != protocol.ChatEventText { + t.Fatalf("%s frame %d = %+v, want text", client.name, i, frame) + } + text.WriteString(frame.Delta) + } + if text.String() != "hello" { + t.Fatalf("%s saw %q, want the streamed turn output", client.name, text.String()) + } + if end := nextEvent(t, ctx, client.conn); end.Kind != protocol.ChatEventStep || end.Step == nil || end.Step.Status != protocol.ChatStepEnded { + t.Fatalf("%s step frame = %+v, want ended", client.name, end) + } + } +} + +// TestChatPromptSerialisedPerSession pins that two prompts for one session never +// interleave: the second is accepted as queued and only posted once the first +// turn ends. +func TestChatPromptSerialisedPerSession(t *testing.T) { + broker := newChannelChat() + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "one"}}) + if ack := readUntil(t, ctx, phone, protocol.ChatPrompt); ack.ChatQueued { + t.Fatalf("first prompt should start immediately: %+v", ack) + } + + // The tablet's prompt while the turn is in flight is queued, and it is told so. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatPrompt, ID: "p2", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "two"}}) + if ack := readUntil(t, ctx, tablet, protocol.ChatPrompt); !ack.ChatQueued { + t.Fatalf("second prompt should be acknowledged as queued: %+v", ack) + } + if broker.promptCount() != 1 { + t.Fatalf("prompts forwarded = %d, want 1 while the first turn is in flight", broker.promptCount()) + } + + // End the first turn; the queued prompt is then posted. + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}}) + deadline := time.Now().Add(3 * time.Second) + for broker.promptCount() < 2 { + if time.Now().After(deadline) { + t.Fatalf("queued prompt was never posted: %v", broker.promptTexts()) + } + time.Sleep(5 * time.Millisecond) + } + if got := broker.promptTexts(); len(got) != 2 || got[0] != "one" || got[1] != "two" { + t.Fatalf("prompts = %v, want [one two] in order", got) + } +} + +// TestChatApprovalFirstAnswerWins is the exactly-once acceptance test: a pending +// approval is shared, the first answer is recorded with the client that gave it +// and broadcast to every client, and a later answer is refused. +func TestChatApprovalFirstAnswerWins(t *testing.T) { + broker := newChannelChat() + broker.perm = []protocol.ChatPermissionFrame{{SessionID: "ses_1", RequestID: "req_1", Action: "bash", Resources: []string{"rm -rf /tmp"}}} + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // A turn starts so the poller runs and pushes the pending request. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "run it"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + + pending := nextPermission(t, ctx, phone, "req_1") + if pending.Resolved { + t.Fatalf("request already marked resolved: %+v", pending) + } + + // A second client attaches and is replayed the still-pending request, so its + // card is answerable too. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatSubscribe, ID: "s1", ChatSubscribe: &protocol.ChatQuery{SessionID: "ses_1"}}) + readUntil(t, ctx, tablet, protocol.ChatSubscribe) + replay := nextPermission(t, ctx, tablet, "req_1") + if replay.Resolved || replay.Action != "bash" { + t.Fatalf("replayed permission = %+v, want the pending request", replay) + } + + // The phone answers first. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatReply, ID: "a1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce, Client: "Pixel 9"}}) + readUntil(t, ctx, phone, protocol.ChatReply) + + // Both clients see the resolution, with the answering device recorded. + for _, client := range []struct { + name string + conn *websocket.Conn + }{{"phone", phone}, {"tablet", tablet}} { + resolution := nextPermission(t, ctx, client.conn, "req_1") + if !resolution.Resolved || resolution.Decision != protocol.ChatDecisionOnce || resolution.ResolvedBy != "Pixel 9" { + t.Fatalf("%s resolution = %+v, want resolved once by Pixel 9", client.name, resolution) + } + } + + // The tablet's later answer is refused, and it never reaches the agent. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatReply, ID: "a2", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionAlways, Client: "Pixel 10 Pro Fold"}}) + var refused protocol.Message + if err := wsjson.Read(ctx, tablet, &refused); err != nil { + t.Fatal(err) + } + if refused.Type != protocol.Error || !strings.Contains(refused.Error, "already answered by Pixel 9") { + t.Fatalf("second answer was not refused as already answered: %+v", refused) + } + if broker.replyCount() != 1 { + t.Fatalf("broker replies = %d, want the agent to receive exactly one answer", broker.replyCount()) + } +} + +// TestChatSubscribeWireShape pins the exact wire body the Android app sends for +// chat_subscribe (ChatProtocol.subscribeRequest): the session id travels in the +// chat_subscribe field, not chat_query. The handler once read chat_query, so the +// unit tests passed while the shipped app's subscribe was silently rejected; this +// test writes the raw JSON, attaches the connection and proves a prompt from +// another client reaches it. +func TestChatSubscribeWireShape(t *testing.T) { + broker := newChannelChat() + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, watch := conns[0], conns[1] + + if err := watch.Write(ctx, websocket.MessageText, []byte(`{"type":"chat_subscribe","id":"s1","chat_subscribe":{"session_id":"ses_1"}}`)); err != nil { + t.Fatal(err) + } + if ack := readUntil(t, ctx, watch, protocol.ChatSubscribe); ack.ID != "s1" { + t.Fatalf("subscribe ack = %+v, want id s1", ack) + } + + // The watcher is attached: another client's prompt is fanned out to it. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "ping", Client: "Pixel 9"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + frame := nextEvent(t, ctx, watch) + if frame.Kind != protocol.ChatEventUser || frame.Client != "Pixel 9" || frame.Part == nil || frame.Part.Text != "ping" { + t.Fatalf("watcher frame = %+v, want the phone's message (subscribe did not attach)", frame) + } +} + +// TestChatQueuedPromptFailureSurfaced pins that a prompt accepted as queued whose +// delivery to the agent later fails is reported to the client that sent it, +// instead of leaving its composer showing "Queued" with no error. +func TestChatQueuedPromptFailureSurfaced(t *testing.T) { + broker := newChannelChat() + broker.promptErrAt = 2 // the queued (second) prompt fails to reach the agent + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // The phone's prompt starts a turn held in flight. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "one"}}) + if ack := readUntil(t, ctx, phone, protocol.ChatPrompt); ack.ChatQueued { + t.Fatalf("first prompt should start immediately: %+v", ack) + } + + // The tablet's prompt is accepted as queued and acknowledged as such. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatPrompt, ID: "p2", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "two"}}) + if ack := readUntil(t, ctx, tablet, protocol.ChatPrompt); !ack.ChatQueued { + t.Fatalf("second prompt should be acknowledged as queued: %+v", ack) + } + + // End the first turn; the queued prompt is posted and the broker rejects it. + broker.push(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventStep, Step: &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}}) + + for { + var message protocol.Message + if err := wsjson.Read(ctx, tablet, &message); err != nil { + t.Fatalf("read (waiting for the queued prompt failure): %v", err) + } + if message.Type != protocol.Error { + continue + } + if message.ID != "p2" || !strings.Contains(message.Error, "broker rejected the prompt") { + t.Fatalf("queued prompt failure = %+v, want an error for p2 naming the broker failure", message) + } + break + } +} + +// TestChatPendingApprovalsAllReplayed pins that every unresolved approval request +// a room holds is replayed to a client that attaches afterwards, not only the +// most recent one, so both cards are answerable on the late client. +func TestChatPendingApprovalsAllReplayed(t *testing.T) { + broker := newChannelChat() + broker.perm = []protocol.ChatPermissionFrame{ + {SessionID: "ses_1", RequestID: "req_1", Action: "bash", Resources: []string{"rm -rf /tmp"}}, + {SessionID: "ses_1", RequestID: "req_2", Action: "write", Resources: []string{"/etc/hosts"}}, + } + ctx, _, _, conns := dialChatServer(t, Options{Chat: broker}, 2) + phone, tablet := conns[0], conns[1] + + // A turn starts so the poller pushes both pending requests to the phone. + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "run them"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + nextPermission(t, ctx, phone, "req_1") + nextPermission(t, ctx, phone, "req_2") + + // A client that attaches afterwards is replayed both. + writeChat(t, ctx, tablet, protocol.Message{Type: protocol.ChatSubscribe, ID: "s1", ChatSubscribe: &protocol.ChatQuery{SessionID: "ses_1"}}) + readUntil(t, ctx, tablet, protocol.ChatSubscribe) + first := nextPermission(t, ctx, tablet, "req_1") + second := nextPermission(t, ctx, tablet, "req_2") + if first.Resolved || second.Resolved || first.Action != "bash" || second.Action != "write" { + t.Fatalf("replayed permissions = %+v / %+v, want both still-pending requests", first, second) + } +} + +// TestChatResyncAfterReconnect is the resync acceptance test: a client that drops +// and reconnects re-syncs the whole conversation from retained state, including +// the user turn and who sent it. +func TestChatResyncAfterReconnect(t *testing.T) { + broker := scriptedChat() + ctx, _, srv, conns := dialChatServer(t, Options{Chat: broker}, 1) + phone := conns[0] + + writeChat(t, ctx, phone, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi", Client: "Pixel 9"}}) + readUntil(t, ctx, phone, protocol.ChatPrompt) + readChatTurn(t, ctx, phone) + + // The phone's socket drops. + phone.CloseNow() + + // A fresh connection re-syncs from retained state. + reconnected := dialChatConn(t, ctx, srv) + writeChat(t, ctx, reconnected, protocol.Message{Type: protocol.ChatMessages, ID: "m1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}) + response := readUntil(t, ctx, reconnected, protocol.ChatMessages) + if len(response.ChatMessages) != 2 { + t.Fatalf("resync returned %d messages, want user+assistant: %+v", len(response.ChatMessages), response.ChatMessages) + } + user := response.ChatMessages[0] + if user.Role != protocol.ChatRoleUser || user.Client != "Pixel 9" || len(user.Parts) != 1 || user.Parts[0].Text != "hi" { + t.Fatalf("resynced user turn = %+v", user) + } + assistant := response.ChatMessages[1] + if assistant.Role != protocol.ChatRoleAssistant || assistant.ID != "msg_1" { + t.Fatalf("resynced assistant turn = %+v", assistant) + } +} diff --git a/internal/server/chat_permissions.go b/internal/server/chat_permissions.go index 28a2b72b..32d006ba 100644 --- a/internal/server/chat_permissions.go +++ b/internal/server/chat_permissions.go @@ -1,5 +1,7 @@ package server +import "git.a-wan.net/alan/pipelines/internal/protocol" + // chatPermissionRetainedLimit bounds the dedup set of already-pushed permission // request ids one session retains, so a long turn cannot grow it without limit. const chatPermissionRetainedLimit = 256 @@ -31,24 +33,83 @@ func (h *chatHub) seenPermission(sessionID, requestID string) bool { return true } -// forgetPermission releases a request id reserved by seenPermission when its -// frame could not be written, so a later poll re-pushes it instead of the id -// staying "seen" while the phone never received the request. -func (h *chatHub) forgetPermission(sessionID, requestID string) { +// reservePermission claims the shared right to answer requestID for client. It +// returns true when this caller is the first to answer (the only caller allowed +// to reach the agent), and false with the recorded resolution when the request is +// already answered or is already being answered, so a later answer is refused +// rather than delivered twice. The reservation is bounded like the dedup set. +func (h *chatHub) reservePermission(sessionID, requestID, client string) (*chatResolution, bool) { if sessionID == "" || requestID == "" { - return + return nil, false } + h.mu.Lock() + defer h.mu.Unlock() + turn := h.turnLocked(sessionID) + if turn.resolutions == nil { + turn.resolutions = map[string]*chatResolution{} + } + if prior, ok := turn.resolutions[requestID]; ok { + return prior, false + } + turn.resolutions[requestID] = &chatResolution{client: client} + turn.resolutionOrder = append(turn.resolutionOrder, requestID) + if len(turn.resolutionOrder) > chatPermissionRetainedLimit { + oldest := turn.resolutionOrder[0] + turn.resolutionOrder = turn.resolutionOrder[1:] + delete(turn.resolutions, oldest) + } + return nil, true +} + +// releasePermission drops a reservation whose answer never reached the agent, so +// a later attempt can win instead of the request staying permanently refused. +func (h *chatHub) releasePermission(sessionID, requestID string) { h.mu.Lock() defer h.mu.Unlock() turn := h.turns[sessionID] if turn == nil { return } - delete(turn.permissions, requestID) - for i, id := range turn.permissionOrder { + delete(turn.resolutions, requestID) + for i, id := range turn.resolutionOrder { if id == requestID { - turn.permissionOrder = append(turn.permissionOrder[:i], turn.permissionOrder[i+1:]...) + turn.resolutionOrder = append(turn.resolutionOrder[:i], turn.resolutionOrder[i+1:]...) break } } } + +// confirmPermission records the delivered answer and pushes the resolution to +// every watching client, so each one's approval card clears and shows the +// outcome and which client gave it. +func (h *chatHub) confirmPermission(sessionID, requestID, client, decision string) { + h.mu.Lock() + if turn := h.turns[sessionID]; turn != nil { + if resolution, ok := turn.resolutions[requestID]; ok { + resolution.decision = decision + resolution.answered = true + } + } + frame := protocol.ChatPermissionFrame{SessionID: sessionID, RequestID: requestID} + var targets []*chatSub + if room := h.rooms[sessionID]; room != nil { + for i := range room.pending { + if room.pending[i].RequestID == requestID { + frame = room.pending[i] + room.pending = append(room.pending[:i], room.pending[i+1:]...) + break + } + } + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + h.mu.Unlock() + frame.Resolved = true + frame.Decision = decision + frame.ResolvedBy = client + msg := protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame} + for _, sub := range targets { + sub.send(msg) + } +} diff --git a/internal/server/chat_room.go b/internal/server/chat_room.go new file mode 100644 index 00000000..caa16324 --- /dev/null +++ b/internal/server/chat_room.go @@ -0,0 +1,662 @@ +package server + +import ( + "context" + "errors" + "fmt" + "log" + "strings" + "sync" + "time" + + "git.a-wan.net/alan/pipelines/internal/opencode" + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// The chat room is one session's shared live channel. Many clients attach to it +// (the operator's phone, tablet and terminal) and every frame any turn produces +// is fanned out to all of them, so each device sees the same conversation +// including the other devices' prompts and the turn's streaming output. The room +// owns the session's one broker stream and its one prompt queue, so a session is +// never read-only for a client and two turns never interleave: a prompt that +// arrives while a turn is in flight is queued (bounded) and its client is told so +// in the ack. +const ( + // chatRoomSubscriberBuffer bounds one attached client's pending frames. A + // client that falls this far behind is dropped rather than blocking the turn + // or the other clients; it re-syncs from history when it reattaches. + chatRoomSubscriberBuffer = 64 + // chatRoomQueueLimit bounds the prompts one session may hold while a turn is + // in flight. A prompt that would exceed it is refused with a visible error + // instead of being silently dropped. + chatRoomQueueLimit = 8 + // chatClientLabelMax bounds the human-readable client label the server stores + // and echoes, so a long device name cannot grow a frame without limit. + chatClientLabelMax = 48 + // chatClientLabelFallback labels a prompt whose sender did not name itself, so + // a transcript always has something to attribute the message to. + chatClientLabelFallback = "Another device" + // chatRoomPendingLimit bounds how many unresolved approval requests one room + // retains for replay to a client that attaches after they were raised, so a + // long turn cannot grow the replay state without limit. + chatRoomPendingLimit = 16 +) + +// chatSub is one client's attachment to a session's shared stream. Frames reach +// it through a dedicated writer goroutine so a slow or broken client never stalls +// the turn or the other subscribers; the buffered channel bounds how far behind +// it may fall. +type chatSub struct { + hub *chatHub + room *chatRoom + clientID string + label string + ch chan protocol.Message + done chan struct{} + once sync.Once + write func(protocol.Message) error +} + +func (s *chatSub) run() { + for { + select { + case <-s.done: + return + case msg := <-s.ch: + if err := s.write(msg); err != nil { + s.close() + return + } + } + } +} + +func (s *chatSub) send(msg protocol.Message) { + select { + case <-s.done: + return + default: + } + select { + case s.ch <- msg: + default: + // The client is not draining: drop it rather than block the fan-out. Its + // next attach re-syncs from history. + s.close() + } +} + +// close detaches the subscription and stops its writer goroutine exactly once. +func (s *chatSub) close() { + s.once.Do(func() { + close(s.done) + s.hub.detach(s.room.sessionID, s) + }) +} + +// chatQueuedPrompt is one prompt waiting for the session's in-flight turn to +// finish. acked marks a prompt the handler already acknowledged as queued, so the +// turn runner does not send a second (success) acknowledgement for the same +// request id; write is kept either way so a later broker failure is still +// reported to the client that sent it. +type chatQueuedPrompt struct { + text string + requestID string + write func(protocol.Message) error + acked bool +} + +// chatRoom is one session's shared live channel. Every field is guarded by the +// owning chatHub's mutex. +type chatRoom struct { + sessionID string + broker chatBroker + ctx context.Context + cancel context.CancelFunc + subs map[string]*chatSub + queue []*chatQueuedPrompt + running bool + streaming bool + // buffering holds the turn's frames until the prompting client's ack has been + // written, so the ack always precedes the frames it acknowledges. It is set + // only while the very first turn subscribes to the firehose. + buffering bool + buffered []protocol.ChatEventFrame + // pending holds the room's unresolved approval requests, in the order they + // were raised, replayed to a client that attaches after they were raised. A + // request is removed once it is resolved. + pending []protocol.ChatPermissionFrame + pollerStarted bool + wake chan struct{} + turnDone chan struct{} +} + +func newChatRoom(base context.Context, sessionID string) *chatRoom { + if base == nil { + base = context.Background() + } + roomCtx, cancel := context.WithCancel(base) + return &chatRoom{ + sessionID: sessionID, + ctx: roomCtx, + cancel: cancel, + subs: map[string]*chatSub{}, + wake: make(chan struct{}, 1), + } +} + +// roomLocked returns the session's room, creating it (and its turn runner) when +// it is the first client to watch the session. Callers must hold h.mu. +func (h *chatHub) roomLocked(sessionID string) *chatRoom { + if h.rooms == nil { + h.rooms = map[string]*chatRoom{} + } + if room := h.rooms[sessionID]; room != nil { + return room + } + room := newChatRoom(h.baseCtx, sessionID) + h.rooms[sessionID] = room + go h.runRoom(room) + return room +} + +// attach registers write as one client's subscription to sessionID's stream and +// returns it, or the existing subscription when the same connection has already +// attached. It is idempotent so a client may prompt and subscribe without +// registering twice. +func (h *chatHub) attach(sessionID, clientID, label string, broker chatBroker, write func(protocol.Message) error) *chatSub { + if sessionID == "" || clientID == "" || write == nil { + return nil + } + h.mu.Lock() + room := h.roomLocked(sessionID) + if room.broker == nil { + room.broker = broker + } + if sub, ok := room.subs[clientID]; ok { + if label != "" { + sub.label = label + } + h.mu.Unlock() + return sub + } + sub := &chatSub{ + hub: h, + room: room, + clientID: clientID, + label: label, + ch: make(chan protocol.Message, chatRoomSubscriberBuffer), + done: make(chan struct{}), + write: write, + } + room.subs[clientID] = sub + h.mu.Unlock() + go sub.run() + return sub +} + +// detach drops one subscription. The room (and its broker stream and queue) is +// released once its last client leaves, so a session with no watchers holds no +// goroutine. +func (h *chatHub) detach(sessionID string, sub *chatSub) { + h.mu.Lock() + room := h.rooms[sessionID] + if room == nil || room.subs[sub.clientID] != sub { + h.mu.Unlock() + return + } + delete(room.subs, sub.clientID) + if len(room.subs) == 0 { + delete(h.rooms, sessionID) + room.cancel() + } + h.mu.Unlock() +} + +// detachClient drops every chat subscription one connection holds; the read loop +// calls it when the connection ends so no subscriber goroutine outlives it. +func (h *chatHub) detachClient(clientID string) { + if clientID == "" { + return + } + h.mu.Lock() + var subs []*chatSub + for _, room := range h.rooms { + if sub, ok := room.subs[clientID]; ok { + subs = append(subs, sub) + } + } + h.mu.Unlock() + for _, sub := range subs { + sub.close() + } +} + +// fanout delivers one frame to every client watching sessionID except the one +// named by except (the sender, who already has it locally). +func (h *chatHub) fanout(sessionID string, msg protocol.Message, except string) { + h.mu.Lock() + var targets []*chatSub + if room := h.rooms[sessionID]; room != nil { + for id, sub := range room.subs { + if id == except { + continue + } + targets = append(targets, sub) + } + } + h.mu.Unlock() + for _, sub := range targets { + sub.send(msg) + } +} + +// broadcastUser retains a prompt as a user turn and pushes it live to every other +// client watching the session, attributed to the sending client's label. The +// sender already has the message locally, so it is excluded to keep its own +// transcript from duplicating it. +func (h *chatHub) broadcastUser(frame protocol.ChatEventFrame, exceptClientID string) { + h.apply(frame) + h.fanout(frame.SessionID, protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame}, exceptClientID) +} + +// emit folds one broker frame into the retained state and fans it out. While the +// first turn's ack is still pending the frames are buffered and flushed in order +// once it is written. A step-ended frame finishes the turn, letting the queue +// advance. +func (h *chatHub) emit(frame protocol.ChatEventFrame) { + h.apply(frame) + h.mu.Lock() + room := h.rooms[frame.SessionID] + buffered := false + var targets []*chatSub + if room != nil { + if room.buffering { + room.buffered = append(room.buffered, frame) + buffered = true + } else { + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + } + if room != nil && frame.Kind == protocol.ChatEventStep && frame.Step != nil && frame.Step.Status == protocol.ChatStepEnded { + h.finishTurnLocked(room) + } + h.mu.Unlock() + if buffered { + return + } + msg := protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame} + for _, sub := range targets { + sub.send(msg) + } +} + +// finishTurnLocked marks the room's turn finished and releases the turn runner's +// wait. Callers must hold h.mu. +func (h *chatHub) finishTurnLocked(room *chatRoom) { + room.running = false + if room.turnDone != nil { + close(room.turnDone) + room.turnDone = nil + } +} + +// flushBuffered releases the frames held while the ack was pending and delivers +// them in order. It is a no-op once the room is no longer buffering. +func (h *chatHub) flushBuffered(sessionID string) { + h.mu.Lock() + room := h.rooms[sessionID] + var pending []protocol.ChatEventFrame + var targets []*chatSub + if room != nil && room.buffering { + room.buffering = false + pending = room.buffered + room.buffered = nil + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + h.mu.Unlock() + for i := range pending { + frame := pending[i] + msg := protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame} + for _, sub := range targets { + sub.send(msg) + } + } +} + +// submitPrompt accepts one prompt: it starts the turn runner immediately when no +// turn is in flight, or queues it (bounded) when one is. It returns whether the +// prompt was queued or refused. +func (h *chatHub) submitPrompt(sessionID string, p *chatQueuedPrompt) (queued bool, refused bool) { + h.mu.Lock() + room := h.roomLocked(sessionID) + if room.running || len(room.queue) > 0 { + if len(room.queue) >= chatRoomQueueLimit { + h.mu.Unlock() + return false, true + } + // The client is acknowledged as queued by the handler, so the turn runner + // must not acknowledge the same request again once it runs. The write is + // still kept so a later broker failure reaches the client that sent it. + p.acked = true + room.queue = append(room.queue, p) + signalWake(room.wake) + h.mu.Unlock() + return true, false + } + room.queue = append(room.queue, p) + signalWake(room.wake) + h.mu.Unlock() + return false, false +} + +// pendingFrames returns a copy of the room's unresolved approval requests so a +// client that attaches after they were raised can be shown every one of them. It +// returns nil when the room holds none. +func (h *chatHub) pendingFrames(sessionID string) []protocol.ChatPermissionFrame { + h.mu.Lock() + defer h.mu.Unlock() + room := h.rooms[sessionID] + if room == nil || len(room.pending) == 0 { + return nil + } + frames := make([]protocol.ChatPermissionFrame, len(room.pending)) + copy(frames, room.pending) + return frames +} + +// pushPermission publishes one newly seen pending approval request to every +// client watching the session and remembers it (bounded) for a client that +// attaches later. A request already seen (or already resolved) is not pushed +// again. +func (h *chatHub) pushPermission(sessionID string, frame protocol.ChatPermissionFrame) { + if frame.RequestID == "" || frame.Resolved { + return + } + if !h.seenPermission(sessionID, frame.RequestID) { + return + } + h.mu.Lock() + var targets []*chatSub + if room := h.rooms[sessionID]; room != nil { + known := false + for i := range room.pending { + if room.pending[i].RequestID == frame.RequestID { + room.pending[i] = frame + known = true + break + } + } + if !known { + room.pending = append(room.pending, frame) + if len(room.pending) > chatRoomPendingLimit { + room.pending = room.pending[len(room.pending)-chatRoomPendingLimit:] + } + } + for _, sub := range room.subs { + targets = append(targets, sub) + } + } + h.mu.Unlock() + msg := protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame} + for _, sub := range targets { + sub.send(msg) + } +} + +// runRoom is the session's turn runner: it takes queued prompts one at a time, +// posts each to the broker and waits for the turn to end, so two prompts of one +// session can never interleave. +func (h *chatHub) runRoom(room *chatRoom) { + for { + p, done, ok := h.nextPrompt(room) + if !ok { + return + } + h.runTurn(room, p, done) + } +} + +// nextPrompt pops the next queued prompt, blocking until one arrives or the room +// is released. It marks the room running and creates the turn's completion +// channel so a stale signal from a previous turn can never end the next one. +func (h *chatHub) nextPrompt(room *chatRoom) (*chatQueuedPrompt, chan struct{}, bool) { + for { + h.mu.Lock() + if len(room.queue) > 0 { + p := room.queue[0] + room.queue = room.queue[1:] + room.running = true + room.turnDone = make(chan struct{}) + done := room.turnDone + h.mu.Unlock() + return p, done, true + } + h.mu.Unlock() + select { + case <-room.ctx.Done(): + return nil, nil, false + case <-room.wake: + } + } +} + +// runTurn subscribes to the broker stream when needed, posts one prompt, writes +// its ack and waits for the turn to end. +func (h *chatHub) runTurn(room *chatRoom, p *chatQueuedPrompt, done chan struct{}) { + broker := h.roomBroker(room) + first := false + h.mu.Lock() + if !room.streaming { + first = true + room.buffering = true + } + h.mu.Unlock() + defer h.flushBuffered(room.sessionID) + + if broker == nil { + h.failPrompt(room, p, errors.New("chat is not configured on this server")) + return + } + if first { + if err := h.startStream(room, broker); err != nil { + h.failPrompt(room, p, err) + h.endRoomTurn(room) + return + } + } + if err := broker.Prompt(room.ctx, room.sessionID, p.text); err != nil { + h.failPrompt(room, p, err) + h.endRoomTurn(room) + return + } + if h.registry != nil { + if err := h.registry.TouchOperatorSession(room.ctx, room.sessionID); err != nil { + log.Printf("touch operator session %s: %v", room.sessionID, err) + } + } + if p.write != nil && !p.acked { + _ = p.write(protocol.Message{Type: protocol.ChatPrompt, ID: p.requestID}) + } + h.flushBuffered(room.sessionID) + // Start the approval poller once, after the first ack, so a pending request + // is surfaced after the prompt is acknowledged and shared with every client. + h.mu.Lock() + startPoller := !room.pollerStarted + room.pollerStarted = true + h.mu.Unlock() + if startPoller { + go h.pollRoom(room, broker) + } + select { + case <-done: + case <-room.ctx.Done(): + } +} + +// endRoomTurn releases the turn slot after a prompt that never entered flight, +// so the queue advances immediately instead of waiting for a step that never +// comes. +func (h *chatHub) endRoomTurn(room *chatRoom) { + h.mu.Lock() + h.finishTurnLocked(room) + h.mu.Unlock() +} + +// failPrompt reports a refused prompt to the client that sent it, so a prompt +// that never reached the agent is visible on the device that sent it rather than +// leaving its composer waiting. It is reported for a queued prompt too, whose +// success ack was already sent but whose delivery may still fail. +func (h *chatHub) failPrompt(room *chatRoom, p *chatQueuedPrompt, err error) { + if p.write == nil || err == nil { + return + } + _ = p.write(protocol.Message{Type: protocol.Error, ID: p.requestID, Error: err.Error()}) +} + +// roomBroker returns the broker bound to the room. +func (h *chatHub) roomBroker(room *chatRoom) chatBroker { + h.mu.Lock() + defer h.mu.Unlock() + return room.broker +} + +// startStream attaches the room to the broker firehose, waiting until the +// subscription is ready so no delta emitted between subscribing and posting a +// prompt is lost. The permission poller starts alongside it. +func (h *chatHub) startStream(room *chatRoom, broker chatBroker) error { + attached := make(chan struct{}) + var once sync.Once + result := make(chan error, 1) + ctx := room.ctx + go func() { + result <- broker.Stream(ctx, room.sessionID, func() { + once.Do(func() { close(attached) }) + }, func(frame protocol.ChatEventFrame) error { + h.emit(frame) + return nil + }) + }() + select { + case <-attached: + case err := <-result: + if err == nil { + err = errors.New("chat stream ended before it was subscribed") + } + return err + case <-ctx.Done(): + return ctx.Err() + } + h.mu.Lock() + room.streaming = true + h.mu.Unlock() + go h.drainStream(room, result) + return nil +} + +// drainStream reports the terminal error of a room's subscription and clears the +// streaming flag so a later turn re-subscribes; it also releases a turn still +// waiting on a stream that ended. +func (h *chatHub) drainStream(room *chatRoom, result <-chan error) { + err := <-result + h.mu.Lock() + room.streaming = false + h.finishTurnLocked(room) + h.mu.Unlock() + if err != nil && room.ctx.Err() == nil { + log.Printf("chat stream session=%s: %v", room.sessionID, err) + } +} + +// pollRoom polls the broker's pending-approval list for the room on a fixed +// interval and pushes each newly seen request to every attached client. The +// first poll runs immediately; the loop stops with the room's context. +func (h *chatHub) pollRoom(room *chatRoom, broker chatBroker) { + ticker := time.NewTicker(chatPermissionPollInterval) + defer ticker.Stop() + reported := false + for { + if err := h.pollPermissionsOnce(room.ctx, broker, room.sessionID); err != nil { + if room.ctx.Err() != nil { + return + } + if errors.Is(err, opencode.ErrPermissionUnsupported) { + log.Printf("chat permission poll session=%s: %v", room.sessionID, err) + return + } + if reported { + log.Printf("chat permission poll session=%s: %v", room.sessionID, err) + } else { + reported = true + h.fanout(room.sessionID, protocol.Message{Type: protocol.Error, Error: "chat permission poll: " + err.Error()}, "") + } + } + select { + case <-room.ctx.Done(): + return + case <-ticker.C: + } + } +} + +// pollPermissionsOnce performs one poll and pushes each newly seen request of the +// session to every client watching it. +func (h *chatHub) pollPermissionsOnce(ctx context.Context, broker chatBroker, sessionID string) error { + pending, err := broker.Permissions(ctx, sessionID) + if err != nil { + return err + } + for _, request := range pending { + if request.SessionID != sessionID || request.RequestID == "" { + continue + } + h.pushPermission(sessionID, request) + } + return nil +} + +// signalWake nudges a room's turn runner without blocking. The channel is +// buffered, so a signal already pending is enough. +func signalWake(ch chan struct{}) { + select { + case ch <- struct{}{}: + default: + } +} + +// sanitizeChatClientLabel cleans a client-supplied device label for storage and +// echo: control characters are dropped, the length is bounded and a blank label +// becomes the generic fallback, so a transcript can always attribute a message. +func sanitizeChatClientLabel(label string) string { + var b strings.Builder + for _, r := range label { + if r < 0x20 || r == 0x7f { + continue + } + b.WriteRune(r) + } + out := strings.TrimSpace(b.String()) + if len(out) > chatClientLabelMax { + out = strings.TrimSpace(out[:chatClientLabelMax]) + } + if out == "" { + return chatClientLabelFallback + } + return out +} + +// permissionRefusal explains why a second answer to an already-answered request +// is refused, naming the client that won so the operator sees what happened. +func permissionRefusal(prior *chatResolution, requestID string) string { + if prior == nil { + return "permission request " + requestID + " is already resolved" + } + if prior.answered { + return fmt.Sprintf("permission request %s was already answered by %s", requestID, prior.client) + } + return fmt.Sprintf("permission request %s is already being answered by %s", requestID, prior.client) +} diff --git a/internal/server/chat_sessions.go b/internal/server/chat_sessions.go index 4a0d034c..17443cf5 100644 --- a/internal/server/chat_sessions.go +++ b/internal/server/chat_sessions.go @@ -17,15 +17,15 @@ import ( // fixed list bounds. const operatorDirectoryLimit = 8 -// handleChatSessions answers chat_sessions with the operator's own sessions, -// marking any another client currently holds as Busy. The registry is the single -// source of truth for which sessions are listed and for their directory, tag, -// created/recency, so a pipeline stage session (recorded in run_steps, never in -// the operator registry) is always excluded and a session with no recorded tag -// is never listed. FAIL-CLOSED: when no registry is configured the result is -// empty, never the whole endpoint list. broker.Sessions is called at most once -// per request, and the registry once. -func handleChatSessions(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) { +// handleChatSessions answers chat_sessions with the operator's own sessions. The +// registry is the single source of truth for which sessions are listed and for +// their directory, tag, created/recency, so a pipeline stage session (recorded +// in run_steps, never in the operator registry) is always excluded and a session +// with no recorded tag is never listed. FAIL-CLOSED: when no registry is +// configured the result is empty, never the whole endpoint list. broker.Sessions +// is called at most once per request, and the registry once. A session is never +// marked Busy: any number of clients may watch and write one session. +func handleChatSessions(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, write func(protocol.Message) error) { if broker == nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) return @@ -74,7 +74,6 @@ func handleChatSessions(ctx context.Context, request protocol.Message, broker ch session.Tag = operator.Tag session.CreatedAt = operator.CreatedAt session.UpdatedAt = operator.UpdatedAt - session.Busy = hub.busyForOther(operator.ID, clientID) response.ChatSessions = append(response.ChatSessions, session) } _ = write(response) diff --git a/internal/server/chat_stream.go b/internal/server/chat_stream.go index 52d52d43..da9f9cb3 100644 --- a/internal/server/chat_stream.go +++ b/internal/server/chat_stream.go @@ -2,10 +2,7 @@ package server import ( "context" - "errors" - "log" "strings" - "sync" "time" "git.a-wan.net/alan/pipelines/internal/opencode" @@ -14,10 +11,16 @@ import ( // chatPermissionPollInterval is the fixed interval between permission polls: one // GET per poll through the shared Connection bounds, never a busy loop. The first -// poll runs immediately so a request pending when the prompt is sent is surfaced +// poll runs immediately so a request pending when a turn starts is surfaced // without waiting a full interval. const chatPermissionPollInterval = 2 * time.Second +// handleChatPrompt accepts a prompt from any client. It never rejects a prompt +// because another client is watching the session: the client attaches to the +// session's shared room and the prompt either starts a turn or is queued behind +// the one in flight, with the ack saying which. The prompt is echoed live to +// every other client, attributed to the sending device's label, and the turn's +// output is fanned out to all of them. func handleChatPrompt(ctx context.Context, request protocol.Message, broker chatBroker, hub *chatHub, registry operatorRegistry, clientID string, write func(protocol.Message) error) { if broker == nil { _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) @@ -42,170 +45,78 @@ func handleChatPrompt(ctx context.Context, request protocol.Message, broker chat _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat prompt exceeds 64 KiB"}) return } - // Claim the session before subscribing or prompting: a second client must be - // rejected here, before any broker call, so two clients cannot silently write - // the same conversation. The same client may re-prompt its own session. sessionID := prompt.SessionID - if !hub.claim(sessionID, clientID) { - _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " is busy with another client"}) + sub := hub.attach(sessionID, clientID, sanitizeChatClientLabel(prompt.Client), broker, write) + if sub == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + sessionID}) return } - - // Subscribe to the OpenCode firehose before posting the prompt: the stream - // has no replay cursor (research 2.4), so a delta emitted between the POST - // and the subscription would otherwise be lost. Frames that arrive before the - // ack is written are buffered and flushed in order after it. - streamCtx, streamCancel := context.WithCancel(ctx) - attached := make(chan struct{}) - var attachOnce sync.Once - streamResult := make(chan error, 1) - var bufferMu sync.Mutex - buffering := true - var buffered []protocol.ChatEventFrame - go func() { - streamResult <- broker.Stream(streamCtx, sessionID, func() { - attachOnce.Do(func() { close(attached) }) - }, func(frame protocol.ChatEventFrame) error { - bufferMu.Lock() - if buffering { - buffered = append(buffered, frame) - bufferMu.Unlock() - return nil - } - bufferMu.Unlock() - hub.apply(frame) - return write(protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame}) - }) - }() - - select { - case <-attached: - case err := <-streamResult: - streamCancel() - hub.release(sessionID, clientID) - if err != nil && ctx.Err() == nil { - _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat stream: " + err.Error()}) - } - return - case <-ctx.Done(): - streamCancel() - hub.release(sessionID, clientID) + // The user turn every *other* client sees, carrying the sender's label. The + // sender's own client appended it locally, so it is excluded below. + userFrame := protocol.ChatEventFrame{ + SessionID: sessionID, + MessageID: hub.nextUserMessageID(), + Kind: protocol.ChatEventUser, + Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "usr", Text: prompt.Text}, + Client: sub.label, + } + queued, refused := hub.submitPrompt(sessionID, &chatQueuedPrompt{ + text: prompt.Text, + requestID: request.ID, + write: write, + }) + if refused { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "session " + sessionID + " already has the maximum number of prompts queued"}) return } - - if err := broker.Prompt(ctx, sessionID, prompt.Text); err != nil { - streamCancel() - hub.release(sessionID, clientID) - _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: err.Error()}) - return + // Publish the user turn to every other client; the sender already has it. + hub.broadcastUser(userFrame, clientID) + if queued { + // The client that sent it is told the prompt is waiting for the in-flight + // turn, so it shows queued/steering instead of blocking or silently + // dropping the message. The turn runner acknowledges it once it runs, so + // clear the ack on the queued entry to avoid a second ack for the same id. + _ = write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID, ChatQueued: true}) } - // Recency is one UPDATE: it moves the operator session to the front of - // chat_sessions. A session id that is not an operator session updates no row - // and is not an error, so pipeline stage prompts are unaffected. if registry != nil { + // Recency is one UPDATE: it moves the operator session to the front of + // chat_sessions. A session id that is not an operator session updates no + // row and is not an error, so pipeline stage prompts are unaffected. if err := registry.TouchOperatorSession(ctx, sessionID); err != nil { - log.Printf("touch operator session %s: %v", sessionID, err) + // Best-effort; the turn runner also touches on delivery. + _ = err } } - // Acknowledge the accepted prompt with the echoed request id, then stream the - // reply. The prompt is sent exactly once and never re-sent on resume. - if err := write(protocol.Message{Type: protocol.ChatPrompt, ID: request.ID}); err != nil { - streamCancel() - hub.release(sessionID, clientID) +} + +// handleChatSubscribe attaches one connection to a session's shared stream so it +// receives every frame any client's turn produces, its own or another device's. +// It replays the session's still-pending approval requests, if the room holds +// any, so a device that joins late still shows the cards. +func handleChatSubscribe(request protocol.Message, broker chatBroker, hub *chatHub, clientID string, write func(protocol.Message) error) { + // The wire body of chat_subscribe is the chat_subscribe field (the app's + // subscribeRequest and docs/cli.md both use it), not the chat_query body the + // other session-scoped commands carry. + query := request.ChatSubscribe + if query == nil || !opencode.ValidSessionID(query.SessionID) { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "a valid OpenCode session id is required"}) return } - // Flush frames buffered while the prompt was accepted, then resume live - // delivery. Holding bufferMu preserves order: the stream goroutine either - // buffered before this flush or waits and writes after it. - bufferMu.Lock() - buffering = false - pending := buffered - buffered = nil - for _, frame := range pending { - hub.apply(frame) - if err := write(protocol.Message{Type: protocol.ChatEvent, ChatEvent: &frame}); err != nil { - bufferMu.Unlock() - streamCancel() - hub.release(sessionID, clientID) - return - } + if broker == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "chat is not configured on this server"}) + return } - bufferMu.Unlock() - go drainChatStream(ctx, streamResult, streamCancel, hub, sessionID, clientID, write) - // Poll for pending approval requests alongside the event stream, sharing - // streamCtx so the poller stops when the stream ends or the client - // disconnects. The first poll runs immediately. - go pollChatPermissions(streamCtx, broker, hub, sessionID, write) -} - -// pollChatPermissions polls the broker's pending-approval list on a fixed -// interval, sharing the chat subscription's context so it stops on disconnect or -// when the turn's stream ends. The hub dedups the request ids, so each pending -// request is pushed at most once; a poll failure is surfaced once through the -// same write closure instead of staying silent. A backend that does not expose -// the approval surface (opencode.ErrPermissionUnsupported) stops the poller -// quietly, so the documented limitation is not reported as a per-prompt error. -func pollChatPermissions(ctx context.Context, broker chatBroker, hub *chatHub, sessionID string, write func(protocol.Message) error) { - ticker := time.NewTicker(chatPermissionPollInterval) - defer ticker.Stop() - reported := false - for { - if err := pushChatPermissions(ctx, broker, hub, sessionID, write); err != nil { - if ctx.Err() != nil { - return - } - if errors.Is(err, opencode.ErrPermissionUnsupported) { - log.Printf("chat permission poll session=%s: %v", sessionID, err) - return - } - if reported { - log.Printf("chat permission poll session=%s: %v", sessionID, err) - } else { - reported = true - _ = write(protocol.Message{Type: protocol.Error, Error: "chat permission poll: " + err.Error()}) - } - } - select { - case <-ctx.Done(): - return - case <-ticker.C: - } - } -} - -// pushChatPermissions performs one poll and writes a chat_permission frame for -// every newly seen request of the session, through the same connection-scoped -// write closure as the chat stream. It never re-pushes a request id, and releases -// the reservation on a write failure so the frame is not silently dropped. -func pushChatPermissions(ctx context.Context, broker chatBroker, hub *chatHub, sessionID string, write func(protocol.Message) error) error { - pending, err := broker.Permissions(ctx, sessionID) - if err != nil { - return err - } - for _, request := range pending { - if request.SessionID != sessionID || request.RequestID == "" { - continue - } - if !hub.seenPermission(sessionID, request.RequestID) { - continue - } - frame := request - if err := write(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame}); err != nil { - hub.forgetPermission(sessionID, request.RequestID) - return err - } - } - return nil -} - -// drainChatStream reports the terminal error of a chat subscription and releases -// its context and the session claim once the stream has ended, so a later client -// is no longer blocked and nothing leaks. -func drainChatStream(ctx context.Context, result <-chan error, cancel context.CancelFunc, hub *chatHub, sessionID, clientID string, write func(protocol.Message) error) { - defer cancel() - defer hub.release(sessionID, clientID) - if err := <-result; err != nil && ctx.Err() == nil { - log.Printf("chat stream session=%s: %v", sessionID, err) - _ = write(protocol.Message{Type: protocol.Error, Error: "chat stream: " + err.Error()}) + sub := hub.attach(query.SessionID, clientID, "", broker, write) + if sub == nil { + _ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Error: "could not attach to session " + query.SessionID}) + return + } + _ = write(protocol.Message{Type: protocol.ChatSubscribe, ID: request.ID}) + // Replay every still-unresolved approval request the room holds, not only the + // most recent one, so a client that attaches after two requests were raised + // still sees both cards. + for _, pending := range hub.pendingFrames(query.SessionID) { + frame := pending + sub.send(protocol.Message{Type: protocol.ChatPermission, ChatPermission: &frame}) } } diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index 7c11801e..1dd43b36 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -436,10 +436,18 @@ func TestChatMessagesResumesRetainedState(t *testing.T) { if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } - if response.Type != protocol.ChatMessages || response.ID != "r2" || len(response.ChatMessages) != 1 { + if response.Type != protocol.ChatMessages || response.ID != "r2" || len(response.ChatMessages) != 2 { t.Fatalf("resume response = %+v", response) } - message := response.ChatMessages[0] + // The prompt is retained as a user turn and the assistant reply beside it, so + // a reconnecting client re-syncs a conversation that still says who sent + // what. The user turn carries the sending client's label (the generic + // fallback when the prompt did not name one). + user := response.ChatMessages[0] + if user.Role != protocol.ChatRoleUser || len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].Text != "hi" || user.Client != chatClientLabelFallback { + t.Fatalf("resumed user turn = %+v", user) + } + message := response.ChatMessages[1] if message.ID != "msg_1" || message.Role != protocol.ChatRoleAssistant || len(message.Parts) != 2 { t.Fatalf("resumed message = %+v", message) } @@ -1361,88 +1369,6 @@ func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) { } } -// TestChatSessionsBusyRejectsSecondClient is the task evidence for busy state: -// while client A holds ses_1 with a blocking prompt, client B's chat_sessions -// reports ses_1 Busy=true and B's chat_prompt for ses_1 is rejected before any -// broker.Prompt call; after A disconnects the claim is released and a later list -// is no longer busy. -func TestChatSessionsBusyRejectsSecondClient(t *testing.T) { - ctx := context.Background() - store := newOperatorStore(t) - if err := store.RecordOperatorSession(ctx, "ses_1", "/work", "operator chat", protocol.ChatSessionTagOperator); err != nil { - t.Fatal(err) - } - broker := scriptedChat() - broker.block = true - broker.done = make(chan struct{}) - broker.sessions = []protocol.ChatSession{{ID: "ses_1"}} - ctx, _, conns := dialChatConns(t, Options{Chat: broker, OperatorRegistry: store}, 2) - connA, connB := conns[0], conns[1] - - if err := wsjson.Write(ctx, connA, protocol.Message{Type: protocol.ChatPrompt, ID: "a1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { - t.Fatal(err) - } - var ack protocol.Message - if err := wsjson.Read(ctx, connA, &ack); err != nil { - t.Fatal(err) - } - if ack.Type != protocol.ChatPrompt || ack.ID != "a1" { - t.Fatalf("prompt ack = %+v", ack) - } - - if err := wsjson.Write(ctx, connB, protocol.Message{Type: protocol.ChatSessions, ID: "b1"}); err != nil { - t.Fatal(err) - } - var listing protocol.Message - if err := wsjson.Read(ctx, connB, &listing); err != nil { - t.Fatal(err) - } - if listing.Type != protocol.ChatSessions || len(listing.ChatSessions) != 1 || !listing.ChatSessions[0].Busy { - t.Fatalf("held session not marked busy: %+v", listing) - } - - if err := wsjson.Write(ctx, connB, protocol.Message{Type: protocol.ChatPrompt, ID: "b2", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hello"}}); err != nil { - t.Fatal(err) - } - var rejected protocol.Message - if err := wsjson.Read(ctx, connB, &rejected); err != nil { - t.Fatal(err) - } - if rejected.Type != protocol.Error || !strings.Contains(rejected.Error, "busy") { - t.Fatalf("second client's prompt was not rejected as busy: %+v", rejected) - } - if prompts, _, _ := broker.counts(); prompts != 1 { - t.Fatalf("busy prompt reached OpenCode: %d prompt calls, want 1", prompts) - } - - // Disconnecting A releases the claim so a later client is no longer blocked. - if err := connA.Close(websocket.StatusNormalClosure, ""); err != nil { - t.Fatal(err) - } - select { - case <-broker.done: - case <-time.After(5 * time.Second): - t.Fatal("stream did not stop after disconnect") - } - deadline := time.Now().Add(5 * time.Second) - for { - if err := wsjson.Write(ctx, connB, protocol.Message{Type: protocol.ChatSessions, ID: "b3"}); err != nil { - t.Fatal(err) - } - var after protocol.Message - if err := wsjson.Read(ctx, connB, &after); err != nil { - t.Fatal(err) - } - if after.Type == protocol.ChatSessions && len(after.ChatSessions) == 1 && !after.ChatSessions[0].Busy { - return - } - if time.Now().After(deadline) { - t.Fatalf("claim not released after disconnect: %+v", after) - } - time.Sleep(10 * time.Millisecond) - } -} - // TestChatPromptPushesPermissionAndForwardsReply is the task evidence: with a // blocking scripted stream keeping the subscription open, a seeded pending // approval request is pushed as a chat_permission frame carrying the seeded @@ -1522,11 +1448,29 @@ func TestChatPermissionDedupesRepeatedPolls(t *testing.T) { mu.Unlock() return nil } + if sub := hub.attach("ses_1", "c1", "phone", broker, write); sub == nil { + t.Fatal("attach returned nil") + } for i := 0; i < 3; i++ { - if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err != nil { + if err := hub.pollPermissionsOnce(context.Background(), broker, "ses_1"); err != nil { t.Fatal(err) } } + deadline := time.Now().Add(2 * time.Second) + for { + mu.Lock() + count := len(pushed) + mu.Unlock() + if count > 0 { + break + } + if time.Now().After(deadline) { + t.Fatal("no permission frame was pushed") + } + time.Sleep(5 * time.Millisecond) + } + // Give a duplicate a chance to arrive before asserting there is none. + time.Sleep(50 * time.Millisecond) mu.Lock() defer mu.Unlock() if len(pushed) != 1 { @@ -1684,32 +1628,6 @@ func TestChatPermissionUnsupportedBackendIsQuiet(t *testing.T) { } } -// TestChatPermissionWriteFailureDoesNotDropRequest pins that a request id is not -// retained as "seen" when its frame could not be written, so the next poll -// re-pushes it instead of silently dropping the approval request. -func TestChatPermissionWriteFailureDoesNotDropRequest(t *testing.T) { - broker := scriptedChat() - broker.permissions = []protocol.ChatPermissionFrame{{SessionID: "ses_1", RequestID: "req_1", Action: "bash"}} - hub := newChatHub() - attempts := 0 - write := func(protocol.Message) error { - attempts++ - if attempts == 1 { - return fmt.Errorf("connection closed") - } - return nil - } - if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err == nil { - t.Fatal("a failed write must surface an error") - } - if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err != nil { - t.Fatalf("retry after a failed write: %v", err) - } - if attempts != 2 { - t.Fatalf("push attempts = %d, want the request re-pushed after the failure", attempts) - } -} - // TestChatAdoptRecordsEndpointSession is the chat_adopt acceptance test: the // endpoint's own record supplies the directory and title, the handler records // the row with the operator tag, and the response echoes the session and its diff --git a/internal/server/websocket.go b/internal/server/websocket.go index 9d3d076a..8ee03ef2 100644 --- a/internal/server/websocket.go +++ b/internal/server/websocket.go @@ -86,6 +86,8 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin if registry == nil && len(stores) > 0 { registry = stores[0] } + hub.baseCtx = ctx + hub.registry = registry mux.HandleFunc("GET /artifacts/{run}/{step}/{name...}", func(w http.ResponseWriter, r *http.Request) { if runs == nil { http.NotFound(w, r) @@ -139,6 +141,9 @@ func HandlerWithOptions(ctx context.Context, options Options, stores ...*pipelin // Drop every run subscription this connection holds when the read loop // returns, so no subscriber, goroutine or timer outlives the connection. defer events.unsubscribeClient(clientID) + // Drop every chat subscription too, so a chat room held only by this + // connection releases its broker stream and turn runner. + defer hub.detachClient(clientID) if len(stores) > 0 { items, err := stores[0].List(ctx) if err != nil {