From aca753296b272f7e0073d3fd00fb3562932a1205 Mon Sep 17 00:00:00 2001 From: Clay Cantrell <77699867+claycantrell@users.noreply.github.com> Date: Sun, 25 Jan 2026 18:00:46 -0800 Subject: [PATCH] feat(web): comprehensive dashboard control panel with 13 data panels (#931) * feat(dashboard): comprehensive control panel with expand/collapse - Add 13 panels: Convoys, Polecats, Sessions, Activity, Mail, Merge Queue, Escalations, Rigs, Dogs, System Health, Open Issues, Hooks, Queues - Add Mayor status banner and Summary/Alerts section - Implement instant client-side expand/collapse (no page reload) - Add responsive grid layout for different window sizes - Parallel data fetching for faster load times - Color-coded mail by sender, chronological ordering - Full titles visible in expanded views (no truncation) - Auto-refresh every 10 seconds via HTMX * fix(web): update tests and lint for dashboard control panel - Update MockConvoyFetcher with 11 new interface methods - Update MockConvoyFetcherWithErrors with matching methods - Update test assertions for new template structure: - Section headers ("Gas Town Convoys" -> "Convoys") - Work status badges (badge-green, badge-yellow, badge-red) - CI/merge status display text - Empty state messages ("No active convoys") - Fix linting: explicit _, _ = for fmt.Sscanf returns Tests and linting now pass with the new dashboard features. * perf(web): add timeouts and error logging to dashboard Performance and reliability improvements: - Add 8-second overall fetch timeout to prevent stuck requests - Add per-command timeouts: 5s for bd/sqlite3, 10s for gh, 2s for tmux - Add helper functions runCmd() and runBdCmd() with context timeout - Add error logging for all 14 fetch operations - Handler now returns partial data if timeout occurs This addresses slow loading and "stuck" dashboard issues by ensuring commands cannot hang indefinitely. --- internal/web/fetcher.go | 985 +++++++++++++++- internal/web/handler.go | 264 ++++- internal/web/handler_test.go | 196 +++- internal/web/templates.go | 250 +++- internal/web/templates/convoy.html | 1758 +++++++++++++++++++++++----- internal/web/templates_test.go | 35 +- 6 files changed, 3046 insertions(+), 442 deletions(-) diff --git a/internal/web/fetcher.go b/internal/web/fetcher.go index 64e841b9..8c4ac4cf 100644 --- a/internal/web/fetcher.go +++ b/internal/web/fetcher.go @@ -2,10 +2,13 @@ package web import ( "bytes" + "context" "encoding/json" "fmt" + "os" "os/exec" "path/filepath" + "sort" "strings" "time" @@ -14,6 +17,51 @@ import ( "github.com/steveyegge/gastown/internal/workspace" ) +// Command timeout constants +const ( + cmdTimeout = 5 * time.Second // timeout for most commands + ghCmdTimeout = 10 * time.Second // longer timeout for GitHub API calls + tmuxCmdTimeout = 2 * time.Second // short timeout for tmux queries +) + +// runCmd executes a command with a timeout and returns stdout. +// Returns empty buffer on timeout or error. +func runCmd(timeout time.Duration, name string, args ...string) (*bytes.Buffer, error) { + ctx, cancel := context.WithTimeout(context.Background(), timeout) + defer cancel() + + cmd := exec.CommandContext(ctx, name, args...) + var stdout bytes.Buffer + cmd.Stdout = &stdout + + if err := cmd.Run(); err != nil { + if ctx.Err() == context.DeadlineExceeded { + return nil, fmt.Errorf("%s timed out after %v", name, timeout) + } + return nil, err + } + return &stdout, nil +} + +// runBdCmd executes a bd command with cmdTimeout in the specified beads directory. +func runBdCmd(beadsDir string, args ...string) (*bytes.Buffer, error) { + ctx, cancel := context.WithTimeout(context.Background(), cmdTimeout) + defer cancel() + + cmd := exec.CommandContext(ctx, "bd", args...) + cmd.Dir = beadsDir + var stdout bytes.Buffer + cmd.Stdout = &stdout + + if err := cmd.Run(); err != nil { + if ctx.Err() == context.DeadlineExceeded { + return nil, fmt.Errorf("bd timed out after %v", cmdTimeout) + } + return nil, err + } + return &stdout, nil +} + // LiveConvoyFetcher fetches convoy data from beads. type LiveConvoyFetcher struct { townRoot string @@ -37,14 +85,8 @@ func NewLiveConvoyFetcher() (*LiveConvoyFetcher, error) { // FetchConvoys fetches all open convoys with their activity data. func (f *LiveConvoyFetcher) FetchConvoys() ([]ConvoyRow, error) { // List all open convoy-type issues - listArgs := []string{"list", "--type=convoy", "--status=open", "--json"} - listCmd := exec.Command("bd", listArgs...) - listCmd.Dir = f.townBeads - - var stdout bytes.Buffer - listCmd.Stdout = &stdout - - if err := listCmd.Run(); err != nil { + stdout, err := runBdCmd(f.townBeads, "list", "--type=convoy", "--status=open", "--json") + if err != nil { return nil, fmt.Errorf("listing convoys: %w", err) } @@ -159,13 +201,9 @@ func (f *LiveConvoyFetcher) getTrackedIssues(convoyID string) []trackedIssueInfo // Query tracked dependencies from SQLite safeConvoyID := strings.ReplaceAll(convoyID, "'", "''") - // #nosec G204 -- sqlite3 path is from trusted config, convoyID is escaped - queryCmd := exec.Command("sqlite3", "-json", dbPath, - fmt.Sprintf(`SELECT depends_on_id, type FROM dependencies WHERE issue_id = '%s' AND type = 'tracks'`, safeConvoyID)) - - var stdout bytes.Buffer - queryCmd.Stdout = &stdout - if err := queryCmd.Run(); err != nil { + query := fmt.Sprintf(`SELECT depends_on_id, type FROM dependencies WHERE issue_id = '%s' AND type = 'tracks'`, safeConvoyID) + stdout, err := runCmd(cmdTimeout, "sqlite3", "-json", dbPath, query) + if err != nil { return nil } @@ -240,12 +278,8 @@ func (f *LiveConvoyFetcher) getIssueDetailsBatch(issueIDs []string) map[string]* args := append([]string{"show"}, issueIDs...) args = append(args, "--json") - // #nosec G204 -- bd is a trusted internal tool, args are issue IDs - showCmd := exec.Command("bd", args...) - var stdout bytes.Buffer - showCmd.Stdout = &stdout - - if err := showCmd.Run(); err != nil { + stdout, err := runCmd(cmdTimeout, "bd", args...) + if err != nil { return result } @@ -338,11 +372,9 @@ func (f *LiveConvoyFetcher) getSessionActivityForAssignee(assignee string) *time // Query tmux for session activity // Format: session_activity returns unix timestamp - cmd := exec.Command("tmux", "list-sessions", "-F", "#{session_name}|#{session_activity}", + stdout, err := runCmd(tmuxCmdTimeout, "tmux", "list-sessions", "-F", "#{session_name}|#{session_activity}", "-f", fmt.Sprintf("#{==:#{session_name},%s}", sessionName)) - var stdout bytes.Buffer - cmd.Stdout = &stdout - if err := cmd.Run(); err != nil { + if err != nil { return nil } @@ -372,10 +404,8 @@ func (f *LiveConvoyFetcher) getSessionActivityForAssignee(assignee string) *time func (f *LiveConvoyFetcher) getAllPolecatActivity() *time.Time { // List all tmux sessions matching gt-*-* pattern (polecat sessions) // Format: gt-{rig}-{polecat} - cmd := exec.Command("tmux", "list-sessions", "-F", "#{session_name}|#{session_activity}") - var stdout bytes.Buffer - cmd.Stdout = &stdout - if err := cmd.Run(); err != nil { + stdout, err := runCmd(tmuxCmdTimeout, "tmux", "list-sessions", "-F", "#{session_name}|#{session_activity}") + if err != nil { return nil } @@ -508,16 +538,11 @@ type prResponse struct { // fetchPRsForRepo fetches open PRs for a single repo. func (f *LiveConvoyFetcher) fetchPRsForRepo(repoFull, repoShort string) ([]MergeQueueRow, error) { - // #nosec G204 -- gh is a trusted CLI, repo is from registered rigs config - cmd := exec.Command("gh", "pr", "list", + stdout, err := runCmd(ghCmdTimeout, "gh", "pr", "list", "--repo", repoFull, "--state", "open", "--json", "number,title,url,mergeable,statusCheckRollup") - - var stdout bytes.Buffer - cmd.Stdout = &stdout - - if err := cmd.Run(); err != nil { + if err != nil { return nil, fmt.Errorf("fetching PRs for %s: %w", repoFull, err) } @@ -636,11 +661,12 @@ func (f *LiveConvoyFetcher) FetchPolecats() ([]PolecatRow, error) { registeredRigs[rigName] = true } + // Pre-fetch assigned issues map: assignee -> (issueID, title) + assignedIssues := f.getAssignedIssuesMap() + // Query all tmux sessions with window_activity for more accurate timing - cmd := exec.Command("tmux", "list-sessions", "-F", "#{session_name}|#{window_activity}") - var stdout bytes.Buffer - cmd.Stdout = &stdout - if err := cmd.Run(); err != nil { + stdout, err := runCmd(tmuxCmdTimeout, "tmux", "list-sessions", "-F", "#{session_name}|#{window_activity}") + if err != nil { // tmux not running or no sessions return nil, nil } @@ -693,6 +719,7 @@ func (f *LiveConvoyFetcher) FetchPolecats() ([]PolecatRow, error) { continue } activityTime := time.Unix(activityUnix, 0) + activityAge := time.Since(activityTime) // Get status hint - special handling for refinery var statusHint string @@ -702,24 +729,100 @@ func (f *LiveConvoyFetcher) FetchPolecats() ([]PolecatRow, error) { statusHint = f.getPolecatStatusHint(sessionName) } + // Look up assigned issue for this polecat + // Assignee format: "rigname/polecats/polecatname" + assignee := fmt.Sprintf("%s/polecats/%s", rig, polecat) + var issueID, issueTitle string + if issue, ok := assignedIssues[assignee]; ok { + issueID = issue.ID + issueTitle = issue.Title + // Keep full title - CSS handles overflow + } + + // Calculate work status based on activity age and issue assignment + workStatus := calculatePolecatWorkStatus(activityAge, issueID, polecat) + polecats = append(polecats, PolecatRow{ Name: polecat, Rig: rig, SessionID: sessionName, LastActivity: activity.Calculate(activityTime), StatusHint: statusHint, + IssueID: issueID, + IssueTitle: issueTitle, + WorkStatus: workStatus, }) } return polecats, nil } +// assignedIssue holds issue info for the assigned issues map. +type assignedIssue struct { + ID string + Title string +} + +// getAssignedIssuesMap returns a map of assignee -> assigned issue. +// Queries beads for all in_progress issues with assignees. +func (f *LiveConvoyFetcher) getAssignedIssuesMap() map[string]assignedIssue { + result := make(map[string]assignedIssue) + + // Query all in_progress issues (these are the ones being worked on) + stdout, err := runBdCmd(f.townBeads, "list", "--status=in_progress", "--json") + if err != nil { + return result // Return empty map on error + } + + var issues []struct { + ID string `json:"id"` + Title string `json:"title"` + Assignee string `json:"assignee"` + } + if err := json.Unmarshal(stdout.Bytes(), &issues); err != nil { + return result + } + + for _, issue := range issues { + if issue.Assignee != "" { + result[issue.Assignee] = assignedIssue{ + ID: issue.ID, + Title: issue.Title, + } + } + } + + return result +} + +// calculatePolecatWorkStatus determines the polecat's work status based on activity and assignment. +// Returns: "working", "stale", "stuck", or "idle" +func calculatePolecatWorkStatus(activityAge time.Duration, issueID, polecatName string) string { + // Refinery has special handling - it's always "working" if it has PRs + if polecatName == "refinery" { + return "working" + } + + // No issue assigned = idle + if issueID == "" { + return "idle" + } + + // Has issue - determine status based on activity + switch { + case activityAge < 5*time.Minute: + return "working" // Active recently + case activityAge < 30*time.Minute: + return "stale" // Might be thinking or stuck + default: + return "stuck" // Likely stuck - no activity for 30+ minutes + } +} + // getPolecatStatusHint captures the last non-empty line from a polecat's pane. func (f *LiveConvoyFetcher) getPolecatStatusHint(sessionName string) string { - cmd := exec.Command("tmux", "capture-pane", "-t", sessionName, "-p", "-J") - var stdout bytes.Buffer - cmd.Stdout = &stdout - if err := cmd.Run(); err != nil { + stdout, err := runCmd(tmuxCmdTimeout, "tmux", "capture-pane", "-t", sessionName, "-p", "-J") + if err != nil { return "" } @@ -800,3 +903,797 @@ func parseActivityTimestamp(s string) (int64, bool) { } return unix, true } + +// FetchMail fetches recent mail messages from the beads database. +func (f *LiveConvoyFetcher) FetchMail() ([]MailRow, error) { + // List all message-type issues (mail) + stdout, err := runBdCmd(f.townBeads, "list", "--type=message", "--json", "--limit=50") + if err != nil { + return nil, fmt.Errorf("listing mail: %w", err) + } + + var messages []struct { + ID string `json:"id"` + Title string `json:"title"` + Status string `json:"status"` + CreatedAt string `json:"created_at"` + Priority int `json:"priority"` + Assignee string `json:"assignee"` // "to" address stored here + CreatedBy string `json:"created_by"` // "from" address + Labels []string `json:"labels"` + } + if err := json.Unmarshal(stdout.Bytes(), &messages); err != nil { + return nil, fmt.Errorf("parsing mail list: %w", err) + } + + rows := make([]MailRow, 0, len(messages)) + for _, m := range messages { + // Parse timestamp + var timestamp time.Time + var age string + var sortKey int64 + if m.CreatedAt != "" { + if t, err := time.Parse(time.RFC3339, m.CreatedAt); err == nil { + timestamp = t + age = formatMailAge(time.Since(t)) + sortKey = t.Unix() + } + } + + // Determine priority string + priorityStr := "normal" + switch m.Priority { + case 0: + priorityStr = "urgent" + case 1: + priorityStr = "high" + case 2: + priorityStr = "normal" + case 3, 4: + priorityStr = "low" + } + + // Determine message type from labels + msgType := "notification" + for _, label := range m.Labels { + if label == "task" || label == "reply" || label == "scavenge" { + msgType = label + break + } + } + + // Format from/to addresses for display + from := formatAgentAddress(m.CreatedBy) + to := formatAgentAddress(m.Assignee) + + rows = append(rows, MailRow{ + ID: m.ID, + From: from, + FromRaw: m.CreatedBy, + To: to, + Subject: m.Title, + Timestamp: timestamp.Format("15:04"), + Age: age, + Priority: priorityStr, + Type: msgType, + Read: m.Status == "closed", + SortKey: sortKey, + }) + } + + // Sort by timestamp, newest first + sort.Slice(rows, func(i, j int) bool { + return rows[i].SortKey > rows[j].SortKey + }) + + return rows, nil +} + +// formatMailAge returns a human-readable age string. +func formatMailAge(d time.Duration) string { + if d < time.Minute { + return "just now" + } + if d < time.Hour { + return fmt.Sprintf("%dm ago", int(d.Minutes())) + } + if d < 24*time.Hour { + return fmt.Sprintf("%dh ago", int(d.Hours())) + } + return fmt.Sprintf("%dd ago", int(d.Hours()/24)) +} + +// formatAgentAddress shortens agent addresses for display. +// "gastown/polecats/Toast" -> "Toast (gastown)" +// "mayor/" -> "Mayor" +func formatAgentAddress(addr string) string { + if addr == "" { + return "—" + } + if addr == "mayor/" || addr == "mayor" { + return "Mayor" + } + + parts := strings.Split(addr, "/") + if len(parts) >= 3 && parts[1] == "polecats" { + return fmt.Sprintf("%s (%s)", parts[2], parts[0]) + } + if len(parts) >= 3 && parts[1] == "crew" { + return fmt.Sprintf("%s (%s/crew)", parts[2], parts[0]) + } + if len(parts) >= 2 { + return fmt.Sprintf("%s/%s", parts[0], parts[len(parts)-1]) + } + return addr +} + +// FetchRigs returns all registered rigs with their agent counts. +func (f *LiveConvoyFetcher) FetchRigs() ([]RigRow, error) { + // Load rigs config from mayor/rigs.json + rigsConfigPath := filepath.Join(f.townRoot, "mayor", "rigs.json") + rigsConfig, err := config.LoadRigsConfig(rigsConfigPath) + if err != nil { + return nil, fmt.Errorf("loading rigs config: %w", err) + } + + var rows []RigRow + for name, entry := range rigsConfig.Rigs { + row := RigRow{ + Name: name, + GitURL: entry.GitURL, + } + + rigPath := filepath.Join(f.townRoot, name) + + // Count polecats + polecatsDir := filepath.Join(rigPath, "polecats") + if entries, err := os.ReadDir(polecatsDir); err == nil { + for _, e := range entries { + if e.IsDir() && !strings.HasPrefix(e.Name(), ".") { + row.PolecatCount++ + } + } + } + + // Count crew + crewDir := filepath.Join(rigPath, "crew") + if entries, err := os.ReadDir(crewDir); err == nil { + for _, e := range entries { + if e.IsDir() && !strings.HasPrefix(e.Name(), ".") { + row.CrewCount++ + } + } + } + + // Check for witness + witnessPath := filepath.Join(rigPath, "witness") + if _, err := os.Stat(witnessPath); err == nil { + row.HasWitness = true + } + + // Check for refinery + refineryPath := filepath.Join(rigPath, "refinery", "rig") + if _, err := os.Stat(refineryPath); err == nil { + row.HasRefinery = true + } + + rows = append(rows, row) + } + + // Sort by name + sort.Slice(rows, func(i, j int) bool { + return rows[i].Name < rows[j].Name + }) + + return rows, nil +} + +// FetchDogs returns all dogs in the kennel with their state. +func (f *LiveConvoyFetcher) FetchDogs() ([]DogRow, error) { + kennelPath := filepath.Join(f.townRoot, "deacon", "dogs") + + entries, err := os.ReadDir(kennelPath) + if err != nil { + if os.IsNotExist(err) { + return nil, nil // No kennel yet + } + return nil, fmt.Errorf("reading kennel: %w", err) + } + + var rows []DogRow + for _, entry := range entries { + if !entry.IsDir() { + continue + } + name := entry.Name() + if strings.HasPrefix(name, ".") { + continue + } + + // Read dog state file + stateFile := filepath.Join(kennelPath, name, ".dog.json") + data, err := os.ReadFile(stateFile) + if err != nil { + continue // Not a valid dog + } + + var state struct { + Name string `json:"name"` + State string `json:"state"` + LastActive time.Time `json:"last_active"` + Work string `json:"work,omitempty"` + Worktrees map[string]string `json:"worktrees,omitempty"` + } + if err := json.Unmarshal(data, &state); err != nil { + continue + } + + rows = append(rows, DogRow{ + Name: state.Name, + State: state.State, + Work: state.Work, + LastActive: formatMailAge(time.Since(state.LastActive)), + RigCount: len(state.Worktrees), + }) + } + + // Sort by name + sort.Slice(rows, func(i, j int) bool { + return rows[i].Name < rows[j].Name + }) + + return rows, nil +} + +// FetchEscalations returns open escalations needing attention. +func (f *LiveConvoyFetcher) FetchEscalations() ([]EscalationRow, error) { + // List open escalations + stdout, err := runBdCmd(f.townBeads, "list", "--label=gt:escalation", "--status=open", "--json") + if err != nil { + return nil, nil // No escalations or bd not available + } + + var issues []struct { + ID string `json:"id"` + Title string `json:"title"` + CreatedAt string `json:"created_at"` + CreatedBy string `json:"created_by"` + Labels []string `json:"labels"` + Description string `json:"description"` + } + if err := json.Unmarshal(stdout.Bytes(), &issues); err != nil { + return nil, fmt.Errorf("parsing escalations: %w", err) + } + + var rows []EscalationRow + for _, issue := range issues { + row := EscalationRow{ + ID: issue.ID, + Title: issue.Title, + EscalatedBy: formatAgentAddress(issue.CreatedBy), + Severity: "medium", // default + } + + // Parse severity from labels + for _, label := range issue.Labels { + if strings.HasPrefix(label, "severity:") { + row.Severity = strings.TrimPrefix(label, "severity:") + } + if label == "acked" { + row.Acked = true + } + } + + // Calculate age + if issue.CreatedAt != "" { + if t, err := time.Parse(time.RFC3339, issue.CreatedAt); err == nil { + row.Age = formatMailAge(time.Since(t)) + } + } + + rows = append(rows, row) + } + + // Sort by severity (critical first), then by age + severityOrder := map[string]int{"critical": 0, "high": 1, "medium": 2, "low": 3} + sort.Slice(rows, func(i, j int) bool { + si, sj := severityOrder[rows[i].Severity], severityOrder[rows[j].Severity] + return si < sj + }) + + return rows, nil +} + +// FetchHealth returns system health status. +func (f *LiveConvoyFetcher) FetchHealth() (*HealthRow, error) { + row := &HealthRow{} + + // Read deacon heartbeat + heartbeatFile := filepath.Join(f.townRoot, "deacon", "heartbeat.json") + if data, err := os.ReadFile(heartbeatFile); err == nil { + var hb struct { + Timestamp time.Time `json:"timestamp"` + Cycle int64 `json:"cycle"` + HealthyAgents int `json:"healthy_agents"` + UnhealthyAgents int `json:"unhealthy_agents"` + } + if err := json.Unmarshal(data, &hb); err == nil { + row.DeaconCycle = hb.Cycle + row.HealthyAgents = hb.HealthyAgents + row.UnhealthyAgents = hb.UnhealthyAgents + age := time.Since(hb.Timestamp) + row.DeaconHeartbeat = formatMailAge(age) + row.HeartbeatFresh = age < 5*time.Minute + } + } else { + row.DeaconHeartbeat = "no heartbeat" + } + + // Check pause state + pauseFile := filepath.Join(f.townRoot, ".runtime", "deacon", "paused.json") + if data, err := os.ReadFile(pauseFile); err == nil { + var pause struct { + Paused bool `json:"paused"` + Reason string `json:"reason"` + } + if err := json.Unmarshal(data, &pause); err == nil { + row.IsPaused = pause.Paused + row.PauseReason = pause.Reason + } + } + + return row, nil +} + +// FetchQueues returns work queues and their status. +func (f *LiveConvoyFetcher) FetchQueues() ([]QueueRow, error) { + // List queue-type beads + stdout, err := runBdCmd(f.townBeads, "list", "--type=queue", "--json") + if err != nil { + return nil, nil // No queues or bd not available + } + + var queues []struct { + ID string `json:"id"` + Title string `json:"title"` + Status string `json:"status"` + Description string `json:"description"` + } + if err := json.Unmarshal(stdout.Bytes(), &queues); err != nil { + return nil, fmt.Errorf("parsing queues: %w", err) + } + + var rows []QueueRow + for _, q := range queues { + row := QueueRow{ + Name: q.Title, + Status: q.Status, + } + + // Parse counts from description (key: value format) + // Best-effort parsing - ignore Sscanf errors as missing/malformed data is acceptable + for _, line := range strings.Split(q.Description, "\n") { + line = strings.TrimSpace(line) + if strings.HasPrefix(line, "available_count:") { + _, _ = fmt.Sscanf(line, "available_count: %d", &row.Available) + } else if strings.HasPrefix(line, "processing_count:") { + _, _ = fmt.Sscanf(line, "processing_count: %d", &row.Processing) + } else if strings.HasPrefix(line, "completed_count:") { + _, _ = fmt.Sscanf(line, "completed_count: %d", &row.Completed) + } else if strings.HasPrefix(line, "failed_count:") { + _, _ = fmt.Sscanf(line, "failed_count: %d", &row.Failed) + } else if strings.HasPrefix(line, "status:") { + // Override with parsed status if present + var s string + _, _ = fmt.Sscanf(line, "status: %s", &s) + if s != "" { + row.Status = s + } + } + } + + rows = append(rows, row) + } + + return rows, nil +} + +// FetchSessions returns active tmux sessions with role detection. +func (f *LiveConvoyFetcher) FetchSessions() ([]SessionRow, error) { + // List tmux sessions + stdout, err := runCmd(tmuxCmdTimeout, "tmux", "list-sessions", "-F", "#{session_name}:#{session_activity}") + if err != nil { + return nil, nil // tmux not running or no sessions + } + + var rows []SessionRow + for _, line := range strings.Split(strings.TrimSpace(stdout.String()), "\n") { + if line == "" { + continue + } + + parts := strings.SplitN(line, ":", 2) + name := parts[0] + + // Only include gt-* sessions + if !strings.HasPrefix(name, "gt-") { + continue + } + + row := SessionRow{ + Name: name, + IsAlive: true, // Session exists + } + + // Parse activity timestamp + if len(parts) > 1 { + if ts, ok := parseActivityTimestamp(parts[1]); ok && ts > 0 { + age := time.Since(time.Unix(ts, 0)) + row.Activity = formatMailAge(age) + } + } + + // Detect role from session name pattern: gt--[-] + // Examples: gt-gastown-witness, gt-gastown-nux, gt-deacon + nameParts := strings.Split(strings.TrimPrefix(name, "gt-"), "-") + if len(nameParts) >= 1 { + // Check for special roles + if nameParts[0] == "deacon" { + row.Role = "deacon" + } else if len(nameParts) >= 2 { + row.Rig = nameParts[0] + role := nameParts[1] + + switch role { + case "witness": + row.Role = "witness" + case "refinery": + row.Role = "refinery" + default: + // Assume it's a polecat name + row.Role = "polecat" + row.Worker = role + } + + // Check if there's a worker name after the role (for crew) + if len(nameParts) >= 3 && (role == "crew") { + row.Worker = nameParts[2] + } + } + } + + rows = append(rows, row) + } + + // Sort by rig, then role, then worker + sort.Slice(rows, func(i, j int) bool { + if rows[i].Rig != rows[j].Rig { + return rows[i].Rig < rows[j].Rig + } + if rows[i].Role != rows[j].Role { + return rows[i].Role < rows[j].Role + } + return rows[i].Worker < rows[j].Worker + }) + + return rows, nil +} + +// FetchHooks returns all hooked beads (work pinned to agents). +func (f *LiveConvoyFetcher) FetchHooks() ([]HookRow, error) { + // Query all beads with status=hooked + stdout, err := runBdCmd(f.townBeads, "list", "--status=hooked", "--json", "--limit=0") + if err != nil { + return nil, nil // No hooked beads or bd not available + } + + var beads []struct { + ID string `json:"id"` + Title string `json:"title"` + Assignee string `json:"assignee"` + UpdatedAt string `json:"updated_at"` + } + if err := json.Unmarshal(stdout.Bytes(), &beads); err != nil { + return nil, fmt.Errorf("parsing hooked beads: %w", err) + } + + var rows []HookRow + for _, bead := range beads { + row := HookRow{ + ID: bead.ID, + Title: bead.Title, + Assignee: bead.Assignee, + Agent: formatAgentAddress(bead.Assignee), + } + + // Keep full title - CSS handles overflow + + // Calculate age and stale status + if bead.UpdatedAt != "" { + if t, err := time.Parse(time.RFC3339, bead.UpdatedAt); err == nil { + age := time.Since(t) + row.Age = formatMailAge(age) + row.IsStale = age > time.Hour // Stale if hooked > 1 hour + } + } + + rows = append(rows, row) + } + + // Sort by stale first (stuck work), then by age + sort.Slice(rows, func(i, j int) bool { + if rows[i].IsStale != rows[j].IsStale { + return rows[i].IsStale // Stale items first + } + return rows[i].Age > rows[j].Age + }) + + return rows, nil +} + +// FetchMayor returns the Mayor's current status. +func (f *LiveConvoyFetcher) FetchMayor() (*MayorStatus, error) { + status := &MayorStatus{ + IsAttached: false, + } + + // Check if gt-mayor tmux session exists + stdout, err := runCmd(tmuxCmdTimeout, "tmux", "list-sessions", "-F", "#{session_name}:#{session_activity}") + if err != nil { + // tmux not running or no sessions + return status, nil + } + + lines := strings.Split(strings.TrimSpace(stdout.String()), "\n") + for _, line := range lines { + if strings.HasPrefix(line, "gt-mayor:") { + status.IsAttached = true + status.SessionName = "gt-mayor" + + // Parse activity timestamp + parts := strings.SplitN(line, ":", 2) + if len(parts) == 2 { + if activityTs, ok := parseActivityTimestamp(parts[1]); ok { + age := time.Since(time.Unix(activityTs, 0)) + status.LastActivity = formatMailAge(age) + status.IsActive = age < 5*time.Minute + } + } + break + } + } + + // Try to detect runtime from mayor config or session + if status.IsAttached { + status.Runtime = "claude" // Default; could enhance to detect actual runtime + } + + return status, nil +} + +// FetchIssues returns open issues (the backlog). +func (f *LiveConvoyFetcher) FetchIssues() ([]IssueRow, error) { + // Query open issues (excluding internal types like messages, convoys, queues) + stdout, err := runBdCmd(f.townBeads, "list", "--status=open", "--json", "--limit=50") + if err != nil { + return nil, nil // No issues or bd not available + } + + var beads []struct { + ID string `json:"id"` + Title string `json:"title"` + Type string `json:"type"` + Priority int `json:"priority"` + Labels []string `json:"labels"` + CreatedAt string `json:"created_at"` + } + if err := json.Unmarshal(stdout.Bytes(), &beads); err != nil { + return nil, fmt.Errorf("parsing issues: %w", err) + } + + var rows []IssueRow + for _, bead := range beads { + // Skip internal types (messages, convoys, queues, merge-requests, wisps) + switch bead.Type { + case "message", "convoy", "queue", "merge-request", "wisp", "agent": + continue + } + + row := IssueRow{ + ID: bead.ID, + Title: bead.Title, + Type: bead.Type, + Priority: bead.Priority, + } + + // Keep full title - CSS handles overflow + + // Format labels (skip internal labels) + var displayLabels []string + for _, label := range bead.Labels { + if !strings.HasPrefix(label, "gt:") && !strings.HasPrefix(label, "internal:") { + displayLabels = append(displayLabels, label) + } + } + if len(displayLabels) > 0 { + row.Labels = strings.Join(displayLabels, ", ") + if len(row.Labels) > 25 { + row.Labels = row.Labels[:22] + "..." + } + } + + // Calculate age + if bead.CreatedAt != "" { + if t, err := time.Parse(time.RFC3339, bead.CreatedAt); err == nil { + row.Age = formatMailAge(time.Since(t)) + } + } + + rows = append(rows, row) + } + + // Sort by priority (1=critical first), then by age + sort.Slice(rows, func(i, j int) bool { + pi, pj := rows[i].Priority, rows[j].Priority + if pi == 0 { + pi = 5 // Treat unset priority as low + } + if pj == 0 { + pj = 5 + } + if pi != pj { + return pi < pj + } + return rows[i].Age > rows[j].Age // Older first for same priority + }) + + return rows, nil +} + +// FetchActivity returns recent activity from the event log. +func (f *LiveConvoyFetcher) FetchActivity() ([]ActivityRow, error) { + eventsPath := filepath.Join(f.townRoot, ".events.jsonl") + + // Read events file + data, err := os.ReadFile(eventsPath) + if err != nil { + return nil, nil // No events file + } + + lines := strings.Split(strings.TrimSpace(string(data)), "\n") + if len(lines) == 0 { + return nil, nil + } + + // Take last 20 events (most recent) + start := 0 + if len(lines) > 20 { + start = len(lines) - 20 + } + + var rows []ActivityRow + for i := len(lines) - 1; i >= start; i-- { + line := lines[i] + if line == "" { + continue + } + + var event struct { + Timestamp string `json:"ts"` + Type string `json:"type"` + Actor string `json:"actor"` + Payload map[string]interface{} `json:"payload"` + Visibility string `json:"visibility"` + } + if err := json.Unmarshal([]byte(line), &event); err != nil { + continue + } + + // Skip audit-only events + if event.Visibility == "audit" { + continue + } + + row := ActivityRow{ + Type: event.Type, + Actor: formatAgentAddress(event.Actor), + Icon: eventIcon(event.Type), + } + + // Calculate time ago + if t, err := time.Parse(time.RFC3339, event.Timestamp); err == nil { + row.Time = formatMailAge(time.Since(t)) + } + + // Generate human-readable summary + row.Summary = eventSummary(event.Type, event.Actor, event.Payload) + + rows = append(rows, row) + } + + return rows, nil +} + +// eventIcon returns an emoji for an event type. +func eventIcon(eventType string) string { + icons := map[string]string{ + "sling": "đŸŽ¯", + "hook": "đŸĒ", + "unhook": "🔓", + "done": "✅", + "mail": "đŸ“Ŧ", + "spawn": "đŸĻ¨", + "kill": "💀", + "nudge": "👉", + "handoff": "🤝", + "session_start": "â–ļī¸", + "session_end": "⏚ī¸", + "session_death": "☠ī¸", + "mass_death": "đŸ’Ĩ", + "patrol_started": "🔍", + "patrol_complete": "✔ī¸", + "escalation_sent": "⚠ī¸", + "escalation_acked": "👍", + "escalation_closed": "🔕", + "merge_started": "🔀", + "merged": "✨", + "merge_failed": "❌", + "boot": "🚀", + "halt": "🛑", + } + if icon, ok := icons[eventType]; ok { + return icon + } + return "📋" +} + +// eventSummary generates a human-readable summary for an event. +func eventSummary(eventType, actor string, payload map[string]interface{}) string { + shortActor := formatAgentAddress(actor) + + switch eventType { + case "sling": + bead, _ := payload["bead"].(string) + target, _ := payload["target"].(string) + return fmt.Sprintf("%s slung to %s", bead, formatAgentAddress(target)) + case "done": + bead, _ := payload["bead"].(string) + return fmt.Sprintf("%s completed %s", shortActor, bead) + case "mail": + to, _ := payload["to"].(string) + subject, _ := payload["subject"].(string) + if len(subject) > 25 { + subject = subject[:22] + "..." + } + return fmt.Sprintf("→ %s: %s", formatAgentAddress(to), subject) + case "spawn": + return fmt.Sprintf("%s spawned", shortActor) + case "kill": + return fmt.Sprintf("%s killed", shortActor) + case "hook": + bead, _ := payload["bead"].(string) + return fmt.Sprintf("%s hooked %s", shortActor, bead) + case "unhook": + bead, _ := payload["bead"].(string) + return fmt.Sprintf("%s unhooked %s", shortActor, bead) + case "merged": + branch, _ := payload["branch"].(string) + return fmt.Sprintf("merged %s", branch) + case "merge_failed": + reason, _ := payload["reason"].(string) + if len(reason) > 30 { + reason = reason[:27] + "..." + } + return fmt.Sprintf("merge failed: %s", reason) + case "escalation_sent": + return "escalation created" + case "session_death": + role, _ := payload["role"].(string) + return fmt.Sprintf("%s session died", formatAgentAddress(role)) + case "mass_death": + count, _ := payload["count"].(float64) + return fmt.Sprintf("%.0f sessions died", count) + default: + return eventType + } +} diff --git a/internal/web/handler.go b/internal/web/handler.go index 02e23557..f0ac134b 100644 --- a/internal/web/handler.go +++ b/internal/web/handler.go @@ -1,15 +1,33 @@ package web import ( + "context" "html/template" + "log" "net/http" + "sync" + "time" ) +// fetchTimeout is the maximum time allowed for all data fetches to complete. +const fetchTimeout = 8 * time.Second + // ConvoyFetcher defines the interface for fetching convoy data. type ConvoyFetcher interface { FetchConvoys() ([]ConvoyRow, error) FetchMergeQueue() ([]MergeQueueRow, error) FetchPolecats() ([]PolecatRow, error) + FetchMail() ([]MailRow, error) + FetchRigs() ([]RigRow, error) + FetchDogs() ([]DogRow, error) + FetchEscalations() ([]EscalationRow, error) + FetchHealth() (*HealthRow, error) + FetchQueues() ([]QueueRow, error) + FetchSessions() ([]SessionRow, error) + FetchHooks() ([]HookRow, error) + FetchMayor() (*MayorStatus, error) + FetchIssues() ([]IssueRow, error) + FetchActivity() ([]ActivityRow, error) } // ConvoyHandler handles HTTP requests for the convoy dashboard. @@ -33,28 +51,181 @@ func NewConvoyHandler(fetcher ConvoyFetcher) (*ConvoyHandler, error) { // ServeHTTP handles GET / requests and renders the convoy dashboard. func (h *ConvoyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { - convoys, err := h.fetcher.FetchConvoys() - if err != nil { - http.Error(w, "Failed to fetch convoys", http.StatusInternalServerError) - return + // Check for expand parameter (fullscreen a specific panel) + expandPanel := r.URL.Query().Get("expand") + + // Create a timeout context for all fetches + ctx, cancel := context.WithTimeout(r.Context(), fetchTimeout) + defer cancel() + + var ( + convoys []ConvoyRow + mergeQueue []MergeQueueRow + polecats []PolecatRow + mail []MailRow + rigs []RigRow + dogs []DogRow + escalations []EscalationRow + health *HealthRow + queues []QueueRow + sessions []SessionRow + hooks []HookRow + mayor *MayorStatus + issues []IssueRow + activity []ActivityRow + wg sync.WaitGroup + ) + + // Run all fetches in parallel with error logging + wg.Add(14) + + go func() { + defer wg.Done() + var err error + convoys, err = h.fetcher.FetchConvoys() + if err != nil { + log.Printf("dashboard: FetchConvoys failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + mergeQueue, err = h.fetcher.FetchMergeQueue() + if err != nil { + log.Printf("dashboard: FetchMergeQueue failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + polecats, err = h.fetcher.FetchPolecats() + if err != nil { + log.Printf("dashboard: FetchPolecats failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + mail, err = h.fetcher.FetchMail() + if err != nil { + log.Printf("dashboard: FetchMail failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + rigs, err = h.fetcher.FetchRigs() + if err != nil { + log.Printf("dashboard: FetchRigs failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + dogs, err = h.fetcher.FetchDogs() + if err != nil { + log.Printf("dashboard: FetchDogs failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + escalations, err = h.fetcher.FetchEscalations() + if err != nil { + log.Printf("dashboard: FetchEscalations failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + health, err = h.fetcher.FetchHealth() + if err != nil { + log.Printf("dashboard: FetchHealth failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + queues, err = h.fetcher.FetchQueues() + if err != nil { + log.Printf("dashboard: FetchQueues failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + sessions, err = h.fetcher.FetchSessions() + if err != nil { + log.Printf("dashboard: FetchSessions failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + hooks, err = h.fetcher.FetchHooks() + if err != nil { + log.Printf("dashboard: FetchHooks failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + mayor, err = h.fetcher.FetchMayor() + if err != nil { + log.Printf("dashboard: FetchMayor failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + issues, err = h.fetcher.FetchIssues() + if err != nil { + log.Printf("dashboard: FetchIssues failed: %v", err) + } + }() + go func() { + defer wg.Done() + var err error + activity, err = h.fetcher.FetchActivity() + if err != nil { + log.Printf("dashboard: FetchActivity failed: %v", err) + } + }() + + // Wait for fetches or timeout + done := make(chan struct{}) + go func() { + wg.Wait() + close(done) + }() + + select { + case <-done: + // All fetches completed + case <-ctx.Done(): + log.Printf("dashboard: fetch timeout after %v", fetchTimeout) } - mergeQueue, err := h.fetcher.FetchMergeQueue() - if err != nil { - // Non-fatal: show convoys even if merge queue fails - mergeQueue = nil - } - - polecats, err := h.fetcher.FetchPolecats() - if err != nil { - // Non-fatal: show convoys even if polecats fail - polecats = nil - } + // Compute summary from already-fetched data + summary := computeSummary(polecats, hooks, issues, convoys, escalations, activity) data := ConvoyData{ - Convoys: convoys, - MergeQueue: mergeQueue, - Polecats: polecats, + Convoys: convoys, + MergeQueue: mergeQueue, + Polecats: polecats, + Mail: mail, + Rigs: rigs, + Dogs: dogs, + Escalations: escalations, + Health: health, + Queues: queues, + Sessions: sessions, + Hooks: hooks, + Mayor: mayor, + Issues: issues, + Activity: activity, + Summary: summary, + Expand: expandPanel, } w.Header().Set("Content-Type", "text/html; charset=utf-8") @@ -64,3 +235,60 @@ func (h *ConvoyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } } + +// computeSummary calculates dashboard stats and alerts from fetched data. +func computeSummary(polecats []PolecatRow, hooks []HookRow, issues []IssueRow, + convoys []ConvoyRow, escalations []EscalationRow, activity []ActivityRow) *DashboardSummary { + + summary := &DashboardSummary{ + PolecatCount: len(polecats), + HookCount: len(hooks), + IssueCount: len(issues), + ConvoyCount: len(convoys), + EscalationCount: len(escalations), + } + + // Count stuck polecats (status = "stuck") + for _, p := range polecats { + if p.WorkStatus == "stuck" { + summary.StuckPolecats++ + } + } + + // Count stale hooks (IsStale = true) + for _, h := range hooks { + if h.IsStale { + summary.StaleHooks++ + } + } + + // Count unacked escalations + for _, e := range escalations { + if !e.Acked { + summary.UnackedEscalations++ + } + } + + // Count high priority issues (P1 or P2) + for _, i := range issues { + if i.Priority == 1 || i.Priority == 2 { + summary.HighPriorityIssues++ + } + } + + // Count recent session deaths from activity + for _, a := range activity { + if a.Type == "session_death" || a.Type == "mass_death" { + summary.DeadSessions++ + } + } + + // Set HasAlerts flag + summary.HasAlerts = summary.StuckPolecats > 0 || + summary.StaleHooks > 0 || + summary.UnackedEscalations > 0 || + summary.DeadSessions > 0 || + summary.HighPriorityIssues > 0 + + return summary +} diff --git a/internal/web/handler_test.go b/internal/web/handler_test.go index c2fd3dba..ffb63bf6 100644 --- a/internal/web/handler_test.go +++ b/internal/web/handler_test.go @@ -17,10 +17,21 @@ var errFetchFailed = errors.New("fetch failed") // MockConvoyFetcher is a mock implementation for testing. type MockConvoyFetcher struct { - Convoys []ConvoyRow - MergeQueue []MergeQueueRow - Polecats []PolecatRow - Error error + Convoys []ConvoyRow + MergeQueue []MergeQueueRow + Polecats []PolecatRow + Mail []MailRow + Rigs []RigRow + Dogs []DogRow + Escalations []EscalationRow + Health *HealthRow + Queues []QueueRow + Sessions []SessionRow + Hooks []HookRow + Mayor *MayorStatus + Issues []IssueRow + Activity []ActivityRow + Error error } func (m *MockConvoyFetcher) FetchConvoys() ([]ConvoyRow, error) { @@ -35,6 +46,50 @@ func (m *MockConvoyFetcher) FetchPolecats() ([]PolecatRow, error) { return m.Polecats, nil } +func (m *MockConvoyFetcher) FetchMail() ([]MailRow, error) { + return m.Mail, nil +} + +func (m *MockConvoyFetcher) FetchRigs() ([]RigRow, error) { + return m.Rigs, nil +} + +func (m *MockConvoyFetcher) FetchDogs() ([]DogRow, error) { + return m.Dogs, nil +} + +func (m *MockConvoyFetcher) FetchEscalations() ([]EscalationRow, error) { + return m.Escalations, nil +} + +func (m *MockConvoyFetcher) FetchHealth() (*HealthRow, error) { + return m.Health, nil +} + +func (m *MockConvoyFetcher) FetchQueues() ([]QueueRow, error) { + return m.Queues, nil +} + +func (m *MockConvoyFetcher) FetchSessions() ([]SessionRow, error) { + return m.Sessions, nil +} + +func (m *MockConvoyFetcher) FetchHooks() ([]HookRow, error) { + return m.Hooks, nil +} + +func (m *MockConvoyFetcher) FetchMayor() (*MayorStatus, error) { + return m.Mayor, nil +} + +func (m *MockConvoyFetcher) FetchIssues() ([]IssueRow, error) { + return m.Issues, nil +} + +func (m *MockConvoyFetcher) FetchActivity() ([]ActivityRow, error) { + return m.Activity, nil +} + func TestConvoyHandler_RendersTemplate(t *testing.T) { mock := &MockConvoyFetcher{ Convoys: []ConvoyRow{ @@ -70,9 +125,7 @@ func TestConvoyHandler_RendersTemplate(t *testing.T) { if !strings.Contains(body, "hq-cv-abc") { t.Error("Response should contain convoy ID") } - if !strings.Contains(body, "Test Convoy") { - t.Error("Response should contain convoy title") - } + // Note: Convoy titles are no longer shown in the simplified dashboard table view if !strings.Contains(body, "2/5") { t.Error("Response should contain progress") } @@ -140,7 +193,7 @@ func TestConvoyHandler_EmptyConvoys(t *testing.T) { } body := w.Body.String() - if !strings.Contains(body, "No convoys") { + if !strings.Contains(body, "No active convoys") { t.Error("Response should show empty state message") } } @@ -196,6 +249,8 @@ func TestConvoyHandler_MultipleConvoys(t *testing.T) { } // Integration tests for error handling +// Note: The refactored dashboard handler treats fetch errors as non-fatal, +// rendering an empty section instead of returning an error. func TestConvoyHandler_FetchConvoysError(t *testing.T) { mock := &MockConvoyFetcher{ @@ -212,13 +267,15 @@ func TestConvoyHandler_FetchConvoysError(t *testing.T) { handler.ServeHTTP(w, req) - if w.Code != http.StatusInternalServerError { - t.Errorf("Status = %d, want %d", w.Code, http.StatusInternalServerError) + // Fetch errors are now non-fatal - the dashboard still renders + if w.Code != http.StatusOK { + t.Errorf("Status = %d, want %d (fetch errors are non-fatal)", w.Code, http.StatusOK) } body := w.Body.String() - if !strings.Contains(body, "Failed to fetch convoys") { - t.Error("Response should contain error message") + // Should show the empty state for convoys section + if !strings.Contains(body, "No active convoys") { + t.Error("Response should show empty state when fetch fails") } } @@ -266,7 +323,7 @@ func TestConvoyHandler_MergeQueueRendering(t *testing.T) { body := w.Body.String() // Check merge queue section header - if !strings.Contains(body, "Refinery Merge Queue") { + if !strings.Contains(body, "Merge Queue") { t.Error("Response should contain merge queue section header") } @@ -283,12 +340,12 @@ func TestConvoyHandler_MergeQueueRendering(t *testing.T) { t.Error("Response should contain repo 'roxas'") } - // Check CI status badges - if !strings.Contains(body, "ci-pass") { - t.Error("Response should contain ci-pass class for passing PR") + // Check CI status badges (now display text, not classes) + if !strings.Contains(body, "CI Pass") { + t.Error("Response should contain 'CI Pass' text for passing PR") } - if !strings.Contains(body, "ci-pending") { - t.Error("Response should contain ci-pending class for pending PR") + if !strings.Contains(body, "CI Running") { + t.Error("Response should contain 'CI Running' text for pending PR") } } @@ -356,8 +413,8 @@ func TestConvoyHandler_PolecatWorkersRendering(t *testing.T) { body := w.Body.String() // Check polecat section header - if !strings.Contains(body, "Polecat Workers") { - t.Error("Response should contain polecat workers section header") + if !strings.Contains(body, "Polecats") { + t.Error("Response should contain polecat section header") } // Check polecat names @@ -373,10 +430,7 @@ func TestConvoyHandler_PolecatWorkersRendering(t *testing.T) { t.Error("Response should contain rig 'roxas'") } - // Check status hints - if !strings.Contains(body, "Running tests...") { - t.Error("Response should contain status hint") - } + // Note: StatusHint is no longer displayed in the simplified dashboard view // Check activity colors (dag should be green, nux should be yellow/red) if !strings.Contains(body, "activity-green") { @@ -393,11 +447,11 @@ func TestConvoyHandler_WorkStatusRendering(t *testing.T) { wantClass string wantStatusText string }{ - {"complete status", "complete", "work-complete", "complete"}, - {"active status", "active", "work-active", "active"}, - {"stale status", "stale", "work-stale", "stale"}, - {"stuck status", "stuck", "work-stuck", "stuck"}, - {"waiting status", "waiting", "work-waiting", "waiting"}, + {"complete status", "complete", "badge-green", "✓"}, + {"active status", "active", "badge-green", "Active"}, + {"stale status", "stale", "badge-yellow", "Stale"}, + {"stuck status", "stuck", "badge-red", "Stuck"}, + {"waiting status", "waiting", "badge-muted", "Wait"}, } for _, tt := range tests { @@ -576,19 +630,19 @@ func TestConvoyHandler_FullDashboard(t *testing.T) { body := w.Body.String() // Verify all three sections are present - if !strings.Contains(body, "Gas Town Convoys") { - t.Error("Response should contain main header") + if !strings.Contains(body, "Convoys") { + t.Error("Response should contain convoy section") } if !strings.Contains(body, "hq-cv-full") { t.Error("Response should contain convoy data") } - if !strings.Contains(body, "Refinery Merge Queue") { + if !strings.Contains(body, "Merge Queue") { t.Error("Response should contain merge queue section") } if !strings.Contains(body, "#789") { t.Error("Response should contain PR data") } - if !strings.Contains(body, "Polecat Workers") { + if !strings.Contains(body, "Polecats") { t.Error("Response should contain polecat section") } if !strings.Contains(body, "worker1") { @@ -676,16 +730,14 @@ func TestE2E_Server_FullDashboard(t *testing.T) { name string content string }{ - {"Convoy section header", "Gas Town Convoys"}, + {"Convoy section", "Convoys"}, {"Convoy ID", "hq-cv-e2e"}, - {"Convoy title", "E2E Test Convoy"}, {"Convoy progress", "2/4"}, - {"Merge queue section", "Refinery Merge Queue"}, + {"Merge queue section", "Merge Queue"}, {"PR number", "#101"}, {"PR repo", "roxas"}, - {"Polecat section", "Polecat Workers"}, + {"Polecat section", "Polecats"}, {"Polecat name", "furiosa"}, - {"Polecat status", "Running E2E tests"}, {"HTMX auto-refresh", `hx-trigger="every 10s"`}, } @@ -772,7 +824,7 @@ func TestE2E_Server_MergeQueueEmpty(t *testing.T) { body := string(bodyBytes) // Section header should always be visible - if !strings.Contains(body, "Refinery Merge Queue") { + if !strings.Contains(body, "Merge Queue") { t.Error("Merge queue section should always be visible") } @@ -792,10 +844,10 @@ func TestE2E_Server_MergeQueueStatuses(t *testing.T) { wantCI string wantMerge string }{ - {"green when ready", "pass", "ready", "mq-green", "ci-pass", "merge-ready"}, - {"red when CI fails", "fail", "ready", "mq-red", "ci-fail", "merge-ready"}, - {"red when conflict", "pass", "conflict", "mq-red", "ci-pass", "merge-conflict"}, - {"yellow when pending", "pending", "pending", "mq-yellow", "ci-pending", "merge-pending"}, + {"green when ready", "pass", "ready", "mq-green", "CI Pass", "Ready"}, + {"red when CI fails", "fail", "ready", "mq-red", "CI Fail", "Ready"}, + {"red when conflict", "pass", "conflict", "mq-red", "CI Pass", "Conflict"}, + {"yellow when pending", "pending", "pending", "mq-yellow", "CI Running", "Pending"}, } for _, tt := range tests { @@ -835,10 +887,10 @@ func TestE2E_Server_MergeQueueStatuses(t *testing.T) { t.Errorf("Should contain row class %q", tt.colorClass) } if !strings.Contains(body, tt.wantCI) { - t.Errorf("Should contain CI class %q", tt.wantCI) + t.Errorf("Should contain CI text %q", tt.wantCI) } if !strings.Contains(body, tt.wantMerge) { - t.Errorf("Should contain merge class %q", tt.wantMerge) + t.Errorf("Should contain merge text %q", tt.wantMerge) } }) } @@ -934,9 +986,7 @@ func TestE2E_Server_RefineryInPolecats(t *testing.T) { if !strings.Contains(body, "refinery") { t.Error("Refinery should appear in polecat workers section") } - if !strings.Contains(body, "Idle - Waiting for PRs") { - t.Error("Refinery idle status should be shown") - } + // Note: StatusHint is no longer displayed in the simplified dashboard view // Regular polecats should also appear if !strings.Contains(body, "dag") { @@ -947,9 +997,9 @@ func TestE2E_Server_RefineryInPolecats(t *testing.T) { // Test that merge queue and polecat errors are non-fatal type MockConvoyFetcherWithErrors struct { - Convoys []ConvoyRow - MergeQueueError error - PolecatsError error + Convoys []ConvoyRow + MergeQueueError error + PolecatsError error } func (m *MockConvoyFetcherWithErrors) FetchConvoys() ([]ConvoyRow, error) { @@ -964,6 +1014,50 @@ func (m *MockConvoyFetcherWithErrors) FetchPolecats() ([]PolecatRow, error) { return nil, m.PolecatsError } +func (m *MockConvoyFetcherWithErrors) FetchMail() ([]MailRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchRigs() ([]RigRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchDogs() ([]DogRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchEscalations() ([]EscalationRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchHealth() (*HealthRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchQueues() ([]QueueRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchSessions() ([]SessionRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchHooks() ([]HookRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchMayor() (*MayorStatus, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchIssues() ([]IssueRow, error) { + return nil, nil +} + +func (m *MockConvoyFetcherWithErrors) FetchActivity() ([]ActivityRow, error) { + return nil, nil +} + func TestConvoyHandler_NonFatalErrors(t *testing.T) { mock := &MockConvoyFetcherWithErrors{ Convoys: []ConvoyRow{ diff --git a/internal/web/templates.go b/internal/web/templates.go index 261cd8d8..e36cc3ac 100644 --- a/internal/web/templates.go +++ b/internal/web/templates.go @@ -14,9 +14,155 @@ var templateFS embed.FS // ConvoyData represents data passed to the convoy template. type ConvoyData struct { - Convoys []ConvoyRow - MergeQueue []MergeQueueRow - Polecats []PolecatRow + Convoys []ConvoyRow + MergeQueue []MergeQueueRow + Polecats []PolecatRow + Mail []MailRow + Rigs []RigRow + Dogs []DogRow + Escalations []EscalationRow + Health *HealthRow + Queues []QueueRow + Sessions []SessionRow + Hooks []HookRow + Mayor *MayorStatus + Issues []IssueRow + Activity []ActivityRow + Summary *DashboardSummary + Expand string // Panel to show fullscreen (from ?expand=name) +} + +// RigRow represents a registered rig in the dashboard. +type RigRow struct { + Name string + GitURL string + PolecatCount int + CrewCount int + HasWitness bool + HasRefinery bool +} + +// DogRow represents a Deacon helper worker. +type DogRow struct { + Name string // Dog name (e.g., "alpha") + State string // idle, working + Work string // Current work assignment + LastActive string // Formatted age (e.g., "5m ago") + RigCount int // Number of worktrees +} + +// EscalationRow represents an escalation needing attention. +type EscalationRow struct { + ID string + Title string + Severity string // critical, high, medium, low + EscalatedBy string + Age string + Acked bool +} + +// HealthRow represents system health status. +type HealthRow struct { + DeaconHeartbeat string // Age of heartbeat (e.g., "2m ago") + DeaconCycle int64 + HealthyAgents int + UnhealthyAgents int + IsPaused bool + PauseReason string + HeartbeatFresh bool // true if < 5min old +} + +// QueueRow represents a work queue. +type QueueRow struct { + Name string + Status string // active, paused, closed + Available int + Processing int + Completed int + Failed int +} + +// SessionRow represents a tmux session. +type SessionRow struct { + Name string // Session name (e.g., "gt-gastown-witness") + Role string // witness, refinery, polecat, crew, deacon + Rig string // Rig name if applicable + Worker string // Worker name for polecats/crew + Activity string // Age since last activity + IsAlive bool // Whether Claude is running in session +} + +// HookRow represents a hooked bead (work pinned to an agent). +type HookRow struct { + ID string // Bead ID (e.g., "gt-abc12") + Title string // Work item title + Assignee string // Agent address (e.g., "gastown/polecats/nux") + Agent string // Formatted agent name + Age string // Time since hooked + IsStale bool // True if hooked > 1 hour (potentially stuck) +} + +// MayorStatus represents the Mayor's current state. +type MayorStatus struct { + IsAttached bool // True if gt-mayor tmux session exists + SessionName string // Tmux session name + LastActivity string // Age since last activity + IsActive bool // True if activity < 5 min (likely working) + Runtime string // Which runtime (claude, codex, etc.) +} + +// IssueRow represents an open issue in the backlog. +type IssueRow struct { + ID string // Bead ID (e.g., "gt-abc12") + Title string // Issue title + Type string // issue, bug, feature, task + Priority int // 1=critical, 2=high, 3=medium, 4=low + Age string // Time since created + Labels string // Comma-separated labels +} + +// ActivityRow represents an event in the activity feed. +type ActivityRow struct { + Time string // Formatted time (e.g., "2m ago") + Icon string // Emoji for event type + Type string // Event type (sling, done, mail, etc.) + Actor string // Who did it + Summary string // Human-readable description +} + +// DashboardSummary provides at-a-glance stats and alerts. +type DashboardSummary struct { + // Stats + PolecatCount int + HookCount int + IssueCount int + ConvoyCount int + EscalationCount int + + // Alerts (things needing attention) + StuckPolecats int // No activity > 5 min + StaleHooks int // Hooked > 1 hour + UnackedEscalations int + DeadSessions int // Sessions that died recently + HighPriorityIssues int // P1/P2 issues + + // Computed + HasAlerts bool +} + +// MailRow represents a mail message in the dashboard. +type MailRow struct { + ID string // Message ID (e.g., "hq-msg-abc123") + From string // Sender (e.g., "gastown/polecats/Toast") + FromRaw string // Raw sender address for color hashing + To string // Recipient (e.g., "mayor/") + Subject string // Message subject + Timestamp string // Formatted timestamp + Age string // Human-readable age (e.g., "5m ago") + Priority string // low, normal, high, urgent + Type string // task, notification, reply + Read bool // Whether message has been read + SortKey int64 // Unix timestamp for sorting } // PolecatRow represents a polecat worker in the dashboard. @@ -26,6 +172,9 @@ type PolecatRow struct { SessionID string // e.g., "gt-roxas-dag" LastActivity activity.Info // Colored activity display StatusHint string // Last line from pane (optional) + IssueID string // Currently assigned issue ID (e.g., "hq-1234") + IssueTitle string // Issue title (truncated) + WorkStatus string // working, stale, stuck, idle } // MergeQueueRow represents a PR in the merge queue. @@ -64,10 +213,15 @@ type TrackedIssue struct { func LoadTemplates() (*template.Template, error) { // Define template functions funcMap := template.FuncMap{ - "activityClass": activityClass, - "statusClass": statusClass, - "workStatusClass": workStatusClass, - "progressPercent": progressPercent, + "activityClass": activityClass, + "statusClass": statusClass, + "workStatusClass": workStatusClass, + "progressPercent": progressPercent, + "senderColorClass": senderColorClass, + "severityClass": severityClass, + "dogStateClass": dogStateClass, + "queueStatusClass": queueStatusClass, + "polecatStatusClass": polecatStatusClass, } // Get the templates subdirectory @@ -136,3 +290,85 @@ func progressPercent(completed, total int) int { } return (completed * 100) / total } + +// senderColorClass returns a CSS class for sender-based color coding. +// Uses a simple hash to assign consistent colors to each sender. +func senderColorClass(fromRaw string) string { + if fromRaw == "" { + return "sender-default" + } + // Simple hash: sum of bytes mod number of colors + var sum int + for _, b := range []byte(fromRaw) { + sum += int(b) + } + colors := []string{ + "sender-cyan", + "sender-purple", + "sender-green", + "sender-yellow", + "sender-orange", + "sender-blue", + "sender-red", + "sender-pink", + } + return colors[sum%len(colors)] +} + +// severityClass returns CSS class for escalation severity. +func severityClass(severity string) string { + switch severity { + case "critical": + return "severity-critical" + case "high": + return "severity-high" + case "medium": + return "severity-medium" + case "low": + return "severity-low" + default: + return "severity-unknown" + } +} + +// dogStateClass returns CSS class for dog state. +func dogStateClass(state string) string { + switch state { + case "idle": + return "dog-idle" + case "working": + return "dog-working" + default: + return "dog-unknown" + } +} + +// queueStatusClass returns CSS class for queue status. +func queueStatusClass(status string) string { + switch status { + case "active": + return "queue-active" + case "paused": + return "queue-paused" + case "closed": + return "queue-closed" + default: + return "queue-unknown" + } +} + +// polecatStatusClass returns CSS class for polecat work status. +func polecatStatusClass(status string) string { + switch status { + case "working": + return "polecat-working" + case "stale": + return "polecat-stale" + case "stuck": + return "polecat-stuck" + case "idle": + return "polecat-idle" + default: + return "polecat-unknown" + } +} diff --git a/internal/web/templates/convoy.html b/internal/web/templates/convoy.html index 381e1d97..13a3b2d9 100644 --- a/internal/web/templates/convoy.html +++ b/internal/web/templates/convoy.html @@ -7,14 +7,22 @@
-

🚚 Gas Town Convoys

+

🚚 Gas Town Control Center

- Auto-refresh: every 10s + Auto-refresh: 10s âŸŗ
- {{if .Convoys}} - - - - - - - - - - - {{range .Convoys}} - - - - - - - {{end}} - -
StatusConvoyProgressLast Activity
- {{.WorkStatus}} - - {{.ID}} - {{.Title}} - - {{.Progress}} - {{if .Total}} -
-
+ +
+
+ 🎩 + The Mayor + {{if .Mayor}} + {{if .Mayor.IsAttached}} + Attached + {{else}} + Detached + {{end}} + {{else}} + Unknown + {{end}} +
+ {{if .Mayor}}{{if .Mayor.IsAttached}} +
+
+ Activity + + {{.Mayor.LastActivity}} + +
+
+ Runtime + {{.Mayor.Runtime}} +
+
+ {{end}}{{end}} +
+ + + {{if .Summary}} +
+
+
+ {{.Summary.PolecatCount}} + đŸĻ¨ Polecats +
+
+ {{.Summary.HookCount}} + đŸĒ Hooks +
+
+ {{.Summary.IssueCount}} + đŸ“ŋ Issues +
+
+ {{.Summary.ConvoyCount}} + 🚚 Convoys +
+
+ {{.Summary.EscalationCount}} + ⚠ī¸ Escalations +
+
+ {{if .Summary.HasAlerts}} +
+ {{if .Summary.StuckPolecats}} + 💀 {{.Summary.StuckPolecats}} stuck + {{end}} + {{if .Summary.StaleHooks}} + ⏰ {{.Summary.StaleHooks}} stale hooks + {{end}} + {{if .Summary.UnackedEscalations}} + 🔔 {{.Summary.UnackedEscalations}} unacked + {{end}} + {{if .Summary.HighPriorityIssues}} + đŸ”Ĩ {{.Summary.HighPriorityIssues}} P1/P2 + {{end}} + {{if .Summary.DeadSessions}} + ☠ī¸ {{.Summary.DeadSessions}} dead + {{end}} +
+ {{else}} +
+ ✓ All clear +
+ {{end}} +
+ {{end}} + +
+ + + +
+
+

🚚 Convoys

+ {{len .Convoys}} + +
+
+ {{if .Convoys}} + + + + + + + + + + + {{range .Convoys}} + + + + + + + {{end}} + +
StatusConvoyProgressActivity
+ {{if eq .WorkStatus "complete"}} + ✓ + {{else if eq .WorkStatus "active"}} + Active + {{else if eq .WorkStatus "stale"}} + Stale + {{else if eq .WorkStatus "stuck"}} + Stuck + {{else}} + Wait + {{end}} + + {{.ID}} + + {{.Progress}} + {{if .Total}} +
+
+
+ {{end}} + 		+ + {{.LastActivity.FormattedAge}} +
+ {{else}} +
+

No active convoys

+
+ {{end}} +
+
+ + +
+
+

🐾 Polecats

+ {{len .Polecats}} + +
+
+ {{if .Polecats}} + + + + + + + + + + + + {{range .Polecats}} + + + + + + + + {{end}} + +
WorkerRigWorking OnStatusActivity
{{.Name}}{{.Rig}} + {{if .IssueID}} + {{.IssueID}} + {{.IssueTitle}} + {{else}} + — + {{end}} + + {{if eq .WorkStatus "working"}} + Working + {{else if eq .WorkStatus "stale"}} + Stale + {{else if eq .WorkStatus "stuck"}} + Stuck + {{else}} + Idle + {{end}} + + + {{.LastActivity.FormattedAge}} +
+ {{else}} +
+

No active workers

+
+ {{end}} +
+
+ + +
+
+

📟 Sessions

+ {{len .Sessions}} + +
+
+ {{if .Sessions}} + + + + + + + + + + + {{range .Sessions}} + + + + + + + {{end}} + +
RoleRigWorkerActivity
+ {{.Role}} + {{.Rig}}{{.Worker}}{{.Activity}}
+ {{else}} +
+

No active sessions

+
+ {{end}} +
+
+ + +
+
+

📜 Activity

+ {{len .Activity}} + +
+
+ {{if .Activity}} +
+ {{range .Activity}} +
+ {{.Icon}} + {{.Summary}} + {{.Time}}
{{end}} -
- - {{.LastActivity.FormattedAge}} -
- {{else}} -
-

No convoys found

-

Create a convoy with: gt convoy create <name> [issues...]

-
- {{end}} +
+ {{else}} +
+

No recent activity

+
+ {{end}} + + -

🔀 Refinery Merge Queue

- {{if .MergeQueue}} - - - - - - - - - - - - {{range .MergeQueue}} - - - - - - - - {{end}} - -
PR #RepoTitleCI StatusMergeable
- #{{.Number}} - {{.Repo}} - {{.Title}} - - {{if eq .CIStatus "pass"}} - ✓ Pass - {{else if eq .CIStatus "fail"}} - ✗ Fail - {{else}} - âŗ Pending - {{end}} - - {{if eq .Mergeable "ready"}} - Ready - {{else if eq .Mergeable "conflict"}} - Conflict - {{else}} - Pending - {{end}} -
- {{else}} -
-

No PRs in queue

-
- {{end}} + - {{if .Polecats}} -

🐾 Polecat Workers

- - - - - - - - - - - {{range .Polecats}} - - - - - - - {{end}} - -
PolecatRigLast ActivityStatus
- {{.Name}} - {{.Rig}} - - {{.LastActivity.FormattedAge}} - {{.StatusHint}}
- {{end}} + +
+
+

✉ī¸ Mail

+ {{len .Mail}} + +
+
+ {{if .Mail}} + + + + + + + + + + + {{range .Mail}} + + + + + + + {{end}} + +
FromToSubjectAge
{{.From}}{{.To}} + {{if eq .Priority "urgent"}}⚡{{end}} + {{if eq .Priority "high"}}!{{end}} + {{.Subject}} + {{.Age}}
+ {{else}} +
+

No recent mail

+
+ {{end}} +
+
+ + +
+
+

🔀 Merge Queue

+ {{len .MergeQueue}} + +
+
+ {{if .MergeQueue}} + + + + + + + + + + + + {{range .MergeQueue}} + + + + + + + + {{end}} + +
PRRepoTitleCIMerge
#{{.Number}}{{.Repo}}{{.Title}} + {{if eq .CIStatus "pass"}}CI Pass + {{else if eq .CIStatus "fail"}}CI Fail + {{else}}CI Running{{end}} + + {{if eq .Mergeable "ready"}}Ready + {{else if eq .Mergeable "conflict"}}Conflict + {{else}}Pending{{end}} +
+ {{else}} +
+

No PRs in queue

+
+ {{end}} +
+
+ + +
+
+

🚨 Escalations

+ {{len .Escalations}} + +
+
+ {{if .Escalations}} + + + + + + + + + + + {{range .Escalations}} + + + + + + + {{end}} + +
SeverityIssueFromAge
+ {{if eq .Severity "critical"}}CRIT + {{else if eq .Severity "high"}}HIGH + {{else if eq .Severity "medium"}}MED + {{else}}LOW{{end}} + + {{.Title}} + {{if .Acked}}ACK{{end}} + {{.EscalatedBy}}{{.Age}}
+ {{else}} +
+

No escalations

+
+ {{end}} +
+
+ + + + +
+
+

🏗ī¸ Rigs

+ {{len .Rigs}} + +
+
+ {{if .Rigs}} + + + + + + + + + + + {{range .Rigs}} + + + + + + + {{end}} + +
NamePolecatsCrewAgents
{{.Name}}{{.PolecatCount}}{{.CrewCount}} + 👁 + ⚗ī¸ +
+ {{else}} +
+

No rigs configured

+
+ {{end}} +
+
+ + +
+
+

🐕 Dogs

+ {{len .Dogs}} + +
+
+ {{if .Dogs}} + + + + + + + + + + + {{range .Dogs}} + + + + + + + {{end}} + +
NameStateWorkActivity
{{.Name}} + {{if eq .State "idle"}}Idle + {{else}}Working{{end}} + {{.Work}}{{.LastActive}}
+ {{else}} +
+

No dogs in kennel

+
+ {{end}} +
+
+ + +
+
+

💓 System Health

+ +
+
+ {{if .Health}} +
+
+
Deacon Heartbeat
+
+ {{.Health.DeaconHeartbeat}} +
+
+
+
Cycle
+
{{.Health.DeaconCycle}}
+
+
+
Healthy Agents
+
{{.Health.HealthyAgents}}
+
+
+
Unhealthy
+
+ {{.Health.UnhealthyAgents}} +
+
+ {{if .Health.IsPaused}} +
+
⚠ī¸ Deacon Paused
+
{{.Health.PauseReason}}
+
+ {{end}} +
+ {{else}} +
+

Health data unavailable

+
+ {{end}} +
+
+ + + {{if .Queues}} +
+
+

📋 Queues

+ {{len .Queues}} + +
+
+ + + + + + + + + + + + + {{range .Queues}} + + + + + + + + + {{end}} + +
QueueStatusAvailProcDoneFail
{{.Name}} + {{if eq .Status "active"}}Active + {{else if eq .Status "paused"}}Paused + {{else}}Closed{{end}} + {{.Available}}{{.Processing}}{{.Completed}}{{if .Failed}}{{.Failed}}{{else}}0{{end}}
+
+
+ {{end}} + + +
+
+

đŸ“ŋ Open Issues

+ {{len .Issues}} + +
+
+ {{if .Issues}} + + + + + + + + + + + + {{range .Issues}} + + + + + + + + {{end}} + +
PriIDTitleTypeAge
+ {{if eq .Priority 1}}P1 + {{else if eq .Priority 2}}P2 + {{else if eq .Priority 3}}P3 + {{else}}P4{{end}} + {{.ID}}{{.Title}}{{.Type}}{{.Age}}
+ {{else}} +
+

No open issues

+
+ {{end}} +
+
+ + +
+
+

đŸĒ Hooks

+ {{len .Hooks}} + +
+
+ {{if .Hooks}} + + + + + + + + + + + {{range .Hooks}} + + + + + + + {{end}} + +
BeadTitleAgentHooked
{{.ID}}{{.Title}}{{.Agent}} + {{if .IsStale}} + {{.Age}} + {{else}} + {{.Age}} + {{end}} +
+ {{else}} +
+

No hooked work

+
+ {{end}} +
+
+ + diff --git a/internal/web/templates_test.go b/internal/web/templates_test.go index 406405a8..5ab6a199 100644 --- a/internal/web/templates_test.go +++ b/internal/web/templates_test.go @@ -54,13 +54,8 @@ func TestConvoyTemplate_RendersConvoyList(t *testing.T) { t.Error("Template should contain convoy ID hq-cv-def") } - // Check titles are rendered - if !strings.Contains(output, "Feature X") { - t.Error("Template should contain title 'Feature X'") - } - if !strings.Contains(output, "Bugfix Y") { - t.Error("Template should contain title 'Bugfix Y'") - } + // The simplified dashboard no longer shows convoy titles in the table, + // only the convoy IDs. Titles are shown in expanded view. } func TestConvoyTemplate_LastActivityColors(t *testing.T) { @@ -184,14 +179,16 @@ func TestConvoyTemplate_StatusIndicators(t *testing.T) { data := ConvoyData{ Convoys: []ConvoyRow{ { - ID: "hq-cv-open", - Title: "Open Convoy", - Status: "open", + ID: "hq-cv-active", + Title: "Active Convoy", + Status: "open", + WorkStatus: "active", }, { - ID: "hq-cv-closed", - Title: "Closed Convoy", - Status: "closed", + ID: "hq-cv-stuck", + Title: "Stuck Convoy", + Status: "open", + WorkStatus: "stuck", }, }, } @@ -204,12 +201,12 @@ func TestConvoyTemplate_StatusIndicators(t *testing.T) { output := buf.String() - // Check status indicators - if !strings.Contains(output, "status-open") { - t.Error("Template should contain status-open class") + // Check work status badges are rendered (replaced status-open/closed classes) + if !strings.Contains(output, "badge-green") { + t.Error("Template should contain badge-green class for active status") } - if !strings.Contains(output, "status-closed") { - t.Error("Template should contain status-closed class") + if !strings.Contains(output, "badge-red") { + t.Error("Template should contain badge-red class for stuck status") } } @@ -232,7 +229,7 @@ func TestConvoyTemplate_EmptyState(t *testing.T) { output := buf.String() // Check for empty state message - if !strings.Contains(output, "No convoys") { + if !strings.Contains(output, "No active convoys") { t.Error("Template should show empty state message when no convoys") } }