* fix: address the Greptile findings on the merged PRs Four valid review findings from PRs #892, #893, #898 and #899, which were merged without the comments being read. - Config.Clone left the new diff-cap pointers aliased (#899, mine). Clone deep-copies every reference field, including the *bool beside it, so a clone could write the cap through to the published snapshot. Both the top-level field and the identity overrides are copied, with the clone test extended to cover them. - providerOutcomeRecorder.record could report an older call as the latest (#892). The completion time is taken before the lock, so two concurrent calls can reach the lock in the opposite order to their completion and the unconditional store overwrote the newer outcome. It now keeps the newer, via a recordAt seam that makes the reordering testable. - Curator model calls bypassed the recorder (#892). curatorLLMRunner calls the runtime directly, so a daemon whose only recent model traffic was curator work reported "no calls attempted yet" while the provider was demonstrably reachable. It records at its own adapter, and sendChatTurn's "single choke point" comment is corrected to say there are two. - A provider error reached /status raw (#892), unlike channel details, so a multiline or oversized error broke the one-line-per-fact layout. Both now share one bounded formatter. Found while fixing the curator path: agentexec.NewRuntime returns nil when no provider is configured, and a nil *runtime.Runtime panics on its first method call, so a curator asking for a completion took the daemon down. It now returns an error, and records nothing -- a local misconfiguration is not a provider call. Not fixed, filed instead: the shared lastPollAt masking a stuck identity, the container max-uptime callback resurrecting teardown bookkeeping, the dashboard dropping a served-only status filter on cold load, and the route registry test's line-by-line parser. * fix(build): drop goimports from the gate's formatter set `task check` spent 136 of its 167 seconds in `task fmt`, and 134 of those 136 in one formatter: goimports alone over the tree. golangci-lint's goimports formatter calls imports.Process once per file, which builds a fresh x/tools ProcessEnv each time, so internal/imports.getFixesWithSource re-reads modindex.Read($GOMODCACHE) per file. On this machine that index is 62.7 MiB / 2,081,070 lines (an 11 GiB module cache), and modindex's in-process memo does not take effect: 3 files read 187.9 MiB back, 15 files open the payload 15 times. That is ~53 GiB of I/O and CSV parsing per run, and it is linear at ~155 ms per file (122 files -> 18.8s, 864 -> 133.8s). Pointing the index cache elsewhere drops the same command to 3.9s. The same analyzer runs under `golangci-lint run`, so a cold cache pays it again: 169s cold with goimports, 31s without -- which is what CI and archied's own PR gate see, since only `fmt` never caches locally. Removing it costs no enforcement. gofumpt and gci remain, `task lint` still reports formatter drift as an issue, and the whole-tree fmt is now 2.2s with the tree byte-identical. What is given up is goimports' convenience of adding and removing import lines, which compile errors already cover. The examples/secret-engines exclusion stays: gofumpt and gci leave those Yaegi programs alone today, but the exclusion is the stated invariant that a formatter must not rewrite the imports of files it cannot type-check, and TestFormattersExcludeInterpretedSecretEngines holds it. Its comment no longer pins the reason to the formatter that was dropped. * fix(gateway): stop /status promising and mis-reporting health it cannot see Two findings from the cloud review of #892. Title generation no longer records chat-model health. It runs detached after a first turn under its own 30s bound and its error is swallowed by the caller, but it shared the process-wide outcome recorder, so a title that merely timed out overwrote the health line with "failed" -- reporting a broken provider on the strength of a call no user was waiting for. The /status command description no longer claims "workers" and "channels". Neither can render: newStatusHealth reads the container pool and the poll loop from boot, but the only production router.Health assignment is in setupGatewayChat, which runs solely in the archie-gateway process, where neither exists; channels is nil since the Messaging Service took the front-ends. Only the broker and chat-model lines actually appear, so that is what the help text now says. The underlying split -- daemon owns the facts, Gateway owns the Router -- is filed rather than patched here: it needs either a cross-process health contract or a ratified two-section /status, not a quick wire-up.
268 lines
8.3 KiB
Go
268 lines
8.3 KiB
Go
package gateway
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// fakeHealthSource is the seam the daemon supplies in production; the report
|
|
// it returns is fixed so each case pins one rendering rule.
|
|
type fakeHealthSource struct {
|
|
report HealthReport
|
|
}
|
|
|
|
func (f fakeHealthSource) Health() HealthReport { return f.report }
|
|
|
|
// TestFormatHealthRendersOnlyWhatWasReported pins the rule that makes /status
|
|
// trustworthy: a section the reporting process has no truthful source for is
|
|
// omitted, never rendered as a zero, a dash or a guess. A health surface that
|
|
// invents a value is worse than a thin one, because an operator cannot tell
|
|
// an invented "0" from a measured one.
|
|
func TestFormatHealthRendersOnlyWhatWasReported(t *testing.T) {
|
|
now := time.Date(2026, 9, 19, 12, 0, 0, 0, time.UTC)
|
|
past := func(d time.Duration) time.Time { return now.Add(-d) }
|
|
at := func(d time.Duration) *time.Time { v := past(d); return &v }
|
|
// The zero time is the daemon's "no pass has started yet" value, distinct
|
|
// from a stale timestamp.
|
|
var zeroTime time.Time
|
|
|
|
tests := []struct {
|
|
name string
|
|
report HealthReport
|
|
want string
|
|
}{
|
|
{
|
|
name: "no source wired reports nothing at all",
|
|
report: HealthReport{},
|
|
want: "",
|
|
},
|
|
{
|
|
name: "disconnected broker",
|
|
report: HealthReport{Broker: &BrokerHealth{}},
|
|
want: "Broker: disconnected",
|
|
},
|
|
{
|
|
name: "connected broker",
|
|
report: HealthReport{Broker: &BrokerHealth{Connected: true}},
|
|
want: "Broker: connected",
|
|
},
|
|
{
|
|
name: "worker pool with a configured cap",
|
|
report: HealthReport{Containers: &ContainerHealth{Active: 1, Cap: 4}},
|
|
want: "Containers: 1/4 active",
|
|
},
|
|
{
|
|
name: "worker pool with no configured cap renders no ratio",
|
|
// MaxConcurrency <= 0 means unlimited, so "2/0" would read as
|
|
// "at capacity" when it means the opposite.
|
|
report: HealthReport{Containers: &ContainerHealth{Active: 2}},
|
|
want: "Containers: 2 active",
|
|
},
|
|
{
|
|
name: "empty pool with a cap",
|
|
report: HealthReport{
|
|
Containers: &ContainerHealth{Cap: 3},
|
|
},
|
|
want: "Containers: 0/3 active",
|
|
},
|
|
{
|
|
name: "channels report their own lifecycle state",
|
|
report: HealthReport{Channels: []ChannelHealth{
|
|
{Name: "telegram", State: "running"},
|
|
{Name: "email", State: "failed", Detail: "dial tcp 127.0.0.1:2525: connection refused"},
|
|
}},
|
|
want: "Channels: telegram running · email failed (dial tcp 127.0.0.1:2525: connection refused)",
|
|
},
|
|
{
|
|
name: "a multi-line channel detail stays on one line",
|
|
report: HealthReport{Channels: []ChannelHealth{
|
|
{Name: "telegram", State: "failed", Detail: "getMe failed:\n 401 Unauthorized"},
|
|
}},
|
|
want: "Channels: telegram failed (getMe failed: 401 Unauthorized)",
|
|
},
|
|
{
|
|
name: "chat model with nothing attempted says so",
|
|
report: HealthReport{
|
|
ChatModel: &ChatModelHealth{},
|
|
},
|
|
want: "Chat model: no calls attempted yet",
|
|
},
|
|
{
|
|
name: "last chat model call succeeded",
|
|
report: HealthReport{
|
|
ChatModel: &ChatModelHealth{
|
|
Attempted: true,
|
|
Outcome: ChatModelOutcome{Model: "openai/gpt-5.6", At: past(30 * time.Second)},
|
|
},
|
|
},
|
|
want: "Chat model: ok just now (openai/gpt-5.6)",
|
|
},
|
|
{
|
|
name: "last chat model call failed, with its model and error",
|
|
report: HealthReport{
|
|
ChatModel: &ChatModelHealth{
|
|
Attempted: true,
|
|
Outcome: ChatModelOutcome{
|
|
Model: "openai/gpt-5.6",
|
|
At: past(4 * time.Minute),
|
|
Err: "401 Unauthorized",
|
|
},
|
|
},
|
|
},
|
|
want: "Chat model: failed 4m ago (openai/gpt-5.6): 401 Unauthorized",
|
|
},
|
|
{
|
|
name: "a call whose model is unknown still reports its outcome",
|
|
report: HealthReport{
|
|
ChatModel: &ChatModelHealth{
|
|
Attempted: true,
|
|
Outcome: ChatModelOutcome{At: past(2 * time.Minute), Err: "connection reset"},
|
|
},
|
|
},
|
|
want: "Chat model: failed 2m ago: connection reset",
|
|
},
|
|
{
|
|
name: "poller has not run a pass yet",
|
|
report: HealthReport{LastPoll: &zeroTime},
|
|
want: "Last poll: not yet",
|
|
},
|
|
{
|
|
name: "poller last ran minutes ago",
|
|
report: HealthReport{LastPoll: at(12 * time.Minute)},
|
|
want: "Last poll: 12m ago",
|
|
},
|
|
{
|
|
name: "every section present renders in one stable order",
|
|
report: HealthReport{
|
|
Broker: &BrokerHealth{Connected: true},
|
|
Containers: &ContainerHealth{Active: 1, Cap: 2},
|
|
Channels: []ChannelHealth{{Name: "telegram", State: "running"}},
|
|
ChatModel: &ChatModelHealth{
|
|
Attempted: true,
|
|
Outcome: ChatModelOutcome{Model: "openai/gpt-5.6", At: past(time.Minute)},
|
|
},
|
|
LastPoll: at(5 * time.Second),
|
|
},
|
|
want: strings.Join([]string{
|
|
"Broker: connected",
|
|
"Containers: 1/2 active",
|
|
"Channels: telegram running",
|
|
"Chat model: ok 1m ago (openai/gpt-5.6)",
|
|
"Last poll: just now",
|
|
// Joined with the report's hard line break: each of these is a
|
|
// line, and a plain "\n" soft-joins them into one paragraph
|
|
// in a Markdown-rendering channel.
|
|
}, reportLineBreak),
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
if got := formatHealth(tc.report, now); got != tc.want {
|
|
t.Errorf("formatHealth() =\n%q\nwant:\n%q", got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFormatStatusAppendsHealthToTheQueueLine pins the shape of the whole
|
|
// reply: the aggregate queue line keeps its place (Phase 1's own health
|
|
// signal), the health section follows it, and an unwired health source leaves
|
|
// the reply exactly as it was.
|
|
func TestFormatStatusAppendsHealthToTheQueueLine(t *testing.T) {
|
|
now := time.Date(2026, 9, 19, 12, 0, 0, 0, time.UTC)
|
|
tests := []struct {
|
|
name string
|
|
counts map[string]int
|
|
report HealthReport
|
|
want string
|
|
}{
|
|
{
|
|
name: "unwired health source",
|
|
counts: map[string]int{"running": 1},
|
|
want: "📊 Archie status\n\nQueue: 1 in flight (1 running) \nRuntime: not configured",
|
|
},
|
|
{
|
|
name: "wired health source",
|
|
counts: map[string]int{"running": 1},
|
|
report: HealthReport{Broker: &BrokerHealth{Connected: true}},
|
|
want: "📊 Archie status\n\nQueue: 1 in flight (1 running) \nBroker: connected \nRuntime: not configured",
|
|
},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
got := formatStatus(tc.counts, tc.report, nil, now)
|
|
if got != tc.want {
|
|
t.Errorf("formatStatus() =\n%q\nwant:\n%q", got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestHandleStatusReadsTheWiredHealthSource pins that /status asks the daemon
|
|
// for health rather than leaving the seam unread -- the failure mode this pins
|
|
// is a router field that exists, is set by composition, and is never called.
|
|
func TestHandleStatusReadsTheWiredHealthSource(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
health HealthSource
|
|
want string
|
|
absent string
|
|
}{
|
|
{
|
|
name: "health source wired",
|
|
health: fakeHealthSource{report: HealthReport{Broker: &BrokerHealth{Connected: true}}},
|
|
want: "Broker: connected",
|
|
},
|
|
{
|
|
name: "no health source",
|
|
health: nil,
|
|
absent: "Broker:",
|
|
},
|
|
}
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
r := NewRouter(&fakeStore{counts: map[string]int{}}, nil, "test")
|
|
r.Health = tc.health
|
|
|
|
reply, err := r.Route(context.Background(), inbound("", "/status"))
|
|
if err != nil {
|
|
t.Fatalf("Route: %v", err)
|
|
}
|
|
if tc.want != "" && !strings.Contains(reply, tc.want) {
|
|
t.Errorf("reply = %q, want contains %q", reply, tc.want)
|
|
}
|
|
if tc.absent != "" && strings.Contains(reply, tc.absent) {
|
|
t.Errorf("reply = %q, want no %q", reply, tc.absent)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestFormatChatModelBoundsTheProviderError pins that a provider error cannot
|
|
// break /status' one-line-per-fact layout. The error is whatever the provider
|
|
// returned, which for an HTML error page is neither short nor single-line, and
|
|
// unlike a channel detail it was passed through raw.
|
|
func TestFormatChatModelBoundsTheProviderError(t *testing.T) {
|
|
now := time.Now()
|
|
health := ChatModelHealth{
|
|
Attempted: true,
|
|
Outcome: ChatModelOutcome{
|
|
Model: "openai/gpt-5.6",
|
|
At: now.Add(-time.Minute),
|
|
Err: "502 Bad Gateway\n<html>\n<head><title>502</title></head>\n" + strings.Repeat("body text ", 40),
|
|
},
|
|
}
|
|
|
|
got := formatChatModel(health, now)
|
|
if strings.ContainsAny(got, "\n\r") {
|
|
t.Fatalf("formatChatModel() = %q, want a single line", got)
|
|
}
|
|
if len([]rune(got)) > maxChannelDetail+80 {
|
|
t.Fatalf("formatChatModel() is %d runes, want it bounded near maxChannelDetail (%d)",
|
|
len([]rune(got)), maxChannelDetail)
|
|
}
|
|
}
|