Files
pipelines/internal/protocol/chat_test.go
T
alan 971e555ceb chat: close and reopen an operator session on the server, keeping its history
Add a server-side close for operator chats, so finishing with a chat takes it out
of the active list for every client without deleting anything. The brokered
protocol gains chat_close and chat_reopen; chat_close stops a running turn by
reusing the existing broker interrupt (its result carries an interrupted flag, so
a stream is never left running into nothing) and then sets closed_at on the
session's operator_sessions row. The session, its transcript and its history
survive, and because the closed state lives in the registry chat_sessions reports
it to every client, not just the one that asked. An id that is not a recorded
operator session, including a pipeline-owned run session, is refused before
anything is written. chat_reopen clears the state again, and simply prompting a
closed session also clears it (the store clears closed_at on touch).

The registry gains closed_at for a fresh database and an idempotent migration for
one created before it existed. The app renders closed sessions under a labelled
Closed section with a Closed chip, offers a Close action with a confirmation that
says it stops a running turn, marks the chat closed on every device and deletes
nothing, and a Reopen action on each closed row. The device-local hide is renamed
Hide on this device, with a snackbar saying the chat stays on the server, so it is
never confused with the real close. No new dependency, the installer and Docker
files are untouched, and no run is started from the app.

Checked before committing: the packaged templates carry no chat surface and need
no update, and internal/author/install.go's managed inventory needs none either
(this adds no reference file). The packaged authoring skill reference
internal/author/skill/references/operations.md and the shared docs/cli.md and
android/README.md are stale because of this change, but an item no longer edits a
shared document: what is stale and what should change there is recorded in
docs/notes/chat-close.md for the docs-fold writer, which is committed here with
the change.

Checks: gofmt clean, go build ./... and go vet ./... clean, and
go test ./internal/protocol/... ./internal/pipeline/... ./internal/server/...
./internal/author/... pass. The app side is verified with :app:assembleDebug and
:app:testDebugUnitTest (--offline --no-daemon, BUILD SUCCESSFUL); the on-device
close, second-client and reopen check is deferred to visual review.

Not deployed; deploying is the operator's step.
2026-10-18 00:16:24 +01:00

226 lines
9.4 KiB
Go

package protocol
import (
"encoding/json"
"reflect"
"strings"
"testing"
)
// chatSamples covers every new chat type with a populated value, plus a text and
// a tool chat_event, so a round-trip loss in any field fails the test.
func chatSamples() []struct {
name string
value any
} {
return []struct {
name string
value any
}{
{"session", ChatSession{
ID: "ses_1", Title: "demo", Agent: "build", Model: "deepseek-v4.1-flash",
Directory: "/work", ParentID: "ses_0", Tag: ChatSessionTagOperator, CreatedAt: 1792112366711, UpdatedAt: 1792112367999,
}},
{"session_busy", ChatSession{ID: "ses_2", Title: "held", Busy: true}},
{"session_closed", ChatSession{ID: "ses_3", Title: "done", Closed: true, ClosedAt: 1792112367999}},
{"close_result", ChatCloseResult{SessionID: "ses_3", ClosedAt: 1792112367999, Interrupted: true}},
{"create", ChatCreateRequest{Title: "demo", Directory: "/work"}},
{"adopt", ChatAdoptRequest{SessionID: "ses_1"}},
{"query", ChatQuery{SessionID: "ses_1", Limit: 50}},
{"prompt", ChatPromptRequest{SessionID: "ses_1", Text: "hello", Model: "m", Agent: "build", Files: []string{"file:///tmp/a.png"}}},
{"message", ChatMessage{
ID: "msg_1", SessionID: "ses_1", Role: ChatRoleAssistant, Model: "m", Agent: "build", CreatedAt: 1792112366711,
Parts: []ChatPart{
{Type: ChatPartText, ID: "p1", Text: "done"},
{Type: ChatPartReasoning, ID: "p2", Text: "thinking"},
{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
State: &ChatToolState{
Status: ChatToolCompleted,
Input: json.RawMessage(`{"command":"ls"}`),
Content: []ChatToolContent{{Type: "text", Text: "app-debug.apk"}, {Type: "file", URI: "file:///tmp/x.png", Mime: "image/png", Name: "x.png"}},
Metadata: map[string]any{"exit": "0"},
},
Time: &ChatTime{Created: 1, Ran: 2, Completed: 3},
},
{Type: ChatPartTool, ID: "call_2", Name: "edit",
State: &ChatToolState{Status: ChatToolError, Input: json.RawMessage(`{}`), Error: &ChatError{Type: "tool", Message: "boom"}},
},
},
}},
{"event_text", ChatEventFrame{
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventText, Delta: "hel",
Part: &ChatPart{Type: ChatPartText, ID: "p1"},
}},
{"event_tool", ChatEventFrame{
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventTool,
Part: &ChatPart{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
State: &ChatToolState{Status: ChatToolRunning, Input: json.RawMessage(`{"command":"ls"}`)},
},
}},
{"event_step", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventStep, Step: &ChatStep{Status: ChatStepEnded, Index: 2}}},
{"event_usage", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventUsage, Usage: &ChatUsage{InputTokens: 12, OutputTokens: 34, Cost: 0.001}}},
{"permission", ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
Resources: []string{"rm -rf /tmp"}, Save: []string{"bash:rm -rf /tmp"},
Metadata: map[string]any{"command": "rm -rf /tmp"},
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"}},
}
}
func TestChatTypesGoldenRoundTrip(t *testing.T) {
for _, sample := range chatSamples() {
encoded, err := json.Marshal(sample.value)
if err != nil {
t.Fatalf("%s: marshal: %v", sample.name, err)
}
target := reflect.New(reflect.TypeOf(sample.value))
if err := json.Unmarshal(encoded, target.Interface()); err != nil {
t.Fatalf("%s: unmarshal: %v", sample.name, err)
}
decoded := target.Elem().Interface()
if !reflect.DeepEqual(decoded, sample.value) {
t.Fatalf("%s: fields lost\n got %+v\nwant %+v", sample.name, decoded, sample.value)
}
again, err := json.Marshal(decoded)
if err != nil {
t.Fatalf("%s: re-marshal: %v", sample.name, err)
}
if string(again) != string(encoded) {
t.Fatalf("%s: wire shape not stable\n got %s\nwant %s", sample.name, again, encoded)
}
}
}
// TestChatEventGoldenJSON pins the exact wire shape of a pushed frame so a JSON
// tag change cannot silently alter what the phone parses.
func TestChatEventGoldenJSON(t *testing.T) {
event := ChatEventFrame{
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventTool,
Part: &ChatPart{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
State: &ChatToolState{
Status: ChatToolStreaming,
Input: json.RawMessage(`"{\"command\":\"ls\""`),
Content: nil,
},
Time: &ChatTime{Created: 10, Ran: 11, Completed: 12},
},
}
encoded, err := json.Marshal(event)
if err != nil {
t.Fatal(err)
}
want := `{"session_id":"ses_1","message_id":"msg_1","kind":"tool","part":{"type":"tool","id":"call_1","name":"shell","executed":true,"state":{"status":"streaming","input":"{\"command\":\"ls\""},"time":{"created":10,"ran":11,"completed":12}}}`
if string(encoded) != want {
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
}
var decoded ChatEventFrame
if err := json.Unmarshal([]byte(want), &decoded); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(decoded, event) {
t.Fatalf("golden did not decode back: %+v", decoded)
}
}
// TestChatPermissionGoldenJSON pins the exact wire shape of the pushed
// chat_permission frame so a JSON tag change cannot silently alter what the
// phone parses.
func TestChatPermissionGoldenJSON(t *testing.T) {
frame := ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
Resources: []string{"rm -rf /tmp"},
Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"},
}
encoded, err := json.Marshal(frame)
if err != nil {
t.Fatal(err)
}
want := `{"session_id":"ses_1","request_id":"per_1","action":"bash","resources":["rm -rf /tmp"],"source":{"type":"tool","message_id":"msg_1","id":"call_1"}}`
if string(encoded) != want {
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
}
var decoded ChatPermissionFrame
if err := json.Unmarshal([]byte(want), &decoded); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(decoded, frame) {
t.Fatalf("golden did not decode back: %+v", decoded)
}
}
func TestChatEnvelopeRoundTrip(t *testing.T) {
session := ChatSession{ID: "ses_1", Title: "demo"}
message := Message{
Type: ChatSessions, ID: "r1",
ChatSessions: []ChatSession{session},
ChatSession: &session,
ChatCreate: &ChatCreateRequest{Title: "new"},
ChatAdopt: &ChatAdoptRequest{SessionID: "ses_1"},
ChatQuery: &ChatQuery{SessionID: "ses_1", Limit: 10},
ChatPrompt: &ChatPromptRequest{SessionID: "ses_1", Text: "hi"},
ChatMessages: []ChatMessage{{ID: "msg_1", SessionID: "ses_1", Role: ChatRoleUser, Parts: []ChatPart{{Type: ChatPartText, Text: "hi"}}}},
ChatEvent: &ChatEventFrame{SessionID: "ses_1", Kind: ChatEventText, Delta: "hi"},
ChatPermission: &ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash", Resources: []string{"rm -rf /"},
},
ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject},
ChatDirectories: []string{"/home/operator", "/work/project"},
ChatClose: &ChatCloseResult{SessionID: "ses_1", ClosedAt: 1792112367999, Interrupted: true},
}
encoded, err := json.Marshal(message)
if err != nil {
t.Fatal(err)
}
var decoded Message
if err := json.Unmarshal(encoded, &decoded); err != nil {
t.Fatal(err)
}
if decoded.Type != ChatSessions || decoded.ID != "r1" {
t.Fatalf("envelope lost: %+v", decoded)
}
if !reflect.DeepEqual(decoded.ChatSessions, message.ChatSessions) ||
!reflect.DeepEqual(decoded.ChatSession, message.ChatSession) ||
!reflect.DeepEqual(decoded.ChatCreate, message.ChatCreate) ||
!reflect.DeepEqual(decoded.ChatAdopt, message.ChatAdopt) ||
!reflect.DeepEqual(decoded.ChatQuery, message.ChatQuery) ||
!reflect.DeepEqual(decoded.ChatPrompt, message.ChatPrompt) ||
!reflect.DeepEqual(decoded.ChatMessages, message.ChatMessages) ||
!reflect.DeepEqual(decoded.ChatEvent, message.ChatEvent) ||
!reflect.DeepEqual(decoded.ChatPermission, message.ChatPermission) ||
!reflect.DeepEqual(decoded.ChatReply, message.ChatReply) ||
!reflect.DeepEqual(decoded.ChatDirectories, message.ChatDirectories) ||
!reflect.DeepEqual(decoded.ChatClose, message.ChatClose) {
t.Fatalf("chat payloads lost: %+v", decoded)
}
}
func TestChatFieldsOmittedWhenUnused(t *testing.T) {
minimal, err := json.Marshal(Message{Type: List, ID: "r1"})
if err != nil {
t.Fatal(err)
}
for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_adopt", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_permission", "chat_reply", "chat_directories", "chat_close"} {
if strings.Contains(string(minimal), absent) {
t.Fatalf("absent %q must be omitted: %s", absent, minimal)
}
}
}
// TestChatOperatorTagVocabulary pins that the stored tag and the display label
// are one mapping (a wire tag plus a derived label), not a second vocabulary.
func TestChatOperatorTagVocabulary(t *testing.T) {
if ChatSessionTagOperator != "operator" || ChatSessionTagOperatorDisplay != "Operator" {
t.Fatalf("operator tag vocabulary = %q/%q, want operator/Operator", ChatSessionTagOperator, ChatSessionTagOperatorDisplay)
}
encoded, err := json.Marshal(ChatSession{ID: "ses_1", Tag: ChatSessionTagOperator})
if err != nil {
t.Fatal(err)
}
if !strings.Contains(string(encoded), `"tag":"operator"`) {
t.Fatalf("operator tag not on the wire: %s", encoded)
}
}