452 lines
10 KiB
Go
452 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/bubbles/help"
|
|
"github.com/charmbracelet/bubbles/key"
|
|
"github.com/charmbracelet/bubbles/table"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
)
|
|
|
|
// Styles
|
|
var (
|
|
headerStyle = lipgloss.NewStyle().
|
|
Bold(true).
|
|
Foreground(lipgloss.Color("#00d4ff")).
|
|
Padding(0, 1)
|
|
|
|
statusRunning = lipgloss.NewStyle().Foreground(lipgloss.Color("#00ff88")).SetString("● running")
|
|
statusCompleted = lipgloss.NewStyle().Foreground(lipgloss.Color("#888888")).SetString("✓ done")
|
|
statusIdle = lipgloss.NewStyle().Foreground(lipgloss.Color("#666666")).SetString("○ idle")
|
|
statusBlocked = lipgloss.NewStyle().Foreground(lipgloss.Color("#ffaa00")).SetString("⚠ blocked")
|
|
statusError = lipgloss.NewStyle().Foreground(lipgloss.Color("#ff4444")).SetString("✕ error")
|
|
|
|
infoStyle = lipgloss.NewStyle().
|
|
Foreground(lipgloss.Color("#aaaaaa")).
|
|
Padding(0, 1)
|
|
|
|
footerStyle = lipgloss.NewStyle().
|
|
Foreground(lipgloss.Color("#888888")).
|
|
Padding(0, 1)
|
|
)
|
|
|
|
// Model
|
|
type model struct {
|
|
table table.Model
|
|
help help.Model
|
|
agents []AgentState
|
|
config Config
|
|
lastPoll time.Time
|
|
err error
|
|
ready bool
|
|
windowWidth int
|
|
}
|
|
|
|
type pollMsg struct{}
|
|
|
|
func initialModel(cfg Config) model {
|
|
columns := []table.Column{
|
|
{Title: "Machine", Width: 12},
|
|
{Title: "Session", Width: 16},
|
|
{Title: "Status", Width: 10},
|
|
{Title: "Model", Width: 18},
|
|
{Title: "Duration", Width: 10},
|
|
{Title: "Tools", Width: 6},
|
|
{Title: "Task", Width: 30},
|
|
}
|
|
|
|
t := table.New(
|
|
table.WithColumns(columns),
|
|
table.WithFocused(true),
|
|
table.WithHeight(20),
|
|
)
|
|
|
|
s := table.DefaultStyles()
|
|
s.Header = s.Header.
|
|
BorderStyle(lipgloss.NormalBorder()).
|
|
BorderForeground(lipgloss.Color("240")).
|
|
BorderBottom(true).
|
|
Bold(false)
|
|
s.Selected = s.Selected.
|
|
Foreground(lipgloss.Color("#ffffff")).
|
|
Background(lipgloss.Color("#334455")).
|
|
Bold(false)
|
|
t.SetStyles(s)
|
|
|
|
return model{
|
|
table: t,
|
|
help: help.New(),
|
|
agents: []AgentState{},
|
|
config: cfg,
|
|
}
|
|
}
|
|
|
|
func (m model) fetchAllAgents() ([]AgentState, error) {
|
|
var all []AgentState
|
|
|
|
// Local
|
|
local, err := readLocalStates(m.config.Local.Path)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("local: %w", err)
|
|
}
|
|
all = append(all, local...)
|
|
|
|
// Remote
|
|
for _, r := range m.config.Remote {
|
|
remote, err := readRemoteStates(r)
|
|
if err != nil {
|
|
// Skip unreachable remotes silently
|
|
continue
|
|
}
|
|
all = append(all, remote...)
|
|
}
|
|
|
|
return all, nil
|
|
}
|
|
|
|
func (m model) Init() tea.Cmd {
|
|
return tea.Batch(pollNow(), tick())
|
|
}
|
|
|
|
func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
switch msg := msg.(type) {
|
|
case tea.WindowSizeMsg:
|
|
m.windowWidth = msg.Width
|
|
m.help.Width = msg.Width
|
|
m.table.SetWidth(msg.Width - 4)
|
|
m.ready = true
|
|
return m, nil
|
|
|
|
case tea.KeyMsg:
|
|
switch {
|
|
case key.Matches(msg, keys.Quit):
|
|
return m, tea.Quit
|
|
case key.Matches(msg, keys.Refresh):
|
|
return m, pollNow()
|
|
case key.Matches(msg, keys.Attach):
|
|
return m, attachToAgent(m)
|
|
case key.Matches(msg, keys.Hunk):
|
|
return m, openHunk(m)
|
|
case key.Matches(msg, keys.Tuxedo):
|
|
return m, openTuxedo(m)
|
|
}
|
|
|
|
case pollMsg:
|
|
agents, err := m.fetchAllAgents()
|
|
if err != nil {
|
|
m.err = err
|
|
} else {
|
|
m.err = nil
|
|
m.agents = agents
|
|
m.lastPoll = time.Now()
|
|
m.updateTable()
|
|
}
|
|
return m, tick()
|
|
|
|
case errMsg:
|
|
m.err = msg.err
|
|
return m, nil
|
|
}
|
|
|
|
var cmd tea.Cmd
|
|
m.table, cmd = m.table.Update(msg)
|
|
return m, cmd
|
|
}
|
|
|
|
func (m model) View() string {
|
|
if !m.ready {
|
|
return "\n Loading Pi Dashboard..."
|
|
}
|
|
|
|
var b strings.Builder
|
|
|
|
// Header
|
|
summary := fmt.Sprintf("%d agent(s)", len(m.agents))
|
|
if len(m.config.Remote) > 0 {
|
|
summary += fmt.Sprintf(" │ %d remote(s)", len(m.config.Remote))
|
|
}
|
|
b.WriteString(headerStyle.Render(fmt.Sprintf(
|
|
"╡ Pi Dashboard │ %s │ %s ╞",
|
|
summary,
|
|
time.Now().Format("15:04:05"),
|
|
)))
|
|
b.WriteString("\n\n")
|
|
|
|
// Error
|
|
if m.err != nil {
|
|
b.WriteString(lipgloss.NewStyle().
|
|
Foreground(lipgloss.Color("#ff4444")).
|
|
Render(fmt.Sprintf("⚠ %v\n\n", m.err)))
|
|
}
|
|
|
|
// Table
|
|
b.WriteString(m.table.View())
|
|
b.WriteString("\n")
|
|
|
|
// Keybindings help
|
|
b.WriteString(footerStyle.Render(
|
|
"↑↓ navigate · Enter attach · d hunk · Tab tuxedo · r refresh · q quit",
|
|
))
|
|
|
|
return b.String()
|
|
}
|
|
|
|
func (m *model) updateTable() {
|
|
var rows []table.Row
|
|
for _, a := range m.agents {
|
|
status := statusStr(a)
|
|
task := strings.ReplaceAll(a.CurrentTask, "\n", " ")
|
|
if len(task) > 30 {
|
|
task = task[:28] + ".."
|
|
}
|
|
rows = append(rows, table.Row{
|
|
a.MachineShort(),
|
|
a.Session,
|
|
status,
|
|
a.ShortModel(),
|
|
a.DurationStr(),
|
|
fmt.Sprintf("%d", a.ToolCalls),
|
|
task,
|
|
})
|
|
}
|
|
m.table.SetRows(rows)
|
|
|
|
// Auto-height
|
|
h := len(rows) + 2
|
|
if h < 5 {
|
|
h = 5
|
|
}
|
|
if h > 30 {
|
|
h = 30
|
|
}
|
|
m.table.SetHeight(h)
|
|
}
|
|
|
|
// ── Commands ─────────────────────────────────────────────────────
|
|
|
|
func tick() tea.Cmd {
|
|
return tea.Tick(2*time.Second, func(t time.Time) tea.Msg {
|
|
return pollMsg{}
|
|
})
|
|
}
|
|
|
|
func pollNow() tea.Cmd {
|
|
return func() tea.Msg {
|
|
return pollMsg{}
|
|
}
|
|
}
|
|
|
|
type errMsg struct{ err error }
|
|
|
|
func attachToAgent(m model) tea.Cmd {
|
|
if len(m.agents) == 0 {
|
|
return nil
|
|
}
|
|
row := m.table.Cursor()
|
|
if row < 0 || row >= len(m.agents) {
|
|
return nil
|
|
}
|
|
a := m.agents[row]
|
|
name := a.ConnectionName
|
|
if name == "" {
|
|
name = a.Session
|
|
}
|
|
|
|
if a.IsLocal() {
|
|
return tea.ExecProcess(
|
|
exec.Command("tmux", "attach-session", "-t", name),
|
|
func(err error) tea.Msg {
|
|
if err != nil { return errMsg{err} }
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
|
|
// Remote agent: find SSH config
|
|
for _, r := range m.config.Remote {
|
|
// Match by hostname in the machine field
|
|
if strings.Contains(a.Machine, r.Host) || strings.Contains(r.Host, a.Machine) {
|
|
user := r.User
|
|
if user == "" { user = "sam" }
|
|
return tea.ExecProcess(
|
|
exec.Command("ssh", "-t", fmt.Sprintf("%s@%s", user, r.Host),
|
|
"tmux", "attach-session", "-t", name),
|
|
func(err error) tea.Msg {
|
|
if err != nil { return errMsg{err} }
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
}
|
|
|
|
// Fallback: show the machine name
|
|
m.err = fmt.Errorf("no SSH config for remote machine: %s", a.Machine)
|
|
return nil
|
|
}
|
|
|
|
func openHunk(m model) tea.Cmd {
|
|
if len(m.agents) == 0 {
|
|
return nil
|
|
}
|
|
row := m.table.Cursor()
|
|
if row < 0 || row >= len(m.agents) {
|
|
return nil
|
|
}
|
|
|
|
// Try to find a worktree or repo path
|
|
// For now, just run hunk in the current directory
|
|
return tea.ExecProcess(exec.Command("hunk", "diff", "--watch"), func(err error) tea.Msg {
|
|
if err != nil {
|
|
return errMsg{err}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func openTuxedo(m model) tea.Cmd {
|
|
home, _ := os.UserHomeDir()
|
|
todoFile := home + "/.pi/agent/dashboard/tasks/todo.txt"
|
|
|
|
// Ensure the file exists before opening
|
|
if _, err := os.Stat(todoFile); os.IsNotExist(err) {
|
|
// Create an empty todo.txt
|
|
os.WriteFile(todoFile, []byte(""), 0644)
|
|
}
|
|
|
|
return tea.ExecProcess(
|
|
exec.Command("tuxedo", todoFile),
|
|
func(err error) tea.Msg {
|
|
if err != nil {
|
|
return errMsg{err}
|
|
}
|
|
return nil
|
|
},
|
|
)
|
|
}
|
|
|
|
// ── Keybindings ──────────────────────────────────────────────────
|
|
|
|
type keyMap struct {
|
|
Quit key.Binding
|
|
Refresh key.Binding
|
|
Attach key.Binding
|
|
Hunk key.Binding
|
|
Tuxedo key.Binding
|
|
}
|
|
|
|
var keys = keyMap{
|
|
Quit: key.NewBinding(key.WithKeys("q", "ctrl+c"), key.WithHelp("q", "quit")),
|
|
Refresh: key.NewBinding(key.WithKeys("r"), key.WithHelp("r", "refresh")),
|
|
Attach: key.NewBinding(key.WithKeys("enter"), key.WithHelp("enter", "attach to agent")),
|
|
Hunk: key.NewBinding(key.WithKeys("d"), key.WithHelp("d", "hunk diff")),
|
|
Tuxedo: key.NewBinding(key.WithKeys("tab"), key.WithHelp("tab", "tuxedo tasks")),
|
|
}
|
|
|
|
// ── Helpers ──────────────────────────────────────────────────────
|
|
|
|
func statusStr(a AgentState) string {
|
|
switch a.Status {
|
|
case "running":
|
|
return "● running"
|
|
case "completed":
|
|
return "✓ done"
|
|
case "error":
|
|
return "✕ error"
|
|
case "blocked":
|
|
return "⚠ blocked"
|
|
default:
|
|
return "○ idle"
|
|
}
|
|
}
|
|
|
|
func printAgentList(agents []AgentState) {
|
|
if len(agents) == 0 {
|
|
fmt.Println("No agents found in ~/.pi/agent/dashboard/")
|
|
return
|
|
}
|
|
fmt.Printf("%-18s %-14s %-20s %-10s %s\n", "Session", "Machine", "Model", "Status", "Task")
|
|
fmt.Println(strings.Repeat("-", 90))
|
|
for _, a := range agents {
|
|
task := strings.ReplaceAll(a.CurrentTask, "\n", " ")
|
|
if len(task) > 35 {
|
|
task = task[:33] + ".."
|
|
}
|
|
fmt.Printf("%-18s %-14s %-20s %-10s %s\n",
|
|
a.Session, a.MachineShort(), a.ShortModel(), statusStr(a), task)
|
|
}
|
|
}
|
|
|
|
// ── Entry point ──────────────────────────────────────────────────
|
|
|
|
func main() {
|
|
// Set local hostname
|
|
var err error
|
|
localHostname, err = os.Hostname()
|
|
if err != nil {
|
|
localHostname = "localhost"
|
|
}
|
|
|
|
home, _ := os.UserHomeDir()
|
|
|
|
// Simple flag parsing (before TUI init)
|
|
args := os.Args[1:]
|
|
for _, arg := range args {
|
|
switch arg {
|
|
case "-h", "--help":
|
|
fmt.Println(`Pi Dashboard — real-time status for pi coding agents
|
|
|
|
Usage:
|
|
pi-dashboard TUI mode (default)
|
|
pi-dashboard --list Print agent states as text
|
|
pi-dashboard --help Show this help
|
|
|
|
Keybindings (TUI mode):
|
|
↑↓ Navigate agents
|
|
Enter Attach to agent (tmux attach)
|
|
d Open hunk diff
|
|
Tab Open tuxedo task list
|
|
r Force refresh
|
|
q Quit
|
|
|
|
Config: ~/.config/pi-dashboard.yaml
|
|
poll_interval: 2 # seconds
|
|
local:
|
|
path: ~/.pi/agent/dashboard/
|
|
remote:
|
|
- host: 192.168.20.13
|
|
user: sam
|
|
path: /home/sam/.pi/agent/dashboard/
|
|
`)
|
|
return
|
|
case "--list":
|
|
cfg := defaultConfig()
|
|
agents, err := readLocalStates(cfg.Local.Path)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
printAgentList(agents)
|
|
return
|
|
}
|
|
}
|
|
|
|
cfgPath := home + "/.config/pi-dashboard.yaml"
|
|
cfg, err := loadConfig(cfgPath)
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Warning: config error: %v\n", err)
|
|
cfg = defaultConfig()
|
|
}
|
|
|
|
p := tea.NewProgram(initialModel(cfg), tea.WithAltScreen())
|
|
if _, err := p.Run(); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error: %v\n", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|