The /update command went silent between "starting" and one final message, gave no version summary, and required manual intervention on failure. CommandInstaller now streams the installer script's stdout live instead of buffering it, and parses a structured result (previous/installed versions, per-component status) from a sentinel line. Because the reference install script hands the daemon restart off to a detached systemd unit specifically so restarting archied.service doesn't kill the process that requested the update, the outcome is reported in two phases: the synchronous build/install result comes back through Install() itself, and the post-restart health check/rollback outcome is written by a new watchdog script and relayed by whichever archied process boots next, via a small JSON handoff file cleared once relayed. Also fixes three defects an adversarial review pass found in the first draft: the caller's request/handler context was passed straight into the install child process, so a concurrent /restart or a browser disconnect could SIGKILL it mid binary-copy; Telegram and the web dashboard each tracked "install in progress" with their own private flag despite sharing one Service, allowing two installs to race the same .prev backups; and the watchdog reported rolled_back:true even when no backup existed to restore, which would have told an operator to stand down while the daemon was still broken. internal/webui gains an unauthenticated /healthz the watchdog polls after restarting archied.
770 lines
29 KiB
Go
770 lines
29 KiB
Go
package webui
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
"github.com/samcharles93/archie-core/internal/gateway"
|
|
"github.com/samcharles93/archie-core/internal/releaseupdate"
|
|
)
|
|
|
|
type chatStatusStub struct{}
|
|
|
|
func (chatStatusStub) StatusCounts(context.Context) (map[string]int, error) {
|
|
return map[string]int{"queued": 2}, nil
|
|
}
|
|
|
|
type chatProviderModelStub struct {
|
|
active string
|
|
}
|
|
|
|
func (s *chatProviderModelStub) Models() []string {
|
|
return []string{"openai/gpt-5", "openrouter/sonnet"}
|
|
}
|
|
|
|
func (s *chatProviderModelStub) ActiveModel() string { return s.active }
|
|
|
|
func (s *chatProviderModelStub) SetActiveModel(context.Context, string) error { return nil }
|
|
|
|
func (*chatProviderModelStub) Providers() []string { return []string{"openai", "openrouter"} }
|
|
|
|
func (s *chatProviderModelStub) ActiveProvider() string {
|
|
provider, _, _ := strings.Cut(s.active, "/")
|
|
return provider
|
|
}
|
|
|
|
func (s *chatProviderModelStub) ModelsForProvider(provider string) []string {
|
|
var models []string
|
|
for _, model := range s.Models() {
|
|
if strings.HasPrefix(model, provider+"/") {
|
|
models = append(models, model)
|
|
}
|
|
}
|
|
return models
|
|
}
|
|
|
|
func (*chatProviderModelStub) SetActiveProvider(context.Context, string) error { return nil }
|
|
|
|
type chatUpdateStub struct {
|
|
snapshot releaseupdate.Snapshot
|
|
deferred releaseupdate.Snapshot
|
|
installed bool
|
|
}
|
|
|
|
type webDangerousStub struct {
|
|
rollbackCalls []int
|
|
stopCalls []string
|
|
}
|
|
|
|
func (s *webDangerousStub) StopProcess(_ context.Context, spec string) error {
|
|
s.stopCalls = append(s.stopCalls, spec)
|
|
return nil
|
|
}
|
|
|
|
func (s *webDangerousStub) Rollback(_ context.Context, checkpoint int) (string, error) {
|
|
s.rollbackCalls = append(s.rollbackCalls, checkpoint)
|
|
return "rollback complete", nil
|
|
}
|
|
|
|
func (*webDangerousStub) ListCheckpoints(context.Context) ([]gateway.CheckpointInfo, error) {
|
|
return []gateway.CheckpointInfo{{Number: 3, Label: "after tests"}}, nil
|
|
}
|
|
|
|
func (s *chatUpdateStub) Check(context.Context, int64) (releaseupdate.Snapshot, error) {
|
|
return s.snapshot, nil
|
|
}
|
|
|
|
func (s *chatUpdateStub) Defer(_ context.Context, _ int64, snapshot releaseupdate.Snapshot) error {
|
|
s.deferred = snapshot
|
|
return nil
|
|
}
|
|
|
|
func (s *chatUpdateStub) Install(_ context.Context, _ releaseupdate.InstallMeta, progress func(string)) (releaseupdate.Result, error) {
|
|
s.installed = true
|
|
progress("install started")
|
|
return releaseupdate.Result{}, nil
|
|
}
|
|
func (*chatUpdateStub) CanInstall() bool { return true }
|
|
|
|
func TestChatSessionAndMessageEndpoints(t *testing.T) {
|
|
t.Parallel()
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
router.InitSessions(sessions)
|
|
server := &Server{Chat: &ChatService{Router: router, Sessions: sessions}}
|
|
session := gateway.SessionContext{
|
|
SessionID: "session-1",
|
|
Source: gateway.SessionSource{Platform: "web", ChannelID: "browser-1"},
|
|
CreatedAt: time.Now().UTC(), LastActiveAt: time.Now().UTC(),
|
|
}
|
|
if err := sessions.Save(context.Background(), session); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := sessions.SaveMessage(context.Background(), session.SessionID, gateway.Message{From: "web", Text: "hello"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
t.Run("sessions", func(t *testing.T) {
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions", nil)
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
var got struct {
|
|
Sessions []gateway.SessionContext `json:"sessions"`
|
|
}
|
|
if err := json.Unmarshal(res.Body.Bytes(), &got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got.Sessions) != 1 || got.Sessions[0].SessionID != session.SessionID {
|
|
t.Fatalf("sessions = %#v", got.Sessions)
|
|
}
|
|
})
|
|
|
|
t.Run("messages", func(t *testing.T) {
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions/session-1/messages", nil)
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
var got []gateway.Message
|
|
if err := json.Unmarshal(res.Body.Bytes(), &got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 1 || got[0].Text != "hello" {
|
|
t.Fatalf("messages = %#v", got)
|
|
}
|
|
})
|
|
|
|
t.Run("shared router command", func(t *testing.T) {
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/message", bytes.NewBufferString(`{"channel_id":"browser-1","text":"/status"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
var got struct {
|
|
Reply string `json:"reply"`
|
|
}
|
|
if err := json.Unmarshal(res.Body.Bytes(), &got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got.Reply == "" {
|
|
t.Fatal("shared router returned an empty status reply")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestChatSessionsExposeActiveSelectorState(t *testing.T) {
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
router.InitSessions(sessions)
|
|
models := &chatProviderModelStub{active: "openrouter/sonnet"}
|
|
router.Models = models
|
|
server := &Server{Chat: &ChatService{
|
|
Router: router,
|
|
Models: models,
|
|
Sessions: sessions,
|
|
Personas: gateway.NewPersonaRegistry(gateway.DefaultPersonas()),
|
|
}}
|
|
session := gateway.SessionContext{
|
|
SessionID: "selector-session",
|
|
Source: gateway.SessionSource{Platform: "web", ChannelID: "selector-browser"},
|
|
}
|
|
if err := sessions.Save(context.Background(), session); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !server.Chat.Personas.SetActive(session.SessionID, "concise") {
|
|
t.Fatal("set active persona failed")
|
|
}
|
|
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions", nil))
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
var got struct {
|
|
ActiveModel string `json:"active_model"`
|
|
ActiveProvider string `json:"active_provider"`
|
|
Providers []string `json:"providers"`
|
|
Models map[string][]string `json:"models_by_provider"`
|
|
Personas map[string]string `json:"active_personas"`
|
|
}
|
|
if err := json.Unmarshal(res.Body.Bytes(), &got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got.ActiveModel != "openrouter/sonnet" || got.ActiveProvider != "openrouter" {
|
|
t.Fatalf("active model state = %#v", got)
|
|
}
|
|
if !slices.Equal(got.Providers, []string{"openai", "openrouter"}) || !slices.Equal(got.Models["openrouter"], []string{"openrouter/sonnet"}) {
|
|
t.Fatalf("provider model state = %#v / %#v", got.Providers, got.Models)
|
|
}
|
|
if got.Personas[session.SessionID] != "concise" {
|
|
t.Fatalf("active personas = %#v", got.Personas)
|
|
}
|
|
}
|
|
|
|
func TestChatUpdateEndpoints(t *testing.T) {
|
|
updates := &chatUpdateStub{snapshot: releaseupdate.Snapshot{Components: []releaseupdate.Component{{ID: "gateway", Label: "Gateway", Installed: "1.0", Available: "1.1"}}}}
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
server := &Server{Chat: &ChatService{Router: router, Sessions: sessions, Updates: updates}}
|
|
|
|
get := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(get, httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/update", nil))
|
|
if get.Code != http.StatusOK || !bytes.Contains(get.Body.Bytes(), []byte(`"can_install":true`)) {
|
|
t.Fatalf("update status = %d, body = %s", get.Code, get.Body.String())
|
|
}
|
|
|
|
body, _ := json.Marshal(chatUpdateRequest{Snapshot: updates.snapshot})
|
|
deferRes := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(deferRes, httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/update/defer", bytes.NewReader(body)))
|
|
if deferRes.Code != http.StatusOK || len(updates.deferred.Components) != 1 {
|
|
t.Fatalf("update defer = %d, body = %s", deferRes.Code, deferRes.Body.String())
|
|
}
|
|
|
|
installBody, _ := json.Marshal(chatUpdateRequest{Snapshot: updates.snapshot})
|
|
installRes := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(installRes, httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/update/install", bytes.NewReader(installBody)))
|
|
if installRes.Code != http.StatusOK || !updates.installed {
|
|
t.Fatalf("update install = %d, body = %s", installRes.Code, installRes.Body.String())
|
|
}
|
|
|
|
updates.installed = false
|
|
displayed := releaseupdate.Snapshot{Components: append([]releaseupdate.Component(nil), updates.snapshot.Components...)}
|
|
updates.snapshot.Components[0].Available = "1.2"
|
|
staleBody, _ := json.Marshal(chatUpdateRequest{Snapshot: displayed})
|
|
staleRes := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(staleRes, httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/update/install", bytes.NewReader(staleBody)))
|
|
if staleRes.Code != http.StatusConflict || updates.installed {
|
|
t.Fatalf("stale update install = %d, body = %s, installed = %v", staleRes.Code, staleRes.Body.String(), updates.installed)
|
|
}
|
|
}
|
|
|
|
func TestChatUpdateEndpointRejectsTypedNilService(t *testing.T) {
|
|
var updates *releaseupdate.Service
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
server := &Server{Chat: &ChatService{Router: router, Sessions: sessions, Updates: updates}}
|
|
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/update", nil))
|
|
if res.Code != http.StatusNotImplemented {
|
|
t.Fatalf("typed-nil update service status = %d, body = %s", res.Code, res.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestChatDangerousApprovalEndpoints(t *testing.T) {
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
authority := &webDangerousStub{}
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
server := &Server{Chat: &ChatService{Router: router, Sessions: sessions, Dangerous: NewDangerousService(authority)}}
|
|
|
|
state := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(state, httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/dangerous", nil))
|
|
if state.Code != http.StatusOK || !bytes.Contains(state.Body.Bytes(), []byte(`"Number":3`)) {
|
|
t.Fatalf("dangerous state = %d, body = %s", state.Code, state.Body.String())
|
|
}
|
|
|
|
request := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(request, httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/dangerous/rollback", bytes.NewBufferString(`{"spec":"3"}`)))
|
|
if request.Code != http.StatusOK || len(authority.rollbackCalls) != 0 {
|
|
t.Fatalf("rollback request = %d, body = %s, calls=%v", request.Code, request.Body.String(), authority.rollbackCalls)
|
|
}
|
|
var pending struct {
|
|
Action DangerousActionView `json:"action"`
|
|
}
|
|
if err := json.Unmarshal(request.Body.Bytes(), &pending); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
decisionBody := bytes.NewBufferString(`{"decision":"approve"}`)
|
|
decision := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(decision, httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/dangerous/"+pending.Action.ID+"/decision", decisionBody))
|
|
if decision.Code != http.StatusOK || len(authority.rollbackCalls) != 1 || authority.rollbackCalls[0] != 3 {
|
|
t.Fatalf("rollback decision = %d, body = %s, calls=%v", decision.Code, decision.Body.String(), authority.rollbackCalls)
|
|
}
|
|
}
|
|
|
|
func TestChatCommandCatalogIncludesEnabledCapabilities(t *testing.T) {
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
server := &Server{Chat: &ChatService{
|
|
Router: router, Sessions: sessions,
|
|
Updates: &chatUpdateStub{}, Dangerous: NewDangerousService(&webDangerousStub{}),
|
|
}}
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions", nil))
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("catalog status = %d, body = %s", res.Code, res.Body.String())
|
|
}
|
|
var body struct {
|
|
Commands []gateway.CommandSpec `json:"commands"`
|
|
}
|
|
if err := json.Unmarshal(res.Body.Bytes(), &body); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
found := map[string]bool{}
|
|
for _, command := range body.Commands {
|
|
found[command.Command] = true
|
|
}
|
|
for _, command := range []string{"/update", "/rollback", "/stop"} {
|
|
if !found[command] {
|
|
t.Errorf("command catalog missing enabled %s", command)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestChatCancelEndpointStopsSessionTurn(t *testing.T) {
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
router.InitSessions(sessions)
|
|
turns := gateway.NewTurns(slog.Default())
|
|
server := &Server{Chat: &ChatService{Router: router, Sessions: sessions, Turns: turns}}
|
|
if err := sessions.Save(context.Background(), gateway.SessionContext{
|
|
SessionID: "session-1", Source: gateway.SessionSource{Platform: "web", ChannelID: "browser-1"},
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
started := make(chan struct{})
|
|
stopped := make(chan struct{})
|
|
turns.Submit(context.Background(), "session-1", func(ctx context.Context) {
|
|
close(started)
|
|
<-ctx.Done()
|
|
close(stopped)
|
|
})
|
|
<-started
|
|
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/cancel", strings.NewReader(`{"session_id":"session-1"}`))
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body.String())
|
|
}
|
|
select {
|
|
case <-stopped:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("cancel endpoint did not stop the turn")
|
|
}
|
|
var body struct {
|
|
Cancelled bool `json:"cancelled"`
|
|
}
|
|
if err := json.Unmarshal(res.Body.Bytes(), &body); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !body.Cancelled {
|
|
t.Fatal("cancel endpoint reported no cancelled turn")
|
|
}
|
|
}
|
|
|
|
// chatTestServer builds the fixture the chat endpoint tests share: a web
|
|
// gateway router on an in-memory session store.
|
|
func chatTestServer(t *testing.T) (*Server, gateway.SessionStore) {
|
|
t.Helper()
|
|
sessions := gateway.NewSessionStoreMemory()
|
|
t.Cleanup(func() { _ = sessions.Close() })
|
|
router := gateway.NewRouter(chatStatusStub{}, nil, "web")
|
|
router.InitSessions(sessions)
|
|
return &Server{Chat: &ChatService{Router: router, Sessions: sessions}}, sessions
|
|
}
|
|
|
|
func saveWebSession(t *testing.T, sessions gateway.SessionStore, id string) {
|
|
t.Helper()
|
|
if err := sessions.Save(context.Background(), gateway.SessionContext{
|
|
SessionID: id,
|
|
Source: gateway.SessionSource{Platform: "web", ChannelID: "browser-" + id},
|
|
CreatedAt: time.Now().UTC(),
|
|
LastActiveAt: time.Now().UTC(),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// TestChatEndpointsRequireToken proves the whole chat surface sits behind the
|
|
// same token gate as the rest of the dashboard, not a parallel auth story.
|
|
func TestChatEndpointsRequireToken(t *testing.T) {
|
|
server := &Server{Token: "secret"}
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions", nil)
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusUnauthorized {
|
|
t.Fatalf("status = %d, want 401 for a tokenless request", res.Code)
|
|
}
|
|
|
|
req = httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions", nil)
|
|
req.Header.Set("Authorization", "Bearer secret")
|
|
res = httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code == http.StatusUnauthorized {
|
|
t.Fatal("valid bearer token was rejected")
|
|
}
|
|
if res.Code != http.StatusNotImplemented {
|
|
t.Fatalf("status = %d, want 501 (chat unconfigured) past the token gate", res.Code)
|
|
}
|
|
}
|
|
|
|
// TestChatEndpointsUnavailableWithoutChatService proves every chat route
|
|
// degrades to 501 rather than panicking when the daemon runs without chat.
|
|
func TestChatEndpointsUnavailableWithoutChatService(t *testing.T) {
|
|
server := &Server{}
|
|
cases := []struct {
|
|
method, path, body string
|
|
}{
|
|
{http.MethodGet, "/api/chat/sessions", ""},
|
|
{http.MethodGet, "/api/chat/sessions/s-1/messages", ""},
|
|
{http.MethodPost, "/api/chat/message", `{"channel_id":"c","text":"hi"}`},
|
|
{http.MethodPost, "/api/chat/stream", `{"channel_id":"c","text":"hi"}`},
|
|
{http.MethodPost, "/api/chat/persona", `{"session_id":"s","name":"concise"}`},
|
|
{http.MethodPost, "/api/chat/update/install", ""},
|
|
}
|
|
for _, tc := range cases {
|
|
var body io.Reader
|
|
if tc.body != "" {
|
|
body = strings.NewReader(tc.body)
|
|
}
|
|
req := httptest.NewRequestWithContext(context.Background(), tc.method, tc.path, body)
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusNotImplemented {
|
|
t.Errorf("%s %s = %d, want 501", tc.method, tc.path, res.Code)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatMessageDecodeErrors proves malformed or incomplete chat messages are
|
|
// refused at the boundary, before any router state is touched.
|
|
func TestChatMessageDecodeErrors(t *testing.T) {
|
|
server, _ := chatTestServer(t)
|
|
cases := []struct {
|
|
name, body string
|
|
}{
|
|
{"malformed json", `{`},
|
|
{"blank text", `{"channel_id":"c","text":" "}`},
|
|
{"missing channel_id", `{"text":"hi"}`},
|
|
}
|
|
for _, tc := range cases {
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/message", strings.NewReader(tc.body))
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusBadRequest {
|
|
t.Errorf("%s: status = %d, want 400", tc.name, res.Code)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatSessionsFiltersNonWeb proves the dashboard only lists and serves
|
|
// browser-originated sessions: a Telegram session is invisible to it and its
|
|
// transcript is not reachable by guessing the id.
|
|
func TestChatSessionsFiltersNonWeb(t *testing.T) {
|
|
server, sessions := chatTestServer(t)
|
|
saveWebSession(t, sessions, "web-1")
|
|
if err := sessions.Save(context.Background(), gateway.SessionContext{
|
|
SessionID: "tg-1",
|
|
Source: gateway.SessionSource{Platform: "telegram", ChannelID: "42"},
|
|
CreatedAt: time.Now().UTC(),
|
|
LastActiveAt: time.Now().UTC(),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions", nil))
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("sessions status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
var got struct {
|
|
Sessions []gateway.SessionContext `json:"sessions"`
|
|
}
|
|
if err := json.Unmarshal(res.Body.Bytes(), &got); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got.Sessions) != 1 || got.Sessions[0].SessionID != "web-1" {
|
|
t.Fatalf("sessions = %#v, want only the web session", got.Sessions)
|
|
}
|
|
|
|
res = httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, httptest.NewRequestWithContext(context.Background(), http.MethodGet, "/api/chat/sessions/tg-1/messages", nil))
|
|
if res.Code != http.StatusNotFound {
|
|
t.Fatalf("telegram transcript status = %d, want 404", res.Code)
|
|
}
|
|
}
|
|
|
|
// chatSSEEvent is one parsed `data: {...}` frame from the stream endpoint.
|
|
type chatSSEEvent struct {
|
|
Type string `json:"type"`
|
|
Text string `json:"text"`
|
|
Tool string `json:"tool"`
|
|
ToolCallID string `json:"tool_call_id"`
|
|
Parameters string `json:"parameters"`
|
|
Failed bool `json:"failed"`
|
|
SessionID string `json:"session_id"`
|
|
}
|
|
|
|
func parseChatSSE(t *testing.T, body string) []chatSSEEvent {
|
|
t.Helper()
|
|
var events []chatSSEEvent
|
|
for frame := range strings.SplitSeq(body, "\n\n") {
|
|
line := strings.TrimSpace(frame)
|
|
if line == "" {
|
|
continue
|
|
}
|
|
if !strings.HasPrefix(line, "data: ") {
|
|
t.Fatalf("malformed SSE frame: %q", frame)
|
|
}
|
|
var ev chatSSEEvent
|
|
if err := json.Unmarshal([]byte(strings.TrimPrefix(line, "data: ")), &ev); err != nil {
|
|
t.Fatalf("invalid SSE payload %q: %v", line, err)
|
|
}
|
|
events = append(events, ev)
|
|
}
|
|
return events
|
|
}
|
|
|
|
// TestChatStreamEndsWithDone proves the stream endpoint answers a local
|
|
// command through the shared router and frames the reply as a single done
|
|
// event carrying the session the turn ran in.
|
|
func TestChatStreamEndsWithDone(t *testing.T) {
|
|
server, _ := chatTestServer(t)
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/stream",
|
|
strings.NewReader(`{"channel_id":"browser-1","text":"/status"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
if ct := res.Header().Get("Content-Type"); !strings.Contains(ct, "text/event-stream") {
|
|
t.Fatalf("Content-Type = %q, want text/event-stream", ct)
|
|
}
|
|
events := parseChatSSE(t, res.Body.String())
|
|
if len(events) == 0 || events[len(events)-1].Type != "done" {
|
|
t.Fatalf("events = %#v, want a final done event", events)
|
|
}
|
|
last := events[len(events)-1]
|
|
if last.Text == "" {
|
|
t.Fatal("done event carried an empty reply")
|
|
}
|
|
if last.SessionID == "" {
|
|
t.Fatal("done event carried no session_id")
|
|
}
|
|
}
|
|
|
|
// TestChatStreamDeltas proves a real streaming responder's deltas are emitted
|
|
// as SSE delta events before the final done event.
|
|
func TestChatStreamDeltas(t *testing.T) {
|
|
server, sessions := chatTestServer(t)
|
|
var gotDeltas []string
|
|
server.Chat.Router.LLMStream = func(_ context.Context, _ gateway.Message, stream gateway.TurnStream) (string, error) {
|
|
stream.Delta("part one")
|
|
stream.Delta("part two")
|
|
return "full reply", nil
|
|
}
|
|
saveWebSession(t, sessions, "web-1")
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/stream",
|
|
strings.NewReader(`{"channel_id":"browser-web-1","text":"hello"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
events := parseChatSSE(t, res.Body.String())
|
|
for _, ev := range events {
|
|
if ev.Type == "delta" {
|
|
gotDeltas = append(gotDeltas, ev.Text)
|
|
}
|
|
}
|
|
if len(gotDeltas) != 2 || gotDeltas[0] != "part one" || gotDeltas[1] != "part two" {
|
|
t.Fatalf("deltas = %#v", gotDeltas)
|
|
}
|
|
if events[len(events)-1].Type != "done" || events[len(events)-1].Text != "full reply" {
|
|
t.Fatalf("final event = %#v, want done/full reply", events[len(events)-1])
|
|
}
|
|
}
|
|
|
|
// Tool activity has to reach the browser interleaved with the text that
|
|
// surrounds it, on both stream paths: without a turn queue the responder
|
|
// writes straight to the SSE writer, with one it hands events across a
|
|
// goroutine, and an ordering that survives only the first is not a fix.
|
|
func TestChatStreamReportsToolCalls(t *testing.T) {
|
|
stream := func(_ context.Context, _ gateway.Message, turn gateway.TurnStream) (string, error) {
|
|
turn.Delta("checking")
|
|
turn.ToolCall(gateway.ToolCallEvent{ID: "call-1", Name: "shell", Parameters: `{"cmd":"true"}`, Output: "exit 0\nignored trailing line"})
|
|
turn.ToolCall(gateway.ToolCallEvent{Name: "read", Err: "no such file"})
|
|
// A successful tool whose own output happens to start with
|
|
// "failed:" (a grep hit, a log line read back) must be reported
|
|
// as not failed: Failed is driven by Err, never by Text content.
|
|
turn.ToolCall(gateway.ToolCallEvent{Name: "grep", Output: "failed: no such file\nmatch"})
|
|
turn.Delta(" and answering")
|
|
return "checking and answering", nil
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
queued bool
|
|
}{
|
|
{name: "direct"},
|
|
{name: "queued", queued: true},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
server, sessions := chatTestServer(t)
|
|
server.Chat.Router.LLMStream = stream
|
|
// Enabled explicitly: this test exercises the tool-narration
|
|
// path itself, which is off by default (see
|
|
// TestChatStreamHidesToolCallsWhenShowToolCallsIsOff).
|
|
server.Cfg = config.NewHolder(config.Config{Chat: config.ChatConfig{ShowToolCalls: true}})
|
|
if tc.queued {
|
|
server.Chat.Turns = gateway.NewTurns(slog.Default())
|
|
}
|
|
saveWebSession(t, sessions, "web-1")
|
|
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/stream",
|
|
strings.NewReader(`{"channel_id":"browser-web-1","text":"hello"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
|
|
var got []string
|
|
for _, ev := range parseChatSSE(t, res.Body.String()) {
|
|
switch ev.Type {
|
|
case "delta":
|
|
got = append(got, "text:"+ev.Text)
|
|
case "tool":
|
|
got = append(got, fmt.Sprintf("tool:%s:%s:%s:%s:failed=%v", ev.ToolCallID, ev.Tool, ev.Parameters, ev.Text, ev.Failed))
|
|
}
|
|
}
|
|
want := []string{
|
|
"text:checking",
|
|
`tool:call-1:shell:{"cmd":"true"}:exit 0:failed=false`,
|
|
"tool::read::failed: no such file:failed=true",
|
|
"tool::grep::failed: no such file:failed=false",
|
|
"text: and answering",
|
|
}
|
|
if len(got) != len(want) {
|
|
t.Fatalf("stream events = %v, want %v", got, want)
|
|
}
|
|
for i := range want {
|
|
if got[i] != want[i] {
|
|
t.Fatalf("stream events = %v, want %v", got, want)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// config.ChatConfig.ShowToolCalls is off by default and shared by every chat
|
|
// channel: an operator who left it unset (or explicitly turned it off) must
|
|
// see no tool activity on the dashboard, not just in Telegram. Previously the
|
|
// web stream narrated every tool call unconditionally, because nothing here
|
|
// read this setting at all.
|
|
func TestChatStreamHidesToolCallsWhenShowToolCallsIsOff(t *testing.T) {
|
|
stream := func(_ context.Context, _ gateway.Message, turn gateway.TurnStream) (string, error) {
|
|
turn.Delta("checking")
|
|
turn.ToolCall(gateway.ToolCallEvent{Name: "shell", Output: "exit 0"})
|
|
turn.Delta(" and answering")
|
|
return "checking and answering", nil
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
cfg *config.Holder
|
|
}{
|
|
{name: "no Cfg wired at all", cfg: nil},
|
|
{name: "Cfg present but show_tool_calls unset", cfg: config.NewHolder(config.Config{})},
|
|
{name: "show_tool_calls explicitly false", cfg: config.NewHolder(config.Config{Chat: config.ChatConfig{ShowToolCalls: false}})},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
server, sessions := chatTestServer(t)
|
|
server.Chat.Router.LLMStream = stream
|
|
server.Cfg = tc.cfg
|
|
saveWebSession(t, sessions, "web-1")
|
|
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/stream",
|
|
strings.NewReader(`{"channel_id":"browser-web-1","text":"hello"}`))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
if res.Code != http.StatusOK {
|
|
t.Fatalf("status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
|
|
for _, ev := range parseChatSSE(t, res.Body.String()) {
|
|
if ev.Type == "tool" {
|
|
t.Fatalf("got a tool frame with show_tool_calls off: %+v", ev)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestChatPersonaEndpoint proves the persona surface: switching to a known
|
|
// persona works, an unknown name is refused, a non-web session is invisible,
|
|
// and an unconfigured registry degrades to 501.
|
|
func TestChatPersonaEndpoint(t *testing.T) {
|
|
server, sessions := chatTestServer(t)
|
|
server.Chat.Personas = gateway.NewPersonaRegistry(gateway.DefaultPersonas())
|
|
saveWebSession(t, sessions, "web-1")
|
|
|
|
post := func(body string) *httptest.ResponseRecorder {
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/persona", strings.NewReader(body))
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
return res
|
|
}
|
|
|
|
if res := post(`{"session_id":"web-1","name":"concise"}`); res.Code != http.StatusOK {
|
|
t.Fatalf("known persona: status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
if res := post(`{"session_id":"web-1","name":"does-not-exist"}`); res.Code != http.StatusBadRequest {
|
|
t.Fatalf("unknown persona: status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
if res := post(`{"session_id":"tg-1","name":"concise"}`); res.Code != http.StatusNotFound {
|
|
t.Fatalf("non-web session: status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
if res := post(`{"session_id":"","name":"concise"}`); res.Code != http.StatusBadRequest {
|
|
t.Fatalf("blank session: status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
|
|
nilServer, nilSessions := chatTestServer(t)
|
|
saveWebSession(t, nilSessions, "web-1")
|
|
if res := postTo(nilServer, `{"session_id":"web-1","name":"concise"}`); res.Code != http.StatusNotImplemented {
|
|
t.Fatalf("nil personas: status = %d, body = %s", res.Code, res.Body)
|
|
}
|
|
}
|
|
|
|
func postTo(server *Server, body string) *httptest.ResponseRecorder {
|
|
req := httptest.NewRequestWithContext(context.Background(), http.MethodPost, "/api/chat/persona", strings.NewReader(body))
|
|
res := httptest.NewRecorder()
|
|
server.Handler().ServeHTTP(res, req)
|
|
return res
|
|
}
|