package server import ( "context" "encoding/json" "fmt" "net/http" "net/http/httptest" "os" "path/filepath" "strings" "sync" "sync/atomic" "testing" "time" "github.com/coder/websocket" "github.com/coder/websocket/wsjson" "git.a-wan.net/alan/pipelines/internal/opencode" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" ) // newOperatorStore opens a scratch store for the operator-session registry, so // the chat tests exercise the real SQL-backed registry (record, list, delete) // rather than a second fake of it. func newOperatorStore(t *testing.T) *pipeline.Store { t.Helper() store, err := pipeline.Open(filepath.Join(t.TempDir(), "operator.db")) if err != nil { t.Fatal(err) } t.Cleanup(func() { store.Close() }) return store } // fakeChat is a scripted chatBroker. It counts calls and either emits a fixed // frame sequence or blocks until the caller's context is canceled. type fakeChat struct { mu sync.Mutex promptCalls int interrupts int replies int replyRequest protocol.ChatReplyRequest replyErr error messageCalls int messageSessionID string messageLimit int messages []protocol.ChatMessage permissionCalls int permissionSessionID string permissions []protocol.ChatPermissionFrame permissionErr error sessionCalls int sessions []protocol.ChatSession sessionErr error permBlock bool permDone chan struct{} permOnce sync.Once script []protocol.ChatEventFrame started chan struct{} done chan struct{} startOnce sync.Once block bool subscribed bool promptBeforeSubscribe bool interruptErr error createCalls int createTitle string createDirectory string created protocol.ChatSession createErr error } func (f *fakeChat) Prompt(context.Context, string, string) error { f.mu.Lock() defer f.mu.Unlock() f.promptCalls++ if !f.subscribed { f.promptBeforeSubscribe = true } return nil } func (f *fakeChat) Stream(ctx context.Context, _ string, ready func(), emit func(protocol.ChatEventFrame) error) error { f.mu.Lock() f.subscribed = true f.mu.Unlock() if ready != nil { ready() } if f.started != nil { f.startOnce.Do(func() { close(f.started) }) } if f.block { <-ctx.Done() if f.done != nil { close(f.done) } return ctx.Err() } for _, frame := range f.script { if err := ctx.Err(); err != nil { return err } if err := emit(frame); err != nil { return err } } return nil } func (f *fakeChat) Interrupt(context.Context, string) error { f.mu.Lock() defer f.mu.Unlock() f.interrupts++ return f.interruptErr } func (f *fakeChat) Messages(_ context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error) { f.mu.Lock() defer f.mu.Unlock() f.messageCalls++ f.messageSessionID = sessionID f.messageLimit = limit return f.messages, nil } // messageQuery reports the recorded chat_messages call count, session id and // limit so a test can assert the handler forwarded the query. func (f *fakeChat) messageQuery() (int, string, int) { f.mu.Lock() defer f.mu.Unlock() return f.messageCalls, f.messageSessionID, f.messageLimit } func (f *fakeChat) Reply(_ context.Context, request protocol.ChatReplyRequest) error { f.mu.Lock() defer f.mu.Unlock() f.replies++ f.replyRequest = request return f.replyErr } // Permissions returns the seeded pending requests, or blocks until the caller's // context is canceled when permBlock is set (used to prove the poller stops on // disconnect). Every call is counted so a test can assert polling happened. func (f *fakeChat) Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error) { f.mu.Lock() f.permissionCalls++ f.permissionSessionID = sessionID frames := append([]protocol.ChatPermissionFrame(nil), f.permissions...) err := f.permissionErr block := f.permBlock done := f.permDone f.mu.Unlock() if block { <-ctx.Done() if done != nil { f.permOnce.Do(func() { close(done) }) } return nil, ctx.Err() } return frames, err } // permissionQuery reports the recorded permission poll count and session id. func (f *fakeChat) permissionQuery() (int, string) { f.mu.Lock() defer f.mu.Unlock() return f.permissionCalls, f.permissionSessionID } // Sessions returns the seeded session list and counts each call so a test can // assert the list handler asks the broker at most once per request. func (f *fakeChat) Sessions(context.Context) ([]protocol.ChatSession, error) { f.mu.Lock() defer f.mu.Unlock() f.sessionCalls++ return f.sessions, f.sessionErr } // sessionQuery reports the recorded chat_sessions call count. func (f *fakeChat) sessionQuery() int { f.mu.Lock() defer f.mu.Unlock() return f.sessionCalls } // Create records the title and directory the handler forwarded and returns the // seeded created session. A blank created id defaults to "ses_created" so a test // only asserts what it cares about. func (f *fakeChat) Create(_ context.Context, title, directory string) (protocol.ChatSession, error) { f.mu.Lock() defer f.mu.Unlock() f.createCalls++ f.createTitle = title f.createDirectory = directory if f.createErr != nil { return protocol.ChatSession{}, f.createErr } session := f.created if session.ID == "" { session.ID = "ses_created" } return session, nil } // createQuery reports the recorded chat_create call count, title and directory. func (f *fakeChat) createQuery() (int, string, string) { f.mu.Lock() defer f.mu.Unlock() return f.createCalls, f.createTitle, f.createDirectory } // replyQuery reports the recorded chat_reply count and the last forwarded // request, so a test can assert the exact session/request/decision. func (f *fakeChat) replyQuery() (int, protocol.ChatReplyRequest) { f.mu.Lock() defer f.mu.Unlock() return f.replies, f.replyRequest } func (f *fakeChat) counts() (int, int, int) { f.mu.Lock() defer f.mu.Unlock() return f.promptCalls, f.interrupts, f.replies } func chatFrame(kind, delta string, part *protocol.ChatPart, step *protocol.ChatStep) protocol.ChatEventFrame { return protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: kind, Delta: delta, Part: part, Step: step} } func scriptedChat() *fakeChat { return &fakeChat{script: []protocol.ChatEventFrame{ chatFrame(protocol.ChatEventText, "hello ", &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}, nil), chatFrame(protocol.ChatEventText, "world", &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}, nil), chatFrame(protocol.ChatEventTool, "", &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: []byte(`{"command":"ls"}`)}}, nil), chatFrame(protocol.ChatEventStep, "", nil, &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}), }} } func dialChat(t *testing.T, broker chatBroker) (context.Context, context.CancelFunc, *websocket.Conn) { t.Helper() return dialChatOptions(t, Options{Chat: broker}) } func dialChatOptions(t *testing.T, options Options) (context.Context, context.CancelFunc, *websocket.Conn) { t.Helper() ctx, cancel, conns := dialChatConns(t, options, 1) return ctx, cancel, conns[0] } // dialChatConns starts one server and dials n connections to the same hub, so a // test can exercise two clients contending for one session. func dialChatConns(t *testing.T, options Options, n int) (context.Context, context.CancelFunc, []*websocket.Conn) { t.Helper() ctx, cancel := context.WithTimeout(context.Background(), 10*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++ { conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil) if err != nil { t.Fatal(err) } t.Cleanup(func() { conn.CloseNow() }) conns = append(conns, conn) } return ctx, cancel, conns } func readChatTurn(t *testing.T, ctx context.Context, conn *websocket.Conn) []protocol.ChatEventFrame { t.Helper() var frames []protocol.ChatEventFrame for { var message protocol.Message if err := wsjson.Read(ctx, conn, &message); err != nil { t.Fatal(err) } if message.Type == protocol.Error { t.Fatalf("unexpected error frame: %s", message.Error) } if message.ChatEvent == nil { continue } frames = append(frames, *message.ChatEvent) if message.ChatEvent.Kind == protocol.ChatEventStep && message.ChatEvent.Step != nil && message.ChatEvent.Step.Status == protocol.ChatStepEnded { return frames } } } func TestChatPromptStreamsEvents(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("ack = %+v", ack) } frames := readChatTurn(t, ctx, conn) if len(frames) != 4 { t.Fatalf("got %d frames, want 4", len(frames)) } sawText, sawStep := false, false for _, frame := range frames { if frame.SessionID != "ses_1" || frame.MessageID != "msg_1" { t.Fatalf("frame missing stable ids: %+v", frame) } switch frame.Kind { case protocol.ChatEventText: sawText = true case protocol.ChatEventStep: sawStep = true if frame.Step == nil || frame.Step.Status != protocol.ChatStepEnded { t.Fatalf("step frame = %+v", frame) } } } if !sawText || !sawStep { t.Fatalf("missing text or step frame: %+v", frames) } if prompts, _, _ := broker.counts(); prompts != 1 { t.Fatalf("prompt forwarded %d times, want 1", prompts) } } func TestChatPromptRejectsInvalidSession(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) for _, id := range []string{"", "not-a-session", "msg_1"} { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "bad", ChatPrompt: &protocol.ChatPromptRequest{SessionID: id, Text: "hi"}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { t.Fatalf("session %q not rejected: %+v", id, response) } } if prompts, _, _ := broker.counts(); prompts != 0 { t.Fatalf("invalid sessions reached OpenCode: %d", prompts) } } func TestChatPromptRejectsOversizedText(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) oversized := strings.Repeat("x", opencode.MaxRequest+1) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "big", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: oversized}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "64 KiB") { t.Fatalf("oversized prompt not rejected: %+v", response) } if prompts, _, _ := broker.counts(); prompts != 0 { t.Fatalf("oversized prompt reached OpenCode: %d", prompts) } } func TestChatPromptWithoutBroker(t *testing.T) { ctx, _, conn := dialChat(t, nil) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { t.Fatalf("unconfigured chat not rejected: %+v", response) } } func TestChatMessagesResumesRetainedState(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } readChatTurn(t, ctx, conn) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatMessages || response.ID != "r2" || len(response.ChatMessages) != 1 { t.Fatalf("resume response = %+v", response) } message := response.ChatMessages[0] if message.ID != "msg_1" || message.Role != protocol.ChatRoleAssistant || len(message.Parts) != 2 { t.Fatalf("resumed message = %+v", message) } if message.Parts[0].Type != protocol.ChatPartText || message.Parts[0].ID != "msg_1#0" || message.Parts[0].Text != "hello world" { t.Fatalf("resumed text part = %+v", message.Parts[0]) } if message.Parts[1].Type != protocol.ChatPartTool || message.Parts[1].State == nil || message.Parts[1].State.Status != protocol.ChatToolCompleted { t.Fatalf("resumed tool part = %+v", message.Parts[1]) } } // seededChatMessages is the stored user + assistant + tool session the // chat_messages evidence tests assert on, mirroring the OpenCode V2 shape of an // assistant turn's completed tool part (input object, text content, status). func seededChatMessages() []protocol.ChatMessage { return []protocol.ChatMessage{ {ID: "msg_user", SessionID: "ses_1", Role: protocol.ChatRoleUser, Parts: []protocol.ChatPart{{Type: protocol.ChatPartText, Text: "list the files"}}}, {ID: "msg_assistant", SessionID: "ses_1", Role: protocol.ChatRoleAssistant, Model: "deepseek-v4.1-flash", Agent: "build", Parts: []protocol.ChatPart{ {Type: protocol.ChatPartText, ID: "p1", Text: "here you go"}, {Type: protocol.ChatPartReasoning, ID: "p2", Text: "thinking"}, {Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", Executed: true, State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: json.RawMessage(`{"command":"ls"}`), Content: []protocol.ChatToolContent{{Type: "text", Text: "ok"}}}, Time: &protocol.ChatTime{Created: 1, Ran: 2, Completed: 3}}, }}, } } // assertSeededChatMessages fails unless the user + assistant + tool session came // back with both roles and the completed tool part's input, content and status. func assertSeededChatMessages(t *testing.T, messages []protocol.ChatMessage) { t.Helper() if len(messages) != 2 { t.Fatalf("got %d messages, want user+assistant: %+v", len(messages), messages) } user, assistant := messages[0], messages[1] if user.ID != "msg_user" || user.Role != protocol.ChatRoleUser || len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].Text != "list the files" { t.Fatalf("user turn = %+v", user) } if assistant.ID != "msg_assistant" || assistant.Role != protocol.ChatRoleAssistant || len(assistant.Parts) != 3 { t.Fatalf("assistant turn = %+v", assistant) } if p := assistant.Parts[0]; p.Type != protocol.ChatPartText || p.Text != "here you go" { t.Fatalf("assistant text part = %+v", p) } tool := assistant.Parts[2] if tool.Type != protocol.ChatPartTool || tool.ID != "call_1" || tool.Name != "shell" || tool.State == nil || tool.State.Status != protocol.ChatToolCompleted { t.Fatalf("assistant tool part = %+v", tool) } var input struct { Command string `json:"command"` } if err := json.Unmarshal(tool.State.Input, &input); err != nil || input.Command != "ls" { t.Fatalf("tool input = %s (err %v)", tool.State.Input, err) } if len(tool.State.Content) != 1 || tool.State.Content[0].Text != "ok" { t.Fatalf("tool content = %+v", tool.State.Content) } } // TestChatMessagesReturnsBrokerHistory drives chat_messages through the handler // with an empty hub, so it must fall through to broker.Messages and return the // seeded user + assistant + tool session, forwarding the query limit unchanged. func TestChatMessagesReturnsBrokerHistory(t *testing.T) { broker := scriptedChat() broker.messages = seededChatMessages() ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1", Limit: 7}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatMessages || response.ID != "r2" { t.Fatalf("response = %+v", response) } assertSeededChatMessages(t, response.ChatMessages) if calls, sessionID, limit := broker.messageQuery(); calls != 1 || sessionID != "ses_1" || limit != 7 { t.Fatalf("broker query = %d/%q/%d, want 1/ses_1/7", calls, sessionID, limit) } } // TestChatMessagesThroughRealAdapter loads a seeded session through the real // opencode.Chat broker: the chat_messages handler reads the V2 // GET /api/session/{id}/message fixture once and returns the user + assistant + // tool turns decoded from it, exercising the full handler -> adapter -> decode // path with no scripted broker. func TestChatMessagesThroughRealAdapter(t *testing.T) { var messageReads atomic.Int32 fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodGet || r.URL.Path != "/api/session/ses_1/message" { t.Errorf("unexpected request %s %s", r.Method, r.URL.Path) return } messageReads.Add(1) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":[ {"id":"msg_user","time":{"created":10},"type":"user","text":"list the files"}, {"id":"msg_assistant","time":{"created":20,"completed":30},"type":"assistant","agent":"build","model":{"id":"deepseek-v4.1-flash","providerID":"opencode-go"},"content":[ {"type":"text","text":"here you go"}, {"type":"reasoning","text":"thinking"}, {"type":"tool","id":"call_1","name":"shell","executed":true,"state":{"status":"completed","input":{"command":"ls"},"content":[{"type":"text","text":"ok"}]},"time":{"created":1,"ran":2,"completed":3}} ]} ],"cursor":{"next":null}}`)) })) defer fixture.Close() broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL}) ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatMessages || response.ID != "r2" { t.Fatalf("response = %+v", response) } assertSeededChatMessages(t, response.ChatMessages) if messageReads.Load() != 1 { t.Fatalf("message endpoint read %d times, want 1", messageReads.Load()) } } // TestChatMessagesRejectsInvalidSession pins that a missing or malformed session // id is rejected before any broker call. func TestChatMessagesRejectsInvalidSession(t *testing.T) { broker := scriptedChat() broker.messages = seededChatMessages() ctx, _, conn := dialChat(t, broker) for _, query := range []*protocol.ChatQuery{nil, {SessionID: ""}, {SessionID: "not-a-session"}} { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "bad", ChatQuery: query}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { t.Fatalf("query %+v not rejected: %+v", query, response) } } if calls, _, _ := broker.messageQuery(); calls != 0 { t.Fatalf("invalid chat_messages reached the broker: %d", calls) } } func TestChatDisconnectCancelsStream(t *testing.T) { broker := scriptedChat() broker.block = true broker.started = make(chan struct{}) broker.done = make(chan struct{}) ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } select { case <-broker.started: case <-time.After(2 * time.Second): t.Fatal("stream never started") } conn.CloseNow() // The server's read loop returns on disconnect, canceling the connection // context the subscription observes; no goroutine may keep running. select { case <-broker.done: case <-time.After(3 * time.Second): t.Fatal("chat stream was not canceled on disconnect") } if prompts, _, _ := broker.counts(); prompts != 1 { t.Fatalf("prompt forwarded %d times, want 1", prompts) } } func TestChatInterruptAndReply(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatInterrupt || response.ID != "i1" { t.Fatalf("interrupt response = %+v", response) } if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil { t.Fatal(err) } if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatReply || response.ID != "p1" { t.Fatalf("reply response = %+v", response) } if _, interrupts, replies := broker.counts(); interrupts != 1 || replies != 1 { t.Fatalf("interrupts=%d replies=%d, want 1/1", interrupts, replies) } } // TestChatInterruptEndsRunningPrompt is the task evidence: it starts a // long-running turn through the real opencode.Chat adapter over an httptest SSE // fixture, sends chat_interrupt, and asserts the run ends. The fixture records // the actual POST /api/session/ses_1/interrupt and only closes the SSE // subscription once that request arrives, so the run genuinely terminates rather // than completing on its own. func TestChatInterruptEndsRunningPrompt(t *testing.T) { var ( mu sync.Mutex prompts int interrupts int interruptPath string ) interrupted := make(chan struct{}) var interruptOnce sync.Once fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch { case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/prompt": mu.Lock() prompts++ mu.Unlock() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":{"id":"msg_1","sessionID":"ses_1","type":"user"}}`)) case r.Method == http.MethodGet && r.URL.Path == "/api/permission/request": w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[]}`)) case r.Method == http.MethodGet && r.URL.Path == "/api/event": flusher, ok := w.(http.Flusher) if !ok { t.Errorf("event stream response is not flushable") return } w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: " + `{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"working"}}` + "\n\n")) flusher.Flush() // Hold the turn open until the interrupt arrives so the test exercises // a running run, not a stream that already completed. select { case <-interrupted: case <-r.Context().Done(): return } _, _ = w.Write([]byte("data: " + `{"id":"evt_2","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}` + "\n\n")) flusher.Flush() case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/interrupt": mu.Lock() interrupts++ interruptPath = r.URL.Path mu.Unlock() interruptOnce.Do(func() { close(interrupted) }) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{}`)) default: t.Errorf("unexpected request %s %s", r.Method, r.URL.Path) } })) defer fixture.Close() broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL}) ctx, _, conn := dialChat(t, broker) // Start a long-running turn. if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "start a long-running task"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("prompt ack = %+v", ack) } // The first text delta proves the turn is live and the subscription attached. var first protocol.Message if err := wsjson.Read(ctx, conn, &first); err != nil { t.Fatal(err) } if first.Type != protocol.ChatEvent || first.ChatEvent == nil || first.ChatEvent.Kind != protocol.ChatEventText || first.ChatEvent.Delta != "working" { t.Fatalf("expected a live text delta, got %+v", first) } // Stop the running turn. if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } // Read until both the interrupt ack and the step.ended frame arrive, in // whichever order the server emits them; any error frame fails the test. var acked, ended bool for !acked || !ended { var message protocol.Message if err := wsjson.Read(ctx, conn, &message); err != nil { t.Fatal(err) } if message.Type == protocol.Error { t.Fatalf("unexpected error frame: %s", message.Error) } if message.Type == protocol.ChatInterrupt { if message.ID != "i1" { t.Fatalf("interrupt ack id = %q, want i1", message.ID) } acked = true } if event := message.ChatEvent; event != nil && event.SessionID == "ses_1" && event.Kind == protocol.ChatEventStep && event.Step != nil && event.Step.Status == protocol.ChatStepEnded { ended = true } } mu.Lock() gotPrompts, gotInterrupts, gotPath := prompts, interrupts, interruptPath mu.Unlock() if gotPrompts != 1 { t.Fatalf("prompt posts = %d, want 1", gotPrompts) } if gotInterrupts != 1 { t.Fatalf("interrupt posts = %d, want 1", gotInterrupts) } if gotPath != "/api/session/ses_1/interrupt" { t.Fatalf("interrupt path = %q, want /api/session/ses_1/interrupt", gotPath) } } // TestChatInterruptRejectsInvalidSession pins that a missing, empty or malformed // session id is rejected with a protocol.Error before any broker call. func TestChatInterruptRejectsInvalidSession(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) for _, query := range []*protocol.ChatQuery{nil, {}, {SessionID: "not-a-session"}} { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "bad", ChatQuery: query}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { t.Fatalf("query %+v not rejected: %+v", query, response) } } if _, interrupts, _ := broker.counts(); interrupts != 0 { t.Fatalf("invalid interrupts reached the broker: %d", interrupts) } } // TestChatInterruptWithoutBroker pins that an unconfigured server answers // chat_interrupt with the existing "not configured" error. func TestChatInterruptWithoutBroker(t *testing.T) { ctx, _, conn := dialChat(t, nil) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { t.Fatalf("unconfigured interrupt not rejected: %+v", response) } } // TestChatInterruptErrorReported pins that a broker failure is surfaced to the // client as a protocol.Error frame carrying the echoed request id. func TestChatInterruptErrorReported(t *testing.T) { broker := scriptedChat() broker.interruptErr = fmt.Errorf("run is already finished") ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "i1" || !strings.Contains(response.Error, "already finished") { t.Fatalf("interrupt failure not reported: %+v", response) } if _, interrupts, _ := broker.counts(); interrupts != 1 { t.Fatalf("interrupts = %d, want 1", interrupts) } } func TestChatHubAccumulatesAndEvicts(t *testing.T) { tick := 0 hub := newChatHub() hub.now = func() time.Time { tick++; return time.Unix(int64(tick), 0) } for _, delta := range []string{"a", "b", "c"} { hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: delta, Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) } messages := hub.snapshot("ses_1") if len(messages) != 1 || len(messages[0].Parts) != 1 || messages[0].Parts[0].Text != "abc" { t.Fatalf("snapshot = %+v", messages) } for i := 0; i < chatMaxTurns+5; i++ { id := fmt.Sprintf("ses_%d", i) hub.apply(protocol.ChatEventFrame{SessionID: id, MessageID: "m", Kind: protocol.ChatEventText, Delta: "x", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: id + "#0"}}) } if len(hub.turns) != chatMaxTurns { t.Fatalf("retained %d turns, want %d", len(hub.turns), chatMaxTurns) } } // TestChatHubKeepsMessagesSeparate pins per-message retention: a second prompt // in one session must not fold its parts onto the first turn's message id. func TestChatHubKeepsMessagesSeparate(t *testing.T) { hub := newChatHub() hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: "one", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}}) hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_2", Kind: protocol.ChatEventText, Delta: "two", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_2#0"}}) messages := hub.snapshot("ses_1") if len(messages) != 2 { t.Fatalf("messages = %+v", messages) } if messages[0].ID != "msg_1" || messages[0].Parts[0].ID != "msg_1#0" || messages[0].Parts[0].Text != "one" { t.Fatalf("first message = %+v", messages[0]) } if messages[1].ID != "msg_2" || messages[1].Parts[0].ID != "msg_2#0" || messages[1].Parts[0].Text != "two" { t.Fatalf("second message = %+v", messages[1]) } } // TestChatHubChargesToolStateBytes pins the retained-state cap: a tool part's // input/content bytes count against it, and an upsert that would exceed the cap // is dropped with the overflow diagnostic rather than growing memory. func TestChatHubChargesToolStateBytes(t *testing.T) { hub := newChatHub() big := strings.Repeat("x", chatRetainedLimit/2) hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolStreaming, Input: json.RawMessage(`"` + big + `"`)}}}) hub.mu.Lock() size := hub.turns["ses_1"].size hub.mu.Unlock() if size < len(big) { t.Fatalf("tool input not charged: size=%d want >= %d", size, len(big)) } huge := strings.Repeat("y", chatRetainedLimit) hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: json.RawMessage(`"` + huge + `"`)}}}) messages := hub.snapshot("ses_1") if len(messages) != 1 || len(messages[0].Parts) != 1 || messages[0].Parts[0].State == nil || messages[0].Parts[0].State.Status != protocol.ChatToolStreaming { t.Fatalf("overflowing tool state was retained: %+v", messages) } } // TestChatPromptSubscribesBeforePrompt pins the subscribe-before-prompt order: // the firehose has no replay cursor, so the subscription must be attached before // the prompt is posted or deltas emitted in between are lost. func TestChatPromptSubscribesBeforePrompt(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } readChatTurn(t, ctx, conn) broker.mu.Lock() before := broker.promptBeforeSubscribe broker.mu.Unlock() if before { t.Fatal("prompt was posted before the event subscription was attached") } } // realAdapterChat posts a chat_prompt through the real opencode.Chat broker and // HandlerWithOptions against a v2 HTTP fixture that replays frames, so the // acceptance path forwards to an actual OpenCode-shaped stream (not a scripted // fake) and returns the chat_event frames the server pushed. It pins exactly one // prompt POST and one event subscription per chat_prompt, then asserts the ack // echoes the request id; callers assert the frames themselves. func realAdapterChat(t *testing.T, frames []string) []protocol.ChatEventFrame { t.Helper() var prompts, streams atomic.Int32 fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { switch { case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/prompt": prompts.Add(1) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"data":{"id":"msg_1","sessionID":"ses_1","type":"user"}}`)) case r.Method == http.MethodGet && r.URL.Path == "/api/permission/request": w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[]}`)) case r.Method == http.MethodGet && r.URL.Path == "/api/event": streams.Add(1) w.Header().Set("Content-Type", "text/event-stream") for _, frame := range frames { _, _ = w.Write([]byte("data: " + frame + "\n\n")) } default: t.Errorf("unexpected request %s %s", r.Method, r.URL.Path) } })) defer fixture.Close() broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL}) ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "ping"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("ack = %+v", ack) } framesIn := readChatTurn(t, ctx, conn) if prompts.Load() != 1 || streams.Load() != 1 { t.Fatalf("prompts=%d streams=%d, want 1/1", prompts.Load(), streams.Load()) } return framesIn } // assertStableFrameIDs fails unless every frame carries the fixture's session // and message ids: a client cannot attribute a frame without them. func assertStableFrameIDs(t *testing.T, frames []protocol.ChatEventFrame) { t.Helper() for _, frame := range frames { if frame.SessionID != "ses_1" || frame.MessageID != "msg_1" { t.Fatalf("frame missing stable ids: %+v", frame) } } } // TestChatPromptThroughRealAdapter drives a text, tool and step turn end to end. func TestChatPromptThroughRealAdapter(t *testing.T) { framesIn := realAdapterChat(t, []string{ `{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"pong"}}`, `{"id":"evt_2","type":"session.tool.called","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","input":{"command":"ls"}}}`, `{"id":"evt_3","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}`, }) assertStableFrameIDs(t, framesIn) sawText, sawTool := false, false for _, frame := range framesIn { if frame.Kind == protocol.ChatEventText && frame.Delta == "pong" { sawText = true } if frame.Kind == protocol.ChatEventTool && frame.Part != nil && frame.Part.Name == "shell" { sawTool = true } } if !sawText || !sawTool { t.Fatalf("missing text or tool frame: %+v", framesIn) } } // TestChatPromptNoToolThroughRealAdapter is the task's evidence harness: it posts // a trivial no-tool prompt to the real opencode.Chat adapter over a v2 SSE // fixture that emits only a text delta and a step, and asserts both arrive as // chat_event frames with stable session/message ids. It reuses dialChat, // readChatTurn and realAdapterChat so it pins the same ack/stream contract as the // other chat tests, and it pins exactly one prompt POST and one event subscription. func TestChatPromptNoToolThroughRealAdapter(t *testing.T) { framesIn := realAdapterChat(t, []string{ `{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"pong"}}`, `{"id":"evt_2","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}`, }) assertStableFrameIDs(t, framesIn) sawText, sawStep, sawTool := false, false, false for _, frame := range framesIn { switch frame.Kind { case protocol.ChatEventText: sawText = frame.Delta == "pong" case protocol.ChatEventStep: sawStep = frame.Step != nil && frame.Step.Status == protocol.ChatStepEnded case protocol.ChatEventTool: sawTool = true } } if !sawText || !sawStep { t.Fatalf("missing text or step frame: %+v", framesIn) } if sawTool { t.Fatalf("a trivial no-tool prompt produced a tool frame: %+v", framesIn) } } // TestChatPromptRejectsEmptyText pins the whitespace guard: an empty or // whitespace-only prompt is rejected before any OpenCode call. func TestChatPromptRejectsEmptyText(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) for _, text := range []string{"", " ", "\t\n"} { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "empty", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: text}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "empty" { t.Fatalf("empty text %q not rejected: %+v", text, response) } } if prompts, _, _ := broker.counts(); prompts != 0 { t.Fatalf("empty prompts reached OpenCode: %d", prompts) } } // TestChatCreateRecordsOperatorSession is the chat_create acceptance test: the // broker creates the session in the resolved directory, the handler records it in // the operator registry with the operator tag, and the response carries the // created session and the registry row (directory, tag). The registry can then // list it. func TestChatCreateRecordsOperatorSession(t *testing.T) { store := newOperatorStore(t) broker := scriptedChat() broker.created = protocol.ChatSession{ID: "ses_new", Title: "demo"} dir := t.TempDir() ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatCreate, ID: "c1", ChatCreate: &protocol.ChatCreateRequest{Title: "demo", Directory: dir}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatCreate || response.ID != "c1" || response.ChatSession == nil { t.Fatalf("chat_create response = %+v", response) } if response.ChatSession.ID != "ses_new" || response.ChatSession.Directory != dir || response.ChatSession.Tag != protocol.ChatSessionTagOperator { t.Fatalf("created session = %+v", response.ChatSession) } if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_new" || response.ChatSessions[0].Tag != protocol.ChatSessionTagOperator { t.Fatalf("created session not echoed as a registry row: %+v", response.ChatSessions) } if calls, title, directory := broker.createQuery(); calls != 1 || title != "demo" || directory != dir { t.Fatalf("broker.Create = %d/%q/%q, want 1/demo/%q", calls, title, directory, dir) } recorded, err := store.OperatorSessions(ctx) if err != nil { t.Fatal(err) } if len(recorded) != 1 || recorded[0].ID != "ses_new" || recorded[0].Directory != dir || recorded[0].Tag != protocol.ChatSessionTagOperator || recorded[0].Title != "demo" { t.Fatalf("registry row = %+v", recorded) } } // TestChatCreateDirectoryResolution pins directory defaulting and rejection: an // omitted/empty/"~"/"~/..." directory resolves to the operator's home (never the // server's working directory), an explicit existing directory is recorded // unchanged, and a relative or missing directory is rejected before any OpenCode // call. func TestChatCreateDirectoryResolution(t *testing.T) { home, err := os.UserHomeDir() if err != nil { t.Fatal(err) } explicit := t.TempDir() cases := []struct { name string omitted bool directory string wantDirectory string wantErr string }{ {name: "omitted", omitted: true, wantDirectory: home}, {name: "empty", directory: "", wantDirectory: home}, {name: "tilde", directory: "~", wantDirectory: home}, {name: "tilde path", directory: "~/project", wantDirectory: home}, {name: "explicit", directory: explicit, wantDirectory: explicit}, {name: "relative", directory: "relative/dir", wantErr: "absolute"}, {name: "missing", directory: filepath.Join(t.TempDir(), "missing"), wantErr: "not available"}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { store := newOperatorStore(t) broker := scriptedChat() ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) request := protocol.Message{Type: protocol.ChatCreate, ID: "c1"} if !tc.omitted { request.ChatCreate = &protocol.ChatCreateRequest{Title: "demo", Directory: tc.directory} } if err := wsjson.Write(ctx, conn, request); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if tc.wantErr != "" { if response.Type != protocol.Error || !strings.Contains(response.Error, tc.wantErr) { t.Fatalf("directory %q not rejected: %+v", tc.directory, response) } if calls, _, _ := broker.createQuery(); calls != 0 { t.Fatalf("rejected directory still reached OpenCode: %d calls", calls) } if recorded, err := store.OperatorSessions(ctx); err != nil || len(recorded) != 0 { t.Fatalf("rejected directory recorded a session: %+v %v", recorded, err) } return } if response.Type != protocol.ChatCreate || response.ChatSession == nil || response.ChatSession.Directory != tc.wantDirectory { t.Fatalf("directory %q resolved wrong: %+v", tc.directory, response) } if calls, _, directory := broker.createQuery(); calls != 1 || directory != tc.wantDirectory { t.Fatalf("broker.Create = %d/%q, want 1/%q", calls, directory, tc.wantDirectory) } }) } } // TestChatDirectoriesHomeThenBoundedRecents pins chat_directories: the operator's // home first, then the directories of previous operator sessions // most-recently-used first, deduplicated and capped at the fixed bound even with // more directory history seeded than the cap. func TestChatDirectoriesHomeThenBoundedRecents(t *testing.T) { home, err := os.UserHomeDir() if err != nil { t.Fatal(err) } store := newOperatorStore(t) ctx, _, conn := dialChatOptions(t, Options{OperatorRegistry: store}) // Seed more directories than the bound, oldest first. seeded := make([]string, 0, operatorDirectoryLimit+4) for i := 0; i < operatorDirectoryLimit+4; i++ { directory := filepath.Join(t.TempDir(), fmt.Sprintf("d%02d", i)) seeded = append(seeded, directory) if err := store.RecordOperatorSession(ctx, fmt.Sprintf("ses_%02d", i), directory, "s", protocol.ChatSessionTagOperator); err != nil { t.Fatal(err) } time.Sleep(2 * time.Millisecond) } if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatDirectories, ID: "d1"}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatDirectories || response.ID != "d1" { t.Fatalf("chat_directories response = %+v", response) } if len(response.ChatDirectories) != operatorDirectoryLimit { t.Fatalf("directories = %+v, want the bound of %d", response.ChatDirectories, operatorDirectoryLimit) } if response.ChatDirectories[0] != home { t.Fatalf("home not first: %+v", response.ChatDirectories) } // The remainder are the most recently recorded directories, MRU first. for i := 1; i < len(response.ChatDirectories); i++ { want := seeded[len(seeded)-i] if response.ChatDirectories[i] != want { t.Fatalf("directory %d = %q, want %q (MRU order): %+v", i, response.ChatDirectories[i], want, response.ChatDirectories) } } } // TestChatSessionsListsOperatorSessionsOnly is the task evidence for the // operator-session filter: the broker lists an operator-registered session, a // genuine pipeline stage session recorded in run_steps/run_session_owners, and a // foreign session; chat_sessions returns exactly the operator session, carrying // its registry directory and operator tag, and asks the broker once. The stage // session is proven to be genuinely recorded through store.OwnedSessions. func TestChatSessionsListsOperatorSessionsOnly(t *testing.T) { ctx := context.Background() store := newOperatorStore(t) if err := store.RecordOperatorSession(ctx, "ses_op", "/work/op", "Operator chat", protocol.ChatSessionTagOperator); err != nil { t.Fatal(err) } if _, err := store.Submit(ctx, "chatsrv", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } items, err := store.List(ctx) if err != nil { t.Fatal(err) } definition, err := store.Get(ctx, items[0].ID, 1) if err != nil { t.Fatal(err) } run, _, err := store.CreateRun(ctx, definition, "stage-run", "/work/stage", false, nil, map[string]any{"prompt": "task"}) if err != nil { t.Fatal(err) } if err := store.BeginStep(ctx, run, 1, "one", map[string]any{"prompt": "task"}); err != nil { t.Fatal(err) } if err := store.RunSession(ctx, run, 1, "ses_stage", true, "v2", "/work/stage"); err != nil { t.Fatal(err) } // Prove ses_stage is a real owned pipeline session, so its exclusion is the // operator filter at work, not an unrecorded id. owned, err := store.OwnedSessions(ctx) if err != nil { t.Fatal(err) } sawStage := false for _, owner := range owned { if owner.ID == "ses_stage" { sawStage = true } if owner.ID == "ses_op" { t.Fatalf("operator session leaked into pipeline ownership: %+v", owner) } } if !sawStage { t.Fatalf("stage session was not recorded in run_steps: %+v", owned) } broker := scriptedChat() broker.sessions = []protocol.ChatSession{ {ID: "ses_op", Title: "upstream", Directory: "/upstream"}, {ID: "ses_stage", Title: "pipeline internal", Directory: "/work/stage"}, {ID: "ses_foreign", Title: "someone else's", Directory: "/elsewhere"}, } _, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatSessions || response.ID != "s1" { t.Fatalf("chat_sessions response = %+v", response) } if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_op" { t.Fatalf("non-operator session leaked into the list: %+v", response.ChatSessions) } got := response.ChatSessions[0] if got.Directory != "/work/op" || got.Tag != protocol.ChatSessionTagOperator { t.Fatalf("operator session shape = %+v", got) } if got.Busy { t.Fatalf("inactive operator session marked busy: %+v", got) } if calls := broker.sessionQuery(); calls != 1 { t.Fatalf("broker.Sessions called %d times, want 1", calls) } } // TestChatSessionsNeverListsUntagged pins that a row with no recorded tag is not // an operator session and is never listed, even when the broker still reports it. func TestChatSessionsNeverListsUntagged(t *testing.T) { ctx := context.Background() store := newOperatorStore(t) if err := store.RecordOperatorSession(ctx, "ses_untagged", "/work/untagged", "no tag", ""); err != nil { t.Fatal(err) } broker := scriptedChat() broker.sessions = []protocol.ChatSession{{ID: "ses_untagged"}} _, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 { t.Fatalf("untagged session was listed: %+v", response) } } // TestChatSessionsMostRecentlyUsedFirst pins the list order: sessions come back // most-recently-used first by registry recency (later creation wins), with the // directory and tag from the registry. func TestChatSessionsMostRecentlyUsedFirst(t *testing.T) { ctx := context.Background() store := newOperatorStore(t) if err := store.RecordOperatorSession(ctx, "ses_old", "/work/old", "old", protocol.ChatSessionTagOperator); err != nil { t.Fatal(err) } time.Sleep(3 * time.Millisecond) if err := store.RecordOperatorSession(ctx, "ses_new", "/work/new", "new", protocol.ChatSessionTagOperator); err != nil { t.Fatal(err) } broker := scriptedChat() // The broker lists them oldest-updated-first, so the handler's registry order // is what decides the result. broker.sessions = []protocol.ChatSession{ {ID: "ses_old", UpdatedAt: 100}, {ID: "ses_new", UpdatedAt: 50}, } _, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store}) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if len(response.ChatSessions) != 2 { t.Fatalf("chat_sessions = %+v, want 2", response.ChatSessions) } if response.ChatSessions[0].ID != "ses_new" || response.ChatSessions[1].ID != "ses_old" { t.Fatalf("not most-recently-used first: %+v", response.ChatSessions) } if response.ChatSessions[0].Directory != "/work/new" || response.ChatSessions[0].Tag != protocol.ChatSessionTagOperator { t.Fatalf("registry fields not applied: %+v", response.ChatSessions[0]) } } // TestChatSessionsFailsClosedWithoutOwnership pins the default when no operator // registry (store or injection) is available: chat_sessions returns an empty list // without consulting the broker, never the full OpenCode machine. func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) { broker := scriptedChat() broker.sessions = []protocol.ChatSession{{ID: "ses_1"}, {ID: "ses_2"}} ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 { t.Fatalf("unregistered sessions were exposed: %+v", response) } if calls := broker.sessionQuery(); calls != 0 { t.Fatalf("fail-closed list consulted the broker %d times, want 0", calls) } } // 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 // session/request id after the prompt ack, and a chat_reply with Decision "once" // is forwarded to the broker with the matching SessionID/RequestID/Decision. // // The live end-to-end approval flow against the real OpenCode service is NOT // tested: this broker is the same interface seam the production handler uses, and // the adapter's exact reply path/body are covered by the opencode package tests // over an httptest fixture. func TestChatPromptPushesPermissionAndForwardsReply(t *testing.T) { broker := scriptedChat() broker.block = true broker.started = make(chan struct{}) broker.permissions = []protocol.ChatPermissionFrame{{ SessionID: "ses_1", RequestID: "req_1", Action: "bash", Resources: []string{"rm -rf /tmp"}, }} ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "run it"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("prompt ack = %+v", ack) } var permission protocol.Message if err := wsjson.Read(ctx, conn, &permission); err != nil { t.Fatal(err) } if permission.Type == protocol.Error { t.Fatalf("unexpected error frame: %s", permission.Error) } if permission.Type != protocol.ChatPermission || permission.ChatPermission == nil { t.Fatalf("expected a chat_permission frame, got %+v", permission) } if permission.ChatPermission.SessionID != "ses_1" || permission.ChatPermission.RequestID != "req_1" || permission.ChatPermission.Action != "bash" { t.Fatalf("permission frame = %+v", permission.ChatPermission) } if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.ChatReply || response.ID != "p1" { t.Fatalf("reply response = %+v", response) } count, forwarded := broker.replyQuery() if count != 1 { t.Fatalf("reply forwarded %d times, want 1", count) } if forwarded.SessionID != "ses_1" || forwarded.RequestID != "req_1" || forwarded.Decision != protocol.ChatDecisionOnce { t.Fatalf("forwarded reply = %+v", forwarded) } } // TestChatPermissionDedupesRepeatedPolls pins that the poller pushes each // pending request at most once even though it re-reads the same list, and that a // foreign session's request is never surfaced. func TestChatPermissionDedupesRepeatedPolls(t *testing.T) { broker := scriptedChat() broker.permissions = []protocol.ChatPermissionFrame{ {SessionID: "ses_1", RequestID: "req_1", Action: "bash"}, {SessionID: "ses_other", RequestID: "req_x", Action: "edit"}, } hub := newChatHub() var mu sync.Mutex var pushed []protocol.Message write := func(message protocol.Message) error { mu.Lock() pushed = append(pushed, message) mu.Unlock() return nil } for i := 0; i < 3; i++ { if err := pushChatPermissions(context.Background(), broker, hub, "ses_1", write); err != nil { t.Fatal(err) } } mu.Lock() defer mu.Unlock() if len(pushed) != 1 { t.Fatalf("pushed %d permission frames, want 1: %+v", len(pushed), pushed) } if pushed[0].Type != protocol.ChatPermission || pushed[0].ChatPermission == nil || pushed[0].ChatPermission.RequestID != "req_1" { t.Fatalf("pushed frame = %+v", pushed[0]) } if calls, sessionID := broker.permissionQuery(); calls != 3 || sessionID != "ses_1" { t.Fatalf("permission polls = %d/%q, want 3/ses_1", calls, sessionID) } } // TestChatDisconnectCancelsPermissionPoller pins that the permission poller is // canceled on disconnect (reusing the stream's context), so it cannot leak a // goroutine after the client goes away. func TestChatDisconnectCancelsPermissionPoller(t *testing.T) { broker := scriptedChat() broker.block = true broker.started = make(chan struct{}) broker.done = make(chan struct{}) broker.permBlock = true broker.permDone = make(chan struct{}) ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } select { case <-broker.started: case <-time.After(2 * time.Second): t.Fatal("stream never started") } select { case <-broker.permDone: t.Fatal("permission poller returned before disconnect") default: } conn.CloseNow() select { case <-broker.permDone: case <-time.After(3 * time.Second): t.Fatal("permission poller was not canceled on disconnect") } select { case <-broker.done: case <-time.After(3 * time.Second): t.Fatal("chat stream was not canceled on disconnect") } } // TestChatPermissionPollErrorSurfaced pins that a malformed permission list is // reported to the client as an error frame rather than silence. func TestChatPermissionPollErrorSurfaced(t *testing.T) { broker := scriptedChat() broker.block = true broker.started = make(chan struct{}) broker.permissionErr = fmt.Errorf("invalid OpenCode permission response") ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "permission poll") { t.Fatalf("malformed permission list not surfaced: %+v", response) } } // TestChatReplyRejectsInvalidInput pins that a missing session id, an empty // request id and an invalid decision are rejected with a protocol.Error before // any broker call. func TestChatReplyRejectsInvalidInput(t *testing.T) { broker := scriptedChat() ctx, _, conn := dialChat(t, broker) cases := []*protocol.ChatReplyRequest{ nil, {SessionID: "", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}, {SessionID: "not-a-session", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}, {SessionID: "ses_1", RequestID: "", Decision: protocol.ChatDecisionOnce}, {SessionID: "ses_1", RequestID: "req_1", Decision: ""}, {SessionID: "ses_1", RequestID: "req_1", Decision: "maybe"}, } for _, reply := range cases { if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "bad", ChatReply: reply}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || response.ID != "bad" { t.Fatalf("reply %+v not rejected: %+v", reply, response) } } if count, _ := broker.replyQuery(); count != 0 { t.Fatalf("invalid replies reached the broker: %d", count) } } // TestChatReplyWithoutBroker pins that an unconfigured server answers chat_reply // with the existing "not configured" error. func TestChatReplyWithoutBroker(t *testing.T) { ctx, _, conn := dialChat(t, nil) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") { t.Fatalf("unconfigured reply not rejected: %+v", response) } } // TestChatPermissionUnsupportedBackendIsQuiet pins that a backend which does not // expose the approval surface (the documented native v1 limitation, reported as // opencode.ErrPermissionUnsupported) stops the poller without writing a // per-prompt error frame, so a working prompt is not misread as a failure. func TestChatPermissionUnsupportedBackendIsQuiet(t *testing.T) { broker := scriptedChat() broker.block = true broker.started = make(chan struct{}) broker.permissionErr = opencode.ErrPermissionUnsupported ctx, _, conn := dialChat(t, broker) if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil { t.Fatal(err) } var ack protocol.Message if err := wsjson.Read(ctx, conn, &ack); err != nil { t.Fatal(err) } if ack.Type != protocol.ChatPrompt || ack.ID != "r1" { t.Fatalf("prompt ack = %+v", ack) } // No error frame may follow: a read with a short deadline must time out. readCtx, cancel := context.WithTimeout(ctx, 300*time.Millisecond) defer cancel() var unexpected protocol.Message if err := wsjson.Read(readCtx, conn, &unexpected); err == nil { t.Fatalf("unsupported permission surface must not write a frame, got %+v", unexpected) } if calls, _ := broker.permissionQuery(); calls != 1 { t.Fatalf("permission polls = %d, want 1 (the poller must stop on the documented limitation)", calls) } } // 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) } }