Files
archie/internal/gateway/gateway_test.go
T
sam 800352a692 feat(gateway): give /status a real daemon-health surface (#892)
* feat(gateway): give /status a real daemon-health surface

Phase 2 of archie-core-wp9s. Phase 1 split the commands apart (health vs
work) but left /status with one aggregate queue line and a static runtime
block; it could not answer the questions an operator actually asks when
something feels wrong. /status now reports, between the queue line and the
runtime block:

- Broker: the live state of this process's own NATS connection
  (eventbus/nats.Client.Connected), not a fresh dial -- a probe would
  report the probe's reachability, not the daemon's.
- Containers: the pool's own active counter against the configured cap
  (Pool.Active/Cap), not a Docker listing, which would include containers
  this pool does not own. A zero cap means unlimited, so it is not shown
  as a ratio.
- Channels: the channel manager's real lifecycle state, including a
  failed adapter's reason (the documented decision: read the existing
  manager rather than re-deriving health per adapter).
- Chat model: last-known outcome of every chat-model call this process
  made, recorded once in sendChatTurn (the single choke point) and read
  back by /status. The second documented decision: never a live probe,
  so /status stays instant and reports what happened -- or says plainly
  that nothing has been attempted yet.
- Last poll: when the most recent poll pass began, stamped on both poll
  paths (Run's single-identity loop and runIdentities' per-identity
  goroutines). A pass that hangs leaves the stamp stale, which is the
  signal; stamping completion would leave a wedged poller looking
  healthy.

Truthful or absent: a section this process has no source for is omitted
rather than rendered as a zero. The standalone Gateway owns no poll loop,
pool or channel manager, so its /status reports broker and chat-model
health only; aggregating across processes would need a new daemon RPC and
is deliberately not built. Version stays out (/version owns it).

/status and /tasks descriptions now describe what each command actually
does on both published surfaces (Telegram menu/help and the shared
specs), pinned by a test that also fails if the two surfaces drift.

Sources are read through functions, not captured values: occupancy and
channel state move, and the daemon is built after the gateways, so a
source captured at construction would freeze /status on boot state.

Left in place deliberately: the Runtime (provider/model) block, which
Phase 1 flagged and which duplicates /model and /whoami. Removing it is a
product call on a command Sam uses daily, not a mechanical follow-up.

* docs(prds): record the two open /status health decisions as settled

Both were flagged in PR #892 as needing the maintainer's call; both are now
answered, and the PRD is the place a follow-up would look:

- The Runtime (provider/model) block stays. It is the one line in /status the
  ticket's own rule says should not be there, but /status is read daily to see
  the active model at a glance, so the duplication is deliberate. Recorded as a
  settled product decision so it is not removed later as an oversight.
- Health stays per-process. Pooling the daemon's and the Gateway's chat-model
  outcomes would need a new daemon<->gateway health RPC for one status line, and
  a per-process line is true where an aggregate would be a claim about a process
  the answering one cannot see.

/agents' published description is still left to archie-core-mxls, unchanged.
2026-09-20 00:30:23 +10:00

1174 lines
35 KiB
Go

package gateway
import (
"context"
"errors"
"fmt"
"slices"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/taskstate"
)
type fakeStore struct {
counts map[string]int
err error
}
func (f *fakeStore) StatusCounts(ctx context.Context) (map[string]int, error) {
return f.counts, f.err
}
func fakeLLM(ctx context.Context, in Inbound) (string, error) {
return "llm: " + in.Message.Text, nil
}
func TestRouteStatusShowsQueueDepthNotPerTaskCounts(t *testing.T) {
r := NewRouter(&fakeStore{counts: map[string]int{"queued": 2, "pr_open": 1}}, nil, "test")
reply, err := r.Route(context.Background(), inbound("", "/status"))
if err != nil {
t.Fatalf("Route: %v", err)
}
// queued and pr_open are not "in flight" (running/waiting/parked), so
// /status reports the daemon idle -- that per-task detail is /tasks' job.
want := "📊 Archie status\n\nQueue: idle \nRuntime: not configured"
if reply != want {
t.Errorf("reply =\n%q\nwant:\n%q", reply, want)
}
}
func TestRouteStatusIncludesActiveProviderAndModel(t *testing.T) {
manager := &fakeProviderModelManager{
models: []string{"openai/gpt-5.6", "openrouter/openai/gpt-5.6"},
activeModel: "openai/gpt-5.6",
}
r := NewRouter(&fakeStore{counts: map[string]int{"running": 1}}, nil, "test")
r.Models = manager
reply, err := r.Route(context.Background(), inbound("", "/status"))
if err != nil {
t.Fatal(err)
}
want := "📊 Archie status\n\nQueue: 1 in flight (1 running) \nProvider: OpenAI \nModel: openai/gpt-5.6"
if reply != want {
t.Fatalf("reply =\n%q\nwant:\n%q", reply, want)
}
}
func TestRouteStatusAtMention(t *testing.T) {
r := NewRouter(&fakeStore{counts: map[string]int{"running": 3}}, nil, "archie")
reply, err := r.Route(context.Background(), inbound("", "/status@archie"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "3 running") {
t.Errorf("reply missing queue depth: %q", reply)
}
}
func TestRouteStatusEmpty(t *testing.T) {
r := NewRouter(&fakeStore{counts: map[string]int{}}, nil, "test")
reply, err := r.Route(context.Background(), inbound("", "/status"))
if err != nil {
t.Fatalf("Route: %v", err)
}
want := "📊 Archie status\n\nQueue: idle \nRuntime: not configured"
if reply != want {
t.Errorf("reply = %q, want %q", reply, want)
}
}
type fakeCustomDisplayNamerManager struct {
fakeProviderModelManager
}
func (f *fakeCustomDisplayNamerManager) ProviderDisplayName(provider string) string {
if provider == "openai" {
return "OpenAI Custom Enterprise"
}
return provider
}
func TestFormatStatus(t *testing.T) {
tests := []struct {
name string
counts map[string]int
models ModelManager
want string
}{
{
name: "single parked task with provider and model",
counts: map[string]int{"parked": 2},
models: &fakeProviderModelManager{
activeModel: "openai/gpt-5.6-luna",
},
want: "📊 Archie status\n\nQueue: 2 in flight (2 parked) \nProvider: OpenAI \nModel: openai/gpt-5.6-luna",
},
{
name: "in-flight states reduce to one aggregate line; queued and terminal states are excluded",
counts: map[string]int{
"queued": 4,
"running": 1,
"waiting_human": 2,
"parked": 3,
"pr_open": 5,
"merged": 6,
"rejected": 7,
"closed_wont_do": 8,
"dead": 9,
"custom_state": 10,
},
models: &fakeProviderModelManager{
activeModel: "deepseek/deepseek-v4-pro",
},
want: "📊 Archie status\n\nQueue: 6 in flight (1 running, 2 waiting on you, 3 parked) \nProvider: DeepSeek \nModel: deepseek/deepseek-v4-pro",
},
{
name: "empty task counts with active model",
counts: map[string]int{},
models: &fakeModelManager{
activeModel: "anthropic/claude-3-5-sonnet",
},
want: "📊 Archie status\n\nQueue: idle \nProvider: Anthropic \nModel: anthropic/claude-3-5-sonnet",
},
{
name: "nil counts with active model",
counts: nil,
models: &fakeModelManager{
activeModel: "google/gemini-2.5-flash",
},
want: "📊 Archie status\n\nQueue: idle \nProvider: Google \nModel: google/gemini-2.5-flash",
},
{
name: "nil model manager",
counts: map[string]int{"running": 2},
models: nil,
want: "📊 Archie status\n\nQueue: 2 in flight (2 running) \nRuntime: not configured",
},
{
name: "empty counts and nil model manager",
counts: map[string]int{},
models: nil,
want: "📊 Archie status\n\nQueue: idle \nRuntime: not configured",
},
{
name: "custom display namer interface",
counts: map[string]int{"running": 1},
models: &fakeCustomDisplayNamerManager{
activeModel: "openai/gpt-5.6",
},
want: "📊 Archie status\n\nQueue: 1 in flight (1 running) \nProvider: OpenAI Custom Enterprise \nModel: openai/gpt-5.6",
},
{
name: "queued-only counts as idle -- queued is not in flight",
counts: map[string]int{"queued": 1},
models: &fakeProviderModelManager{
activeModel: "",
},
want: "📊 Archie status\n\nQueue: idle \nRuntime: not configured",
},
{
name: "model without slash and no provider manager",
counts: map[string]int{"running": 1},
models: &fakeModelManager{
activeModel: "custom-local-model",
},
want: "📊 Archie status\n\nQueue: 1 in flight (1 running) \nProvider: not configured \nModel: custom-local-model",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
// Health sections are covered by TestFormatHealthRendersOnlyWhatWasReported;
// these cases pin the queue and runtime sections with no health source wired.
got := formatStatus(tc.counts, HealthReport{}, tc.models, time.Date(2026, 9, 19, 12, 0, 0, 0, time.UTC))
if got != tc.want {
t.Errorf("formatStatus() =\n%q\nwant:\n%q\ndiff:\ngot:\n%s\nwant:\n%s", got, tc.want, got, tc.want)
}
})
}
}
func TestRouteStatusError(t *testing.T) {
r := NewRouter(&fakeStore{err: errors.New("db down")}, nil, "test")
if _, err := r.Route(context.Background(), inbound("", "/status")); err == nil {
t.Error("expected error from Route when StatusCounts fails")
}
}
// -- /tasks tests --
type fakeChatTaskLister struct {
tasks []ChatTaskSummary
err error
}
func (f *fakeChatTaskLister) ListChatTasks(ctx context.Context, identity string, limit int) ([]ChatTaskSummary, error) {
return f.tasks, f.err
}
func TestRouteTasksNotConfigured(t *testing.T) {
r := NewRouter(nil, nil, "test")
reply, err := r.Route(context.Background(), inbound("", "/tasks"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if reply != "task list not configured" {
t.Errorf("reply = %q, want the not-configured message", reply)
}
}
func TestRouteTasksEmpty(t *testing.T) {
r := NewRouter(nil, nil, "test")
r.TaskLister = &fakeChatTaskLister{}
reply, err := r.Route(context.Background(), inbound("", "/tasks"))
if err != nil {
t.Fatalf("Route: %v", err)
}
want := "🗂 Archie tasks\n\nNo tasks yet"
if reply != want {
t.Errorf("reply = %q, want %q", reply, want)
}
}
func TestRouteTasksError(t *testing.T) {
r := NewRouter(nil, nil, "test")
r.TaskLister = &fakeChatTaskLister{err: errors.New("store unavailable")}
if _, err := r.Route(context.Background(), inbound("", "/tasks")); err == nil {
t.Error("expected error from Route when ListChatTasks fails")
}
}
func TestFormatTasks(t *testing.T) {
now := time.Date(2026, 9, 3, 12, 0, 0, 0, time.UTC)
tests := []struct {
name string
tasks []ChatTaskSummary
want string
}{
{
name: "running task shows workflow/stage and age",
tasks: []ChatTaskSummary{
{ID: 42, Title: "Fix login bug", Status: taskstate.Running, Workflow: "tdd", Stage: "implement", UpdatedAt: now.Add(-3 * time.Minute)},
},
want: "🗂 Archie tasks\n\n▶ #42 Fix login bug \n Running · tdd/implement · updated 3m ago",
},
{
// The criterion this command was built for: a bare "Running: 1"
// reads the same whether the task is making progress or wedged in a
// failure loop, and each task's own age is what tells them apart.
name: "a stuck running task does not read like one making progress",
tasks: []ChatTaskSummary{
{ID: 5, Title: "Wedged", Status: taskstate.Running, Workflow: "tdd", Stage: "implement", UpdatedAt: now.Add(-47 * time.Minute)},
{ID: 6, Title: "Working", Status: taskstate.Running, Workflow: "tdd", Stage: "implement", UpdatedAt: now.Add(-20 * time.Second)},
},
want: "🗂 Archie tasks\n\n▶ #5 Wedged \n Running · tdd/implement · updated 47m ago\n\n▶ #6 Working \n Running · tdd/implement · updated just now",
},
{
name: "parked task shows its reason",
tasks: []ChatTaskSummary{
{ID: 17, Title: "Add dark mode", Status: taskstate.Parked, Workflow: "feasibility", ParkReason: "gate failed 3x", UpdatedAt: now.Add(-2 * time.Hour)},
},
want: "🗂 Archie tasks\n\n⏸ #17 Add dark mode \n Parked · feasibility · updated 2h ago \n ↳ gate failed 3x",
},
{
name: "attempt is shown only once a retry has happened",
tasks: []ChatTaskSummary{
{ID: 1, Title: "First try", Status: taskstate.Running, Attempt: 1, UpdatedAt: now},
{ID: 2, Title: "Retried", Status: taskstate.Running, Attempt: 2, UpdatedAt: now},
},
want: "🗂 Archie tasks\n\n▶ #1 First try \n Running · updated just now\n\n▶ #2 Retried \n Running · attempt 2 · updated just now",
},
{
name: "an unrecognized status still renders, generically",
tasks: []ChatTaskSummary{
{ID: 9, Title: "Mystery", Status: "custom_state", UpdatedAt: now},
},
want: "🗂 Archie tasks\n\n• #9 Mystery \n Custom state · updated just now",
},
{
name: "actionable work leads terminal work regardless of recency",
tasks: []ChatTaskSummary{
{ID: 3, Title: "Just merged", Status: taskstate.Merged, UpdatedAt: now},
{ID: 4, Title: "Still running", Status: taskstate.Running, UpdatedAt: now.Add(-time.Hour)},
},
want: "🗂 Archie tasks\n\n▶ #4 Still running \n Running · updated 1h ago\n\n✅ #3 Just merged \n Merged · updated just now",
},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got := formatTasks(tc.tasks, now)
if got != tc.want {
t.Errorf("formatTasks() =\n%q\nwant:\n%q", got, tc.want)
}
})
}
}
func TestRouteNonCommandWithLLM(t *testing.T) {
r := NewRouter(nil, fakeLLM, "test")
reply, err := r.Route(context.Background(), inbound("", "hello"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if reply != "llm: hello" {
t.Errorf("reply = %q, want %q", reply, "llm: hello")
}
}
func TestRouteNonCommandWithoutLLM(t *testing.T) {
r := NewRouter(nil, nil, "test")
reply, err := r.Route(context.Background(), inbound("", "hello"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "/status") {
t.Errorf("reply = %q, want mention of /status", reply)
}
}
func TestRouterRejectsUnknownCommand(t *testing.T) {
tests := []string{
"/frobnicate",
"/frobnicate with arguments",
"/frobnicate@test with arguments",
}
for _, text := range tests {
t.Run(text, func(t *testing.T) {
llmCalls := 0
r := NewRouter(nil, func(context.Context, Inbound) (string, error) {
llmCalls++
return "fabricated command behavior", nil
}, "test")
r.LLMStream = func(context.Context, Inbound, TurnStream) (string, error) {
llmCalls++
return "fabricated streaming behavior", nil
}
reply, err := r.RouteStream(context.Background(), inbound("", text), DeltaFunc(func(string) {}))
if err != nil {
t.Fatalf("RouteStream: %v", err)
}
if llmCalls != 0 {
t.Fatalf("unknown command invoked LLM %d times", llmCalls)
}
if !strings.Contains(reply, "/frobnicate") || !strings.Contains(reply, "/help") {
t.Errorf("reply = %q, want unknown command and /help guidance", reply)
}
})
}
}
// -- ModelManager fakes for /model tests --
type fakeModelManager struct {
models []string
activeModel string
setErr error
}
type fakeProviderModelManager struct {
fakeModelManager
}
func (f *fakeProviderModelManager) Providers() []string {
return []string{"openai", "openrouter"}
}
func (f *fakeProviderModelManager) ActiveProvider() string {
provider, _, _ := strings.Cut(f.activeModel, "/")
return provider
}
func (f *fakeProviderModelManager) ModelsForProvider(provider string) []string {
var models []string
for _, model := range f.models {
if strings.HasPrefix(model, provider+"/") {
models = append(models, model)
}
}
return models
}
func (f *fakeProviderModelManager) SetActiveProvider(_ context.Context, provider string) error {
models := f.ModelsForProvider(provider)
if len(models) == 0 {
return fmt.Errorf("unknown provider: %s", provider)
}
f.activeModel = models[0]
return nil
}
func (f *fakeModelManager) Models() []string {
return f.models
}
func (f *fakeModelManager) ActiveModel() string {
return f.activeModel
}
func (f *fakeModelManager) SetActiveModel(_ context.Context, ref string) error {
if f.setErr != nil {
return f.setErr
}
if slices.Contains(f.models, ref) {
f.activeModel = ref
return nil
}
return fmt.Errorf("unknown model: %s", ref)
}
// -- /model tests --
func TestRouteModelsIsNoLongerACommand(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/models"))
if err != nil {
t.Fatal(err)
}
if !strings.Contains(reply, "Unknown command /models") {
t.Errorf("reply = %q, want /models to be unavailable", reply)
}
}
func TestRouteModelSwitch(t *testing.T) {
mgr := &fakeModelManager{
models: []string{"a/b", "c/d"},
}
r := NewRouter(nil, nil, "test-gw")
r.Models = mgr
reply, err := r.Route(context.Background(), inbound("", "/model a/b"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "a/b") || !strings.Contains(reply, "set to") {
t.Errorf("reply should confirm model switch: %q", reply)
}
if mgr.activeModel != "a/b" {
t.Errorf("active model = %q, want %q", mgr.activeModel, "a/b")
}
}
func TestRouteModelAtMention(t *testing.T) {
mgr := &fakeModelManager{
models: []string{"a/b"},
}
r := NewRouter(nil, nil, "test-gw")
r.Models = mgr
reply, err := r.Route(context.Background(), inbound("", "/model@test-gw a/b"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "a/b") {
t.Errorf("reply should confirm model switch: %q", reply)
}
}
func TestRouteModelUnknown(t *testing.T) {
mgr := &fakeModelManager{
models: []string{"a/b"},
}
r := NewRouter(nil, nil, "test-gw")
r.Models = mgr
reply, err := r.Route(context.Background(), inbound("", "/model unknown/unknown"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Cannot switch") {
t.Errorf("reply should mention cannot switch: %q", reply)
}
}
func TestRouteModelNoArg(t *testing.T) {
mgr := &fakeModelManager{
models: []string{"a/b", "c/d"},
}
r := NewRouter(nil, nil, "test-gw")
r.Models = mgr
reply, err := r.Route(context.Background(), inbound("", "/model"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Usage") || !strings.Contains(reply, "a/b") || !strings.Contains(reply, "c/d") {
t.Errorf("reply should show usage and available models: %q", reply)
}
}
func TestRouteModelNoManager(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/model a/b"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want 'not configured' message", reply)
}
}
// -- TaskCreator fakes for /spawn tests --
type fakeTaskCreator struct {
tasks []string
requests []SpawnRequest
createFn func(ctx context.Context, req SpawnRequest) (int64, error)
}
func (f *fakeTaskCreator) CreateTask(ctx context.Context, req SpawnRequest) (int64, error) {
f.tasks = append(f.tasks, req.Title)
f.requests = append(f.requests, req)
if f.createFn != nil {
return f.createFn(ctx, req)
}
return int64(len(f.tasks)), nil
}
func TestRouteSpawnCreatesTask(t *testing.T) {
tc := &fakeTaskCreator{}
r := NewRouter(nil, nil, "test-gw")
r.Tasks = tc
reply, err := r.Route(context.Background(), inbound("", "/spawn Fix the login bug"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Created task") || !strings.Contains(reply, "1") {
t.Errorf("reply should confirm task creation: %q", reply)
}
if len(tc.tasks) != 1 || tc.tasks[0] != "Fix the login bug" {
t.Errorf("tasks = %v, want [Fix the login bug]", tc.tasks)
}
}
func TestRouteSpawnAtMention(t *testing.T) {
tc := &fakeTaskCreator{}
r := NewRouter(nil, nil, "archie-bot")
r.Tasks = tc
reply, err := r.Route(context.Background(), inbound("", "/spawn@archie-bot Deploy the release"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Created task") {
t.Errorf("reply should confirm creation: %q", reply)
}
}
func TestRouteSpawnNoTitle(t *testing.T) {
tc := &fakeTaskCreator{}
r := NewRouter(nil, nil, "test-gw")
r.Tasks = tc
reply, err := r.Route(context.Background(), inbound("", "/spawn"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Usage") {
t.Errorf("reply should show usage: %q", reply)
}
if len(tc.tasks) != 0 {
t.Errorf("no task should be created without a title")
}
}
func TestRouteSpawnNoManager(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/spawn something"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want 'not configured'", reply)
}
}
func TestRouteSpawnHandlesCreationError(t *testing.T) {
tc := &fakeTaskCreator{
createFn: func(ctx context.Context, req SpawnRequest) (int64, error) {
return 0, fmt.Errorf("store unavailable")
},
}
r := NewRouter(nil, nil, "test-gw")
r.Tasks = tc
reply, err := r.Route(context.Background(), inbound("", "/spawn Break things"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Failed") {
t.Errorf("reply should mention failure: %q", reply)
}
}
func TestRouteSpawnParsesRepoAndWorkflow(t *testing.T) {
tc := &fakeTaskCreator{}
r := NewRouter(nil, nil, "test-gw")
r.Tasks = tc
r.Identity = "archie"
reply, err := r.Route(context.Background(), inbound("", "/spawn repo=acme/example-service workflow=tdd Fix the flaky test"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Created task") {
t.Errorf("reply = %q, want task creation confirmation", reply)
}
if len(tc.requests) != 1 {
t.Fatalf("requests = %d, want 1", len(tc.requests))
}
got := tc.requests[0]
if got.Repo != "acme/example-service" || got.Workflow != "tdd" || got.Title != "Fix the flaky test" || got.Identity != "archie" {
t.Errorf("request = %+v, want {Repo:acme/example-service Workflow:tdd Title:\"Fix the flaky test\" Identity:archie}", got)
}
}
func TestRouteSpawnParsesIdentity(t *testing.T) {
tc := &fakeTaskCreator{}
r := NewRouter(nil, nil, "test-gw")
r.Tasks = tc
r.Identity = "default"
reply, err := r.Route(context.Background(), inbound("", "/spawn identity=reviewer repo=acme/example-service workflow=tdd Fix the flaky test"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Created task") {
t.Errorf("reply = %q, want task creation confirmation", reply)
}
got := tc.requests[0]
if got.Identity != "reviewer" || got.Repo != "acme/example-service" || got.Workflow != "tdd" || got.Title != "Fix the flaky test" {
t.Errorf("request = %+v, want selected identity, repo, workflow, and full title", got)
}
}
func TestRouteSpawnWithoutRepoOrWorkflowUsesDefaults(t *testing.T) {
tc := &fakeTaskCreator{}
r := NewRouter(nil, nil, "test-gw")
r.Tasks = tc
reply, err := r.Route(context.Background(), inbound("", "/spawn Fix the login bug"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Created task") {
t.Errorf("reply = %q", reply)
}
got := tc.requests[0]
if got.Repo != "" || got.Workflow != "" || got.Title != "Fix the login bug" {
t.Errorf("request = %+v, want empty Repo/Workflow and full title", got)
}
}
func TestRouteSpawnTitleLooksLikeKeyValueIsPreserved(t *testing.T) {
// A title that happens to contain "=" after the repo=/workflow=
// tokens must not be mistaken for another key=value token.
tc := &fakeTaskCreator{}
r := NewRouter(nil, nil, "test-gw")
r.Tasks = tc
if _, err := r.Route(context.Background(), inbound("", "/spawn repo=acme/example-service Fix x=y in config")); err != nil {
t.Fatalf("Route: %v", err)
}
got := tc.requests[0]
if got.Repo != "acme/example-service" || got.Title != "Fix x=y in config" {
t.Errorf("request = %+v, want Repo:acme/example-service Title:\"Fix x=y in config\"", got)
}
}
// -- TaskController fakes for /approve and /cancel tests --
type fakeTaskController struct {
approveFn func(ctx context.Context, taskID int64, identity string) error
cancelFn func(ctx context.Context, taskID int64, identity string) error
approved []int64
cancelled []int64
identities []string
stopRunning []int64
stopRunningErr error
stoppedIdentities []string
}
func (f *fakeTaskController) Approve(ctx context.Context, taskID int64, identity string) error {
f.approved = append(f.approved, taskID)
f.identities = append(f.identities, identity)
if f.approveFn != nil {
return f.approveFn(ctx, taskID, identity)
}
return nil
}
func (f *fakeTaskController) Cancel(ctx context.Context, taskID int64, identity string) error {
f.cancelled = append(f.cancelled, taskID)
f.identities = append(f.identities, identity)
if f.cancelFn != nil {
return f.cancelFn(ctx, taskID, identity)
}
return nil
}
func (f *fakeTaskController) StopRunning(_ context.Context, identity string) ([]int64, error) {
f.stoppedIdentities = append(f.stoppedIdentities, identity)
return f.stopRunning, f.stopRunningErr
}
func TestRouteApproveParsesIdentity(t *testing.T) {
fc := &fakeTaskController{}
r := NewRouter(nil, nil, "test-gw")
r.Controller = fc
r.Identity = "default"
reply, err := r.Route(context.Background(), inbound("", "/approve identity=reviewer 42"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "approved") {
t.Errorf("reply = %q, want mention of approval", reply)
}
if len(fc.approved) != 1 || fc.approved[0] != 42 || fc.identities[0] != "reviewer" {
t.Errorf("approved/identities = %v/%v, want [42]/[reviewer]", fc.approved, fc.identities)
}
}
func TestRouteApproveSuccess(t *testing.T) {
fc := &fakeTaskController{}
r := NewRouter(nil, nil, "test-gw")
r.Controller = fc
reply, err := r.Route(context.Background(), inbound("", "/approve 42"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "approved") {
t.Errorf("reply = %q, want mention of approval", reply)
}
if len(fc.approved) != 1 || fc.approved[0] != 42 {
t.Errorf("approved = %v, want [42]", fc.approved)
}
}
func TestRouteApproveNotConfigured(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/approve 1"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want 'not configured'", reply)
}
}
func TestRouteApproveBadID(t *testing.T) {
fc := &fakeTaskController{}
r := NewRouter(nil, nil, "test-gw")
r.Controller = fc
reply, err := r.Route(context.Background(), inbound("", "/approve notanumber"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Usage") {
t.Errorf("reply = %q, want usage message", reply)
}
if len(fc.approved) != 0 {
t.Error("Approve must not be called with an invalid ID")
}
}
func TestRouteApproveWrongStateSurfacesError(t *testing.T) {
fc := &fakeTaskController{
approveFn: func(ctx context.Context, taskID int64, identity string) error {
return fmt.Errorf("task is queued, not waiting_human")
},
}
r := NewRouter(nil, nil, "test-gw")
r.Controller = fc
reply, err := r.Route(context.Background(), inbound("", "/approve 7"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Cannot approve") || !strings.Contains(reply, "waiting_human") {
t.Errorf("reply = %q, want error surfaced to user", reply)
}
}
func TestRouteCancelSuccess(t *testing.T) {
fc := &fakeTaskController{}
r := NewRouter(nil, nil, "test-gw")
r.Controller = fc
reply, err := r.Route(context.Background(), inbound("", "/cancel 5"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "cancelled") {
t.Errorf("reply = %q, want mention of cancellation", reply)
}
if len(fc.cancelled) != 1 || fc.cancelled[0] != 5 {
t.Errorf("cancelled = %v, want [5]", fc.cancelled)
}
}
func TestRouteCancelParsesIdentity(t *testing.T) {
fc := &fakeTaskController{}
r := NewRouter(nil, nil, "test-gw")
r.Controller = fc
r.Identity = "default"
reply, err := r.Route(context.Background(), inbound("", "/cancel identity=reviewer 5"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "cancelled") {
t.Errorf("reply = %q, want mention of cancellation", reply)
}
if len(fc.cancelled) != 1 || fc.cancelled[0] != 5 || fc.identities[0] != "reviewer" {
t.Errorf("cancelled/identities = %v/%v, want [5]/[reviewer]", fc.cancelled, fc.identities)
}
}
func TestRouteCancelCrossIdentityRejected(t *testing.T) {
fc := &fakeTaskController{
cancelFn: func(ctx context.Context, taskID int64, identity string) error {
if identity != "archie" {
return fmt.Errorf("task belongs to a different identity")
}
return nil
},
}
r := NewRouter(nil, nil, "test-gw")
r.Controller = fc
r.Identity = "winter"
reply, err := r.Route(context.Background(), inbound("", "/cancel 9"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Cannot cancel") || !strings.Contains(reply, "different identity") {
t.Errorf("reply = %q, want cross-identity rejection surfaced", reply)
}
}
func TestRouteCancelNotConfigured(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/cancel 1"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want 'not configured'", reply)
}
}
// -- /whoami tests --
func TestRouteWhoami(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Identity = "archie"
reply, err := r.Route(context.Background(), inbound("", "/whoami"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "archie") {
t.Errorf("reply = %q, want mention of identity", reply)
}
}
func TestRouteWhoamiNoIdentity(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/whoami"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Archie") {
t.Errorf("reply = %q, want mention of Archie", reply)
}
}
func TestRouteWhoamiWithModel(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Identity = "archie"
r.Models = &fakeModelManager{
models: []string{"a/b", "c/d"},
activeModel: "a/b",
}
reply, err := r.Route(context.Background(), inbound("", "/whoami"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "archie") || !strings.Contains(reply, "a/b") {
t.Errorf("reply = %q, want identity and model", reply)
}
}
// -- /profile tests --
func TestRouteProfile(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Identity = "archie"
r.Models = &fakeModelManager{
models: []string{"a/b", "c/d"},
activeModel: "a/b",
}
reply, err := r.Route(context.Background(), inbound("", "/profile"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "archie") || !strings.Contains(reply, "a/b") {
t.Errorf("reply = %q, want identity and model", reply)
}
}
func TestRouteProfileNoIdentity(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/profile"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want mention of not configured", reply)
}
}
// -- /sessions tests --
type fakeSessionLister struct {
*fakeSessionStore
sessions []SessionContext
err error
}
func (f *fakeSessionLister) List(ctx context.Context) ([]SessionContext, error) {
return f.sessions, f.err
}
func TestRouteSessionsEmpty(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{fakeSessionStore: newFakeSessionStore()}
reply, err := r.Route(context.Background(), inbound("", "/sessions"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "No sessions") {
t.Errorf("reply = %q, want 'No sessions'", reply)
}
}
func TestRouteSessionsNotConfigured(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/sessions"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want 'not configured'", reply)
}
}
func TestRouteSessionsError(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{fakeSessionStore: newFakeSessionStore(), err: fmt.Errorf("store unavailable")}
_, err := r.Route(context.Background(), inbound("", "/sessions"))
if err == nil {
t.Error("expected error from Route when List fails")
}
}
// -- /resume tests --
func TestRouteResumeNoArg(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{fakeSessionStore: newFakeSessionStore()}
reply, err := r.Route(context.Background(), inbound("", "/resume"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Usage") {
t.Errorf("reply = %q, want usage", reply)
}
}
func TestRouteResumeNotConfigured(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/resume abc"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want 'not configured'", reply)
}
}
func TestRouteResumeNoMatch(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{
fakeSessionStore: newFakeSessionStore(),
sessions: []SessionContext{
{SessionID: "session-1"},
},
}
reply, err := r.Route(context.Background(), inbound("", "/resume xyz"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "No session matching") {
t.Errorf("reply = %q, want 'No session matching'", reply)
}
}
func TestRouteResumeAmbiguous(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{
fakeSessionStore: newFakeSessionStore(),
sessions: []SessionContext{
{SessionID: "abc-123"},
{SessionID: "abc-456"},
},
}
reply, err := r.Route(context.Background(), inbound("", "/resume abc"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Multiple sessions") {
t.Errorf("reply = %q, want 'Multiple sessions'", reply)
}
}
func TestRouteResumeExactMatch(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Sessions = &fakeSessionLister{
fakeSessionStore: newFakeSessionStore(),
sessions: []SessionContext{
{SessionID: "abc-123"},
{SessionID: "abc-456"},
},
}
reply, err := r.Route(context.Background(), inbound("", "/resume abc-123"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Resumed session") {
t.Errorf("reply = %q, want 'Resumed session'", reply)
}
}
// -- /agents tests --
type fakeAgentReader struct {
agents []AgentInfo
err error
}
func (f *fakeAgentReader) AgentList(ctx context.Context) ([]AgentInfo, error) {
if f.err != nil {
return nil, f.err
}
return f.agents, nil
}
func TestRouteAgentsEmpty(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Agents = &fakeAgentReader{}
reply, err := r.Route(context.Background(), inbound("", "/agents"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "No active agents") {
t.Errorf("reply = %q, want 'No active agents'", reply)
}
}
func TestRouteAgentsNotConfigured(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
reply, err := r.Route(context.Background(), inbound("", "/agents"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "not configured") {
t.Errorf("reply = %q, want 'not configured'", reply)
}
}
func TestRouteAgentsWithTasks(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Agents = &fakeAgentReader{
agents: []AgentInfo{
{ID: 1, Title: "Fix the bug", Status: "running", Identity: "archie"},
{ID: 2, Title: "Add tests", Status: "waiting_human", Identity: "archie"},
},
}
reply, err := r.Route(context.Background(), inbound("", "/agents"))
if err != nil {
t.Fatalf("Route: %v", err)
}
if !strings.Contains(reply, "Fix the bug") || !strings.Contains(reply, "Add tests") {
t.Errorf("reply = %q, want task titles", reply)
}
if !strings.Contains(reply, "running") || !strings.Contains(reply, "waiting_human") {
t.Errorf("reply = %q, want task statuses", reply)
}
}
func TestRouteAgentsError(t *testing.T) {
r := NewRouter(nil, nil, "test-gw")
r.Agents = &fakeAgentReader{err: fmt.Errorf("store unavailable")}
_, err := r.Route(context.Background(), inbound("", "/agents"))
if err == nil {
t.Error("expected error from Route when AgentList fails")
}
}
func TestLocalCommandsIncludesNewCommands(t *testing.T) {
cmds := LocalCommands()
for _, want := range []string{"/whoami", "/profile", "/sessions", "/resume", "/agents", "/tasks"} {
if !slices.Contains(cmds, want) {
t.Errorf("LocalCommands() missing %s", want)
}
}
}
// The two command surfaces must describe the same set: /help lists the
// names, adapters publish the specs, and a command in one but not the
// other is either undiscoverable or advertised without an implementation.
func TestLocalCommandSpecsAndCommandsAgree(t *testing.T) {
names := LocalCommands()
specs := LocalCommandSpecs()
specified := make(map[string]bool, len(specs))
for _, s := range specs {
specified[s.Command] = true
if !slices.Contains(names, s.Command) {
t.Errorf("LocalCommandSpecs() advertises %s, which Route does not handle", s.Command)
}
}
for _, name := range names {
if !specified[name] {
t.Errorf("LocalCommandSpecs() is missing %s", name)
}
}
}
// TestSummarizeParkReasonBoundsAToolLog is the regression case for a single
// parked task swamping /tasks. A gate failure parks the task with the tool's
// whole output -- Sam's #10 carried a multi-line golangci-lint dump, warnings
// and all -- which the list view rendered verbatim, pushing every other task
// out of the reply.
func TestSummarizeParkReasonBoundsAToolLog(t *testing.T) {
reason := "stage fix: agent parked (gate_parked): [golangci-lint] golangci-lint run ./...\n" +
"level=warning msg=\"[formatter] gofumpt: extra-rules is deprecated\"\n" +
"scratchverify/main.go:38:1: calculated cyclomatic complexity for function run is 16, max is 15 (cyclop)\n" +
"1 issues:\n- cyclop: 1"
got := summarizeParkReason(reason)
if strings.ContainsAny(got, "\n\r") {
t.Fatalf("summarizeParkReason() = %q, want a single line", got)
}
if len([]rune(got)) > parkReasonMaxRunes+3 {
t.Fatalf("summarizeParkReason() is %d runes, want at most %d plus the ellipsis",
len([]rune(got)), parkReasonMaxRunes)
}
if !strings.HasPrefix(got, "stage fix: agent parked") {
t.Fatalf("summarizeParkReason() = %q, want it to keep the leading reason", got)
}
}
// TestSummarizeParkReasonKeepsAShortReasonIntact pins that the common case --
// a one-line reason an operator can act on -- is passed through untouched.
func TestSummarizeParkReasonKeepsAShortReasonIntact(t *testing.T) {
const reason = "diff is 789 changed lines (cap 400) -- split the issue or approve manually"
if got := summarizeParkReason(reason); got != reason {
t.Fatalf("summarizeParkReason() = %q, want it unchanged", got)
}
}