The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
package dashboard
import (
"encoding/json"
"math"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/diagnostics"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/endpoint/lifecycle"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/learning"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/testenv"
"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/tokens"
"github.com/asymptote-labs/agent-beacon/pkg/asymptoteobserve"
)
func TestStatusUsesRequestedRuntimeLogSource(t *testing.T) {
oldResolveRuntimeLog := resolveRuntimeLog
oldGetEndpointStatus := getEndpointStatus
t.Cleanup(func() {
resolveRuntimeLog = oldResolveRuntimeLog
getEndpointStatus = oldGetEndpointStatus
})
dir := t.TempDir()
systemLog := filepath.Join(dir, "system-runtime.jsonl")
userLog := filepath.Join(dir, "user-runtime.jsonl")
warning := "system collector is writing OTLP events to " + systemLog
resolveRuntimeLog = func(userMode bool, logPath string) lifecycle.RuntimeLogSource {
if !userMode || logPath != "" {
t.Fatalf("ResolveRuntimeLog called with userMode=%t logPath=%q, want requested user mode with empty log path", userMode, logPath)
}
return lifecycle.RuntimeLogSource{
RequestedUserMode: true,
EffectiveUserMode: false,
RequestedLogPath: userLog,
EffectiveLogPath: systemLog,
Warning: warning,
}
}
getEndpointStatus = func(userMode bool, logPath string) lifecycle.Status {
if !userMode || logPath != "" {
t.Fatalf("GetStatus called with userMode=%t logPath=%q, want requested user mode with empty log path", userMode, logPath)
}
return lifecycle.Status{
Version: "test",
ConfigPath: "system-config.json",
LogPath: systemLog,
Diagnostics: []diagnostics.Check{{
Name: "runtime_log_source",
Status: "warn",
Severity: "medium",
Message: warning,
}},
}
}
if err := os.WriteFile(systemLog, []byte(`{"timestamp":"2026-06-11T10:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"test","category":"test"},"severity":"info","endpoint":{"os":"darwin"},"message":"system event"}`+"\n"), 0644); err != nil {
t.Fatalf("write system log: %v", err)
}
handler, err := Handler(Options{UserMode: true})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/status", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var status StatusResponse
if err := json.Unmarshal(rec.Body.Bytes(), &status); err != nil {
t.Fatalf("unmarshal status response: %v", err)
}
if status.LogPath != systemLog || status.RuntimeLog.EffectiveLogPath != systemLog || status.RuntimeLog.Warning != warning {
t.Fatalf("status runtime log = %#v log_path=%q, want effective system log with warning", status.RuntimeLog, status.LogPath)
}
if !strings.Contains(rec.Body.String(), "runtime_log_source") {
t.Fatalf("status body missing runtime log diagnostic: %s", rec.Body.String())
}
req = httptest.NewRequest(http.MethodGet, "/api/events", nil)
rec = httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("events status code = %d, body = %s", rec.Code, rec.Body.String())
}
if !strings.Contains(rec.Body.String(), "system event") {
t.Fatalf("events body did not read effective system log: %s", rec.Body.String())
}
}
// TestSummaryEndpointAggregatesAllMatchedEvents guards /api/summary against
// truncated aggregation: total_events comes from the full match count, so the
// breakdown counts must be computed over the same full set even when the
// request carries a small ?limit= from the Agent Activity Sessions view.
func TestSummaryEndpointAggregatesAllMatchedEvents(t *testing.T) {
logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
mk := func(minute int) string {
return `{"timestamp":"2026-06-11T10:` + itoa2(minute) + `:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"command.executed","category":"command"},"severity":"info","endpoint":{"os":"darwin"},"harness":{"name":"cursor"},"session":{"id":"s1"},"command":{"command":"ls"},"message":"command.executed"}`
}
var lines []string
for i := 0; i < 12; i++ {
lines = append(lines, mk(i))
}
if err := os.WriteFile(logPath, []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
t.Fatalf("write fixture log: %v", err)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/summary?limit=5", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var summary Summary
if err := json.Unmarshal(rec.Body.Bytes(), &summary); err != nil {
t.Fatalf("unmarshal summary: %v", err)
}
if summary.TotalEvents != 12 {
t.Fatalf("total_events = %d, want 12", summary.TotalEvents)
}
if summary.CountsByHarness["cursor"] != 12 {
t.Fatalf("counts_by_harness[cursor] = %d, want 12 (must not be capped by ?limit=5)", summary.CountsByHarness["cursor"])
}
if summary.CommandEvents != 12 {
t.Fatalf("command_events = %d, want 12", summary.CommandEvents)
}
if len(summary.TopHarnesses) != 1 || summary.TopHarnesses[0].Count != 12 {
t.Fatalf("top_harnesses = %#v, want cursor with 12 events", summary.TopHarnesses)
}
}
func TestMemoryEndpointServesReadOnlyLearningState(t *testing.T) {
dir := t.TempDir()
logPath := filepath.Join(dir, "endpoint", "logs", "runtime.jsonl")
if err := os.MkdirAll(filepath.Dir(logPath), 0755); err != nil {
t.Fatal(err)
}
store := learning.Open(learning.PathForRuntimeLog(logPath))
project := asymptoteobserve.LearningProjectV1{ID: "project-1"}
eval := asymptoteobserve.LearningEvaluationV1{
ID: "eval-1",
Status: asymptoteobserve.LearningEvaluationStatusCompleted,
Project: project,
RubricVersion: "rubric",
RubricHash: "sha256:rubric",
Evaluator: "jev",
Trace: asymptoteobserve.LearningTraceRefV1{ID: "trace-1", Title: "Fix package smoke"},
Score: 0.9,
}
if err := store.PutEvaluation(eval); err != nil {
t.Fatal(err)
}
candidate := asymptoteobserve.LearningCandidateV1{
ID: "candidate-1",
State: asymptoteobserve.LearningCandidateStateApproved,
Kind: asymptoteobserve.LearningMemoryKindDebuggingPattern,
Title: "Fix package smoke",
Body: "Rerun once after a transient failure.",
Project: project,
SourceEvaluationID: "eval-1",
MemoryID: "memory-1",
}
if err := store.PutCandidate(candidate); err != nil {
t.Fatal(err)
}
if err := store.PutMemory(asymptoteobserve.LearningMemoryV1{
ID: "memory-1",
CandidateID: candidate.ID,
Kind: candidate.Kind,
Title: candidate.Title,
Body: candidate.Body,
Project: project,
}); err != nil {
t.Fatal(err)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/memory", nil))
if rec.Code != http.StatusOK {
t.Fatalf("memory status = %d body=%s", rec.Code, rec.Body.String())
}
var resp MemoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatal(err)
}
if resp.Status.Evaluations != 1 || len(resp.Evaluations) != 1 || len(resp.Candidates) != 1 || len(resp.Memories) != 1 {
t.Fatalf("memory response = %#v", resp)
}
}
func itoa2(v int) string {
if v < 10 {
return "0" + strconv.Itoa(v)
}
return strconv.Itoa(v)
}
func TestTokensEndpointAggregatesUsage(t *testing.T) {
logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
lines := []string{
`{"timestamp":"2026-06-11T09:59:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"session.context","category":"session"},"severity":"info","endpoint":{"os":"darwin"},"user":{"name":"alice","uid":"501"},"harness":{"name":"claude_code"},"session":{"id":"local-session"},"message":"Session context observed"}`,
// Claude Code metric datapoint events (delta temporality).
`{"timestamp":"2026-06-11T10:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"token.usage","category":"metric"},"severity":"info","endpoint":{"os":"darwin"},"harness":{"name":"claude_code"},"session":{"id":"local-session"},"model":"claude-sonnet-4-5","gen_ai":{"usage":{"input_tokens":100}},"message":"claude_code.token.usage","raw":{"metric_name":"claude_code.token.usage","metric_temporality":"Delta"}}`,
`{"timestamp":"2026-06-11T10:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"token.usage","category":"metric"},"severity":"info","endpoint":{"os":"darwin"},"harness":{"name":"claude_code"},"session":{"id":"local-session"},"model":"claude-sonnet-4-5","gen_ai":{"usage":{"output_tokens":40}},"message":"claude_code.token.usage","raw":{"metric_name":"claude_code.token.usage","metric_temporality":"Delta"}}`,
`{"timestamp":"2026-06-11T10:05:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"cost.usage","category":"metric"},"severity":"info","endpoint":{"os":"darwin"},"harness":{"name":"claude_code"},"session":{"id":"local-session"},"model":"claude-sonnet-4-5","gen_ai":{"usage":{"cost_usd":0.5}},"message":"claude_code.cost.usage","raw":{"metric_name":"claude_code.cost.usage","metric_temporality":"Delta"}}`,
// Cloud SDK span usage with trace identity.
`{"timestamp":"2026-06-11T11:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"tool.invoked","category":"tool"},"severity":"info","endpoint":{"os":"linux"},"harness":{"name":"asymptote_observe"},"origin":"cloud","session":{"id":"cloud-session"},"trace":{"id":"trace-1","span_id":"span-1"},"model":"gpt-4o-mini","gen_ai":{"usage":{"input_tokens":60,"output_tokens":20}},"message":"agent.step"}`,
}
if err := os.WriteFile(logPath, []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
t.Fatalf("write fixture log: %v", err)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/tokens?bucket=1h", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var report tokens.Report
if err := json.Unmarshal(rec.Body.Bytes(), &report); err != nil {
t.Fatalf("unmarshal tokens report: %v", err)
}
if report.Totals.InputTokens != 160 || report.Totals.OutputTokens != 60 || report.Totals.CostUSD != 0.5 {
t.Fatalf("totals = %#v", report.Totals)
}
// The list-price estimate rides beside the reported cost: claude-sonnet-4-5 100 x $3 + 40 x
// $15 per MTok, plus gpt-4o-mini 60 x $0.15 + 20 x $0.60 = $0.000921. The Claude session
// reported its cost, so its effective cost is that; the cloud session's is its estimate.
if report.Totals.EstimatedCostUSD != 0.000921 || report.Totals.CostSource != tokens.CostSourceMixed ||
math.Abs(report.Totals.EffectiveCostUSD-0.500021) > 1e-12 {
t.Fatalf("cost fields = %#v", report.Totals)
}
if report.Pricing == nil || report.Pricing.Catalog.Commit == "" || len(report.Pricing.Models) != 2 {
t.Fatalf("pricing = %#v", report.Pricing)
}
if len(report.ByModel) != 2 || report.ByModel[0].Key != "claude-sonnet-4-5" {
t.Fatalf("by_model = %#v", report.ByModel)
}
if len(report.BySession) != 2 {
t.Fatalf("by_session = %#v", report.BySession)
}
if len(report.ByUser) != 1 || report.ByUser[0].Key != "alice [501]" || report.ByUser[0].Usage.InputTokens != 100 {
t.Fatalf("by_user = %#v", report.ByUser)
}
if len(report.Series) != 2 {
t.Fatalf("series = %#v", report.Series)
}
// Session filter plus per-step detail for the cloud session.
req = httptest.NewRequest(http.MethodGet, "/api/tokens?session=cloud-session", nil)
rec = httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
report = tokens.Report{}
if err := json.Unmarshal(rec.Body.Bytes(), &report); err != nil {
t.Fatalf("unmarshal session tokens report: %v", err)
}
if report.Totals.InputTokens != 60 {
t.Fatalf("session totals = %#v", report.Totals)
}
if report.SessionDetail == nil || report.SessionDetail.SessionID != "cloud-session" || len(report.SessionDetail.Steps) != 1 {
t.Fatalf("session detail = %#v", report.SessionDetail)
}
if report.SessionDetail.Steps[0].SpanID != "span-1" || report.SessionDetail.Steps[0].Usage.InputTokens != 60 {
t.Fatalf("session step = %#v", report.SessionDetail.Steps[0])
}
}
func itoa(v int64) string { return strconv.FormatInt(v, 10) }
// TestTokensEndpointDedupesManySameSecondDatapoints reproduces a real Claude Code export: a batch of
// cumulative token.usage datapoints written to the log within the same second. ReadEvents returns
// events newest-first and breaks same-timestamp ties on lexicographic line IDs (line-9 > line-10),
// so the token endpoint must reorder by numeric append order before Aggregate, or the cumulative
// dedup misreads each step-down as a counter reset and sums the raw cumulative values.
func TestTokensEndpointDedupesManySameSecondDatapoints(t *testing.T) {
logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
var lines []string
for k := int64(1); k <= 12; k++ {
// Cumulative input k*100 -> per-interval delta of 100 each -> 1200 total.
lines = append(lines, `{"timestamp":"2026-06-11T10:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"token.usage","category":"metric"},"severity":"info","endpoint":{"os":"linux"},"harness":{"name":"claude_code"},"session":{"id":"s1"},"model":"claude-sonnet-4-5","gen_ai":{"usage":{"input_tokens":`+itoa(k*100)+`}},"message":"claude_code.token.usage","raw":{"metric_name":"claude_code.token.usage","metric_temporality":"Cumulative"}}`)
}
if err := os.WriteFile(logPath, []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
t.Fatalf("write fixture log: %v", err)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/tokens", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var report tokens.Report
if err := json.Unmarshal(rec.Body.Bytes(), &report); err != nil {
t.Fatalf("unmarshal tokens report: %v", err)
}
if report.Totals.InputTokens != 1200 {
t.Fatalf("cumulative input tokens = %d, want 1200", report.Totals.InputTokens)
}
}
// TestTokensEndpointSessionFilterIsExact guards against substring session
// matching: filtering session-1 must not fold in session-10's usage.
func TestTokensEndpointSessionFilterIsExact(t *testing.T) {
logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
mk := func(session string, input int64) string {
return `{"timestamp":"2026-06-11T10:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"token.usage","category":"metric"},"severity":"info","endpoint":{"os":"linux"},"harness":{"name":"claude_code"},"session":{"id":"` + session + `"},"model":"claude-sonnet-4-5","gen_ai":{"usage":{"input_tokens":` + itoa(input) + `}},"message":"claude_code.token.usage","raw":{"metric_name":"claude_code.token.usage","metric_temporality":"Delta"}}`
}
lines := []string{mk("session-1", 100), mk("session-10", 999)}
if err := os.WriteFile(logPath, []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
t.Fatalf("write fixture log: %v", err)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/tokens?session=session-1", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var report tokens.Report
if err := json.Unmarshal(rec.Body.Bytes(), &report); err != nil {
t.Fatalf("unmarshal tokens report: %v", err)
}
if report.Totals.InputTokens != 100 {
t.Fatalf("session-1 totals = %d, want 100 (session-10 must not fold in)", report.Totals.InputTokens)
}
if report.SessionDetail == nil || report.SessionDetail.Usage.InputTokens != 100 {
t.Fatalf("session detail = %#v, want exact session-1 usage", report.SessionDetail)
}
}
// TestTokensEndpointSessionFilterIsCaseInsensitive guards the token session
// filter against case mismatches: the event query matches sessions
// case-insensitively, so the post-filter and drilldown must too, or a
// differently-cased filter value returns zero usage for matching events.
func TestTokensEndpointSessionFilterIsCaseInsensitive(t *testing.T) {
logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
line := `{"timestamp":"2026-06-11T10:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"token.usage","category":"metric"},"severity":"info","endpoint":{"os":"linux"},"harness":{"name":"claude_code"},"session":{"id":"Session-ABC"},"model":"claude-sonnet-4-5","gen_ai":{"usage":{"input_tokens":123}},"message":"claude_code.token.usage","raw":{"metric_name":"claude_code.token.usage","metric_temporality":"Delta"}}`
if err := os.WriteFile(logPath, []byte(line+"\n"), 0644); err != nil {
t.Fatalf("write fixture log: %v", err)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/tokens?session=session-abc", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var report tokens.Report
if err := json.Unmarshal(rec.Body.Bytes(), &report); err != nil {
t.Fatalf("unmarshal tokens report: %v", err)
}
if report.Totals.InputTokens != 123 {
t.Fatalf("totals = %d, want 123 for case-insensitive session match", report.Totals.InputTokens)
}
if report.SessionDetail == nil || report.SessionDetail.Usage.InputTokens != 123 {
t.Fatalf("session detail = %#v, want case-insensitive match", report.SessionDetail)
}
}
func TestDetectionsEndpointListsBaselineRules(t *testing.T) {
testenv.SetHome(t, t.TempDir()) // empty store -> embedded baseline
handler, err := Handler(Options{UserMode: true, LogPath: filepath.Join(t.TempDir(), "runtime.jsonl")})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/detections", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var resp DetectionsResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("unmarshal detections: %v", err)
}
if resp.Count == 0 || resp.Count != len(resp.Rules) {
t.Fatalf("count = %d, rules = %d", resp.Count, len(resp.Rules))
}
for _, rule := range resp.Rules {
if rule.Source != "baseline" {
t.Fatalf("rule %q source = %q, want baseline", rule.ID, rule.Source)
}
if rule.ID == "" || rule.Severity == "" || rule.Kind == "" {
t.Fatalf("rule missing fields: %#v", rule)
}
}
}
func TestFindingsEndpointReturnsHitsLinkedToRules(t *testing.T) {
testenv.SetHome(t, t.TempDir()) // empty store -> embedded baseline
logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
// A destructive command the baseline "recursive-root-delete" rule matches.
line := `{"timestamp":"2026-06-11T10:00:00Z","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"command.executed","category":"command"},"severity":"info","endpoint":{"os":"darwin"},"harness":{"name":"claude_code"},"session":{"id":"local-session"},"command":{"command":"rm -rf /"},"message":"command.executed"}`
if err := os.WriteFile(logPath, []byte(line+"\n"), 0644); err != nil {
t.Fatalf("write fixture log: %v", err)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/findings", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var resp FindingsResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("unmarshal findings: %v", err)
}
if resp.Scanned != 1 {
t.Fatalf("scanned = %d, want 1", resp.Scanned)
}
found := false
for _, f := range resp.Findings {
if f.RuleID == "recursive-root-delete" {
found = true
}
}
if !found {
t.Fatalf("expected a recursive-root-delete finding, got %#v", resp.Findings)
}
// An out-of-range min_severity is rejected.
bad := httptest.NewRequest(http.MethodGet, "/api/findings?min_severity=nope", nil)
badRec := httptest.NewRecorder()
handler.ServeHTTP(badRec, bad)
if badRec.Code != http.StatusBadRequest {
t.Fatalf("invalid min_severity status = %d, want 400", badRec.Code)
}
}
func TestRunScanRejectsEmptyRuleSet(t *testing.T) {
testenv.SetHome(t, t.TempDir())
_, err := RunScan(true, filepath.Join(t.TempDir(), "runtime.jsonl"), t.TempDir(), "", "")
if err == nil {
t.Fatal("expected empty rule set to be rejected")
}
}
func TestInventoryEndpointReturnsConfigsAndMCPServers(t *testing.T) {
home := t.TempDir()
testenv.SetHome(t, home)
// A Claude Code user config declaring one MCP server, which the inventory
// scan should discover and surface.
claudeDir := filepath.Join(home, ".claude")
if err := os.MkdirAll(claudeDir, 0755); err != nil {
t.Fatalf("mkdir claude config dir: %v", err)
}
settings := `{"mcpServers":{"local-fs":{"command":"npx","args":["-y","server"],"env":{"FS_ROOT":"/tmp"}}}}`
if err := os.WriteFile(filepath.Join(claudeDir, "settings.json"), []byte(settings), 0644); err != nil {
t.Fatalf("write claude settings: %v", err)
}
skillDir := filepath.Join(claudeDir, "skills", "deploy")
if err := os.MkdirAll(skillDir, 0755); err != nil {
t.Fatalf("mkdir claude skill dir: %v", err)
}
if err := os.WriteFile(filepath.Join(skillDir, "SKILL.md"), []byte("# Deploy\nDo not retain this body."), 0644); err != nil {
t.Fatalf("write claude skill: %v", err)
}
handler, err := Handler(Options{UserMode: true, LogPath: filepath.Join(t.TempDir(), "runtime.jsonl")})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
req := httptest.NewRequest(http.MethodGet, "/api/inventory", nil)
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var resp InventoryResponse
if err := json.Unmarshal(rec.Body.Bytes(), &resp); err != nil {
t.Fatalf("unmarshal inventory response: %v", err)
}
if resp.GeneratedAt == "" {
t.Fatal("expected generated_at to be set")
}
if resp.UserScope.Mode == "" {
t.Fatalf("expected user scope mode, got %#v", resp.UserScope)
}
var claudeConfig *struct {
exists bool
mcp int
}
for _, config := range resp.Configs {
if config.Runtime == "claude_code" && config.Scope == "user" && config.Exists {
claudeConfig = &struct {
exists bool
mcp int
}{exists: true, mcp: config.MCPServerCount}
}
}
if claudeConfig == nil {
t.Fatalf("expected an existing claude_code user config in %#v", resp.Configs)
}
if claudeConfig.mcp != 1 {
t.Fatalf("claude config mcp_server_count = %d, want 1", claudeConfig.mcp)
}
found := false
for _, server := range resp.MCPServers {
if server.Runtime == "claude_code" && server.ServerName == "local-fs" {
found = true
if !server.CommandPresent || server.CommandName != "npx" {
t.Fatalf("server command = %#v, want npx command present", server)
}
}
}
if !found {
t.Fatalf("expected a local-fs MCP server, got %#v", resp.MCPServers)
}
foundSkill := false
for _, skill := range resp.Skills {
if skill.Runtime == "claude_code" && skill.SkillName == "deploy" {
foundSkill = true
if !skill.Exists || !skill.Readable || skill.FileSHA256 == "" {
t.Fatalf("skill metadata = %#v, want readable skill with hash", skill)
}
}
}
if !foundSkill {
t.Fatalf("expected deploy skill, got %#v", resp.Skills)
}
if strings.Contains(rec.Body.String(), "Do not retain this body") {
t.Fatalf("inventory response retained skill body: %s", rec.Body.String())
}
}
func TestStaticDashboardPagesServe(t *testing.T) {
handler, err := Handler(Options{UserMode: true, LogPath: filepath.Join(t.TempDir(), "runtime.jsonl")})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
for _, path := range []string{"/", "/session.html", "/overview.html", "/tokens.html", "/memory.html", "/detections.html", "/findings.html", "/inventory.html", "/inventory-hooks.html"} {
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
if rec.Code != http.StatusOK || !strings.HasPrefix(rec.Header().Get("Content-Type"), "text/html") {
t.Errorf("GET %s = %d %q, want an HTML page", path, rec.Code, rec.Header().Get("Content-Type"))
}
}
}
func TestRequireLoopbackHostRejectsRebindingHosts(t *testing.T) {
handler := RequireLoopbackHost(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
}))
for host, want := range map[string]int{
"127.0.0.1:8765": http.StatusOK,
"127.0.0.1": http.StatusOK,
"localhost:8765": http.StatusOK,
"LOCALHOST:8765": http.StatusOK,
"[::1]:8766": http.StatusOK,
"[::1]": http.StatusOK,
"attacker.example:8765": http.StatusForbidden,
"localhost.attacker.example": http.StatusForbidden,
"192.168.1.20:8765": http.StatusForbidden,
"": http.StatusForbidden,
} {
req := httptest.NewRequest(http.MethodGet, "/api/events", nil)
req.Host = host
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != want {
t.Errorf("Host %q: status = %d, want %d", host, rec.Code, want)
}
}
}
// TestTokensEndpointCountsALiveAndBackfilledRequestOnce reads a Claude Code session the way the
// production readers hand it to the token report: matched events plus a reduced context set. The
// live OTLP channel's first event is the user_prompt log; the transcript stamps the request as it
// streamed, before the api_request log that reports the same usage lands. The cutover has to come
// from that first live event, which is neither a session.context row nor a usage record, or the
// backfilled copy of the session's first request is counted beside the live one.
func TestTokensEndpointCountsALiveAndBackfilledRequestOnce(t *testing.T) {
logPath := filepath.Join(t.TempDir(), "runtime.jsonl")
line := func(ts, method, action, usage string) string {
genAI := ""
if usage != "" {
genAI = `,"gen_ai":{"usage":` + usage + `}`
}
return `{"timestamp":"` + ts + `","vendor":"beacon","product":"endpoint-agent","schema_version":"1.0","event":{"kind":"agent_runtime","action":"` + action + `","category":"session"},"severity":"info","endpoint":{"os":"linux","hostname":"devbox"},"harness":{"name":"claude_code","collection_method":"` + method + `"},"session":{"id":"sess-live-poll"},"model":"claude-opus-4-6"` + genAI + `,"message":"` + action + `"}`
}
lines := []string{
line("2026-06-11T10:00:00Z", "otlp", "prompt.submitted", ""),
line("2026-06-11T10:00:02Z", "poll", "token.usage", `{"input_tokens":6,"output_tokens":120,"cache_read":{"input_tokens":40000}}`),
line("2026-06-11T10:00:06Z", "otlp", "token.usage", `{"input_tokens":6,"output_tokens":120,"cache_read":{"input_tokens":40000}}`),
}
if err := os.WriteFile(logPath, []byte(strings.Join(lines, "\n")+"\n"), 0644); err != nil {
t.Fatalf("write fixture log: %v", err)
}
events, contexts, err := ReadTokenEventsAppendOrder(logPath, EventQuery{NoLimit: true})
if err != nil {
t.Fatal(err)
}
report := tokens.AggregateScopedWithContexts(events, contexts, "", tokens.Options{})
if report.Totals.OutputTokens != 120 || report.Totals.CacheReadInputTokens != 40000 || report.SuppressedPollEvents != 1 {
t.Fatalf("totals = %+v suppressed = %d, want one request (output 120, cache read 40000) and the backfill copy suppressed", report.Totals, report.SuppressedPollEvents)
}
// A window that starts after the live channel's first event must not move the cutover.
windowed, windowContexts, err := ReadTokenEventsAppendOrder(logPath, EventQuery{NoLimit: true, Since: mustParseTime(t, "2026-06-11T10:00:01Z")})
if err != nil {
t.Fatal(err)
}
report = tokens.AggregateScopedWithContexts(windowed, windowContexts, "", tokens.Options{})
if report.Totals.OutputTokens != 120 || report.SuppressedPollEvents != 1 {
t.Fatalf("windowed totals = %+v suppressed = %d, want one request", report.Totals, report.SuppressedPollEvents)
}
handler, err := Handler(Options{UserMode: true, LogPath: logPath})
if err != nil {
t.Fatalf("Handler returned error: %v", err)
}
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/tokens", nil))
if rec.Code != http.StatusOK {
t.Fatalf("status code = %d, body = %s", rec.Code, rec.Body.String())
}
var served tokens.Report
if err := json.Unmarshal(rec.Body.Bytes(), &served); err != nil {
t.Fatalf("unmarshal tokens report: %v", err)
}
if served.Totals.OutputTokens != 120 {
t.Fatalf("/api/tokens output = %d, want 120 (the backfill copy counted twice gives 240)", served.Totals.OutputTokens)
}
}
func mustParseTime(t *testing.T, value string) time.Time {
t.Helper()
parsed, err := time.Parse(time.RFC3339, value)
if err != nil {
t.Fatal(err)
}
return parsed
}