:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
package tui
import (
"fmt"
"strings"
"time"
"charm.land/bubbles/v2/key"
"charm.land/lipgloss/v2"
"github.com/charmbracelet/x/ansi"
sharedpalette "github.com/posthog/posthog/phrocs/internal/palette"
"github.com/posthog/posthog/phrocs/internal/process"
)
// Triggers warning icon and banner
const highMemoryMB = 2048
func (m Model) renderHeader() string {
brand := headerBrandStyle.Render("phrocs")
running := 0
for _, p := range m.services {
if p.Status() == process.StatusRunning {
running++
}
}
meta := headerMetaStyle.Render(fmt.Sprintf("%d running", running))
if m.copyMode {
if p := m.activeProc(); p != nil {
label := labelStyle.Render(p.Name)
stripesW := lipgloss.Width(stripesStyle)
labelW := lipgloss.Width(label)
innerW := m.width - stripesW - lipgloss.Width(brand) - lipgloss.Width(meta)
leftGap := max((innerW-labelW)/2, 0)
rightGap := max(innerW-labelW-leftGap, 0)
left := lipgloss.NewStyle().Width(leftGap).Render("")
right := lipgloss.NewStyle().Width(rightGap).Render("")
return lipgloss.JoinHorizontal(lipgloss.Top, stripesStyle, brand, left, label, right, meta)
}
}
var procInfo string
if p := m.activeProc(); p != nil {
if pid := p.PID(); pid > 0 {
procInfo = headerMetaStyle.Render(fmt.Sprintf("PID %d", pid))
}
}
var sortInfo string
if m.sortMode != SortName {
sortInfo = headerMetaStyle.Render(fmt.Sprintf("▼ %s", m.sortMode))
}
var groupInfo string
if m.isGrouped() {
groupInfo = headerMetaStyle.Render(fmt.Sprintf("☰ %s", m.activeGroupDim()))
}
spacerW := max(m.width-lipgloss.Width(stripesStyle)-lipgloss.Width(brand)-lipgloss.Width(groupInfo)-lipgloss.Width(sortInfo)-lipgloss.Width(procInfo)-lipgloss.Width(meta)-1, 0)
spacer := lipgloss.NewStyle().Width(spacerW).Render("")
return lipgloss.JoinHorizontal(lipgloss.Top, stripesStyle, brand, spacer, groupInfo, sortInfo, procInfo, "•", meta)
}
func (m Model) renderSidebar() string {
h := m.sidebarHeight()
// Usable column width inside the border
innerW := m.effectiveSidebarWidth() - 1
if m.isGrouped() {
return m.renderGroupedSidebar(h, innerW)
}
// Determine the vertical slice of the services list to render based
// on the current cursor position and servicesOffset
start := min(max(m.servicesOffset, 0), max(0, len(m.services)-1))
canScrollUp, canScrollDown, visibleH := m.sidebarScrollState()
visibleEnd := min(len(m.services), start+visibleH)
var rows []string
if canScrollUp {
rows = append(rows, scrollArrowStyle.Width(innerW).Render("▲"))
}
for i := start; i < visibleEnd; i++ {
p := m.services[i]
status := p.Status()
iconChar := statusIconChar(status)
// For pending processes, swap in the current spinner frame. Strip ANSI
// from spinner.View() so the raw character can be safely composed inside
// the surrounding lipgloss styles without breaking their background colour.
if status == process.StatusPending {
iconChar = ansi.Strip(m.spinner.View())
}
iconColor := statusIconColor(status)
name := truncate(p.Name, innerW-3)
rows = append(rows, renderSidebarRow(sidebarRow{
icon: iconChar,
name: name,
iconColor: iconColor,
selected: i == m.servicesCursor,
unread: p.Unread(),
standby: status.IsStandby(),
innerW: innerW,
isDark: m.isDark,
}))
}
if canScrollDown {
rows = append(rows, scrollArrowStyle.Width(innerW).Render("▼"))
}
// Pad remaining rows so the sidebar border extends the full height
for len(rows) < h {
rows = append(rows, procInactiveStyle.Width(innerW).Render(""))
}
return borderFor(m.isDark, m.focusedPane == focusServices).Height(h).Render(strings.Join(rows, "\n"))
}
// renderGroupedSidebar renders the sidebar with group headers interspersed.
func (m Model) renderGroupedSidebar(h, innerW int) string {
entries := m.sidebarEntries
n := len(entries)
// Compute scroll state for entries (similar to sidebarScrollState but for entries)
start := min(max(m.servicesOffset, 0), max(0, n-1))
canScrollUp := start > 0
avail := h
if canScrollUp {
avail--
}
canScrollDown := start+avail < n
if canScrollDown {
avail--
}
avail = max(avail, 1)
visibleEnd := min(n, start+avail)
var rows []string
if canScrollUp {
rows = append(rows, scrollArrowStyle.Width(innerW).Render("▲"))
}
for i := start; i < visibleEnd; i++ {
e := entries[i]
if e.spacer {
rows = append(rows, procInactiveStyle.Width(innerW).Render(""))
continue
}
if e.isHeader() {
label := truncate(e.groupHeader, innerW-1)
rows = append(rows, groupHeaderStyle.Width(innerW).Render(label))
continue
}
p := e.proc
status := p.Status()
iconChar := statusIconChar(status)
if status == process.StatusPending {
iconChar = ansi.Strip(m.spinner.View())
}
iconColor := statusIconColor(status)
name := truncate(p.Name, innerW-3)
rows = append(rows, renderSidebarRow(sidebarRow{
icon: iconChar,
name: name,
iconColor: iconColor,
selected: i == m.entryCursor,
unread: p.Unread(),
standby: status.IsStandby(),
innerW: innerW,
isDark: m.isDark,
}))
}
if canScrollDown {
rows = append(rows, scrollArrowStyle.Width(innerW).Render("▼"))
}
for len(rows) < h {
rows = append(rows, procInactiveStyle.Width(innerW).Render(""))
}
return borderFor(m.isDark, m.focusedPane == focusServices).Height(h).Render(strings.Join(rows, "\n"))
}
func (m Model) sidebarHeight() int {
fh := m.footerHeight()
h := m.height - headerHeight - fh
return max(h, 1)
}
// sidebarScrollState computes whether scroll arrows are needed and how many
// process rows fit. Arrows are derived from offset and list length only,
// avoiding the circular dependency where arrow visibility depends on visible
// count which depends on arrow visibility.
func (m Model) sidebarScrollState() (canScrollUp, canScrollDown bool, visibleH int) {
h := m.sidebarHeight()
n := len(m.services)
if m.isGrouped() {
n = len(m.sidebarEntries)
}
if n <= h {
return false, false, h
}
start := min(max(m.servicesOffset, 0), max(0, n-1))
canScrollUp = start > 0
// Tentatively deduct one row for the up arrow
avail := h
if canScrollUp {
avail--
}
// Check whether the remaining rows can show everything from start onward
canScrollDown = start+avail < n
if canScrollDown {
avail--
}
return canScrollUp, canScrollDown, max(avail, 1)
}
// Keep selected process row within the visible
// sidebar window by adjusting servicesOffset
func (m *Model) ensureSidebarCursorVisible() {
if m.isGrouped() {
m.ensureGroupedCursorVisible()
return
}
_, _, h := m.sidebarScrollState()
if len(m.services) <= m.sidebarHeight() {
m.servicesOffset = 0
return
}
maxOffset := len(m.services) - h
if m.servicesOffset > maxOffset {
m.servicesOffset = max(maxOffset, 0)
}
if m.servicesCursor < m.servicesOffset {
m.servicesOffset = m.servicesCursor
}
if m.servicesCursor >= m.servicesOffset+h {
m.servicesOffset = m.servicesCursor - h + 1
}
}
// ensureGroupedCursorVisible keeps the entryCursor visible in grouped mode.
func (m *Model) ensureGroupedCursorVisible() {
n := len(m.sidebarEntries)
h := m.sidebarHeight()
if n <= h {
m.servicesOffset = 0
return
}
// Compute available rows accounting for scroll arrows
canScrollUp := m.servicesOffset > 0
avail := h
if canScrollUp {
avail--
}
canScrollDown := m.servicesOffset+avail < n
if canScrollDown {
avail--
}
avail = max(avail, 1)
maxOffset := n - avail
if m.servicesOffset > maxOffset {
m.servicesOffset = max(maxOffset, 0)
}
if m.entryCursor < m.servicesOffset {
m.servicesOffset = m.entryCursor
// Show the group header above if immediately preceding
if m.entryCursor > 0 && m.sidebarEntries[m.entryCursor-1].isHeader() {
m.servicesOffset = m.entryCursor - 1
}
}
if m.entryCursor >= m.servicesOffset+avail {
m.servicesOffset = m.entryCursor - avail + 1
}
}
func (m Model) renderOutput() string {
content := lipgloss.JoinHorizontal(lipgloss.Top, m.viewportWithIndicator())
if m.isFullScreen() {
return content
}
return borderFor(m.isDark, m.focusedPane == focusOutput).Render(content)
}
// Overlays a -line counter in the top-right corner of the viewport
// and appends the typed input buffer after the last output line.
func (m Model) viewportWithIndicator() string {
view := m.viewport.View()
if m.hedgehogMode {
view = m.overlayHedgehog(view)
}
if m.infoMode {
return view
}
lines := strings.Split(view, "\n")
// Show a cursor after the last line when keystrokes are being forwarded to
// the process (auto-detected prompt or explicit input mode).
if p := m.activeProc(); p != nil {
showCursor := m.isForwardingInput()
if showCursor {
lastLine := len(lines) - 1
lines[lastLine] = strings.TrimRight(lines[lastLine], " ") + " " + m.inputBuffer + "▌"
}
}
total := m.viewport.TotalLineCount()
scrollLines := total - m.viewport.YOffset() - m.viewport.Height()
if scrollLines > 0 && len(lines) > 0 {
indicator := scrollIndicatorStyle.Render(fmt.Sprintf("-%d", scrollLines))
indicatorW := lipgloss.Width(indicator)
firstLine := lines[0]
firstLineW := lipgloss.Width(firstLine)
if firstLineW >= indicatorW {
lines[0] = ansi.Truncate(firstLine, firstLineW-indicatorW, "") + indicator
}
}
return strings.Join(lines, "\n")
}
func (m Model) renderFooter() string {
if m.copyMode {
var hint string
if m.copyAnchor < 0 {
hint = fmt.Sprintf("-- COPY MODE -- line %d ↑/↓: navigate c: mark start esc: cancel", m.copyCursor+1)
} else {
lo := min(m.copyAnchor, m.copyCursor) + 1
hi := max(m.copyAnchor, m.copyCursor) + 1
hint = fmt.Sprintf("-- COPY MODE -- lines %d–%d ↑/↓: extend c: copy esc: cancel", lo, hi)
}
return footerStyle.Width(m.width - 2).Render(
lipgloss.NewStyle().Foreground(colorBlue).Render(hint),
)
} else if p := m.activeProc(); m.inputMode && m.focusedPane == focusOutput && p != nil && p.IsRunning() {
hint := "-- INPUT -- send text to the process ↵: send ⌫: delete esc: cancel"
return footerStyle.Width(m.width - 2).Render(
lipgloss.NewStyle().Foreground(colorGreen).Render(hint),
)
} else if m.infoMode {
hint := "-- INFO -- i/esc: close"
return footerStyle.Width(m.width - 2).Render(
lipgloss.NewStyle().Foreground(colorYellow).Render(hint),
)
} else if m.filterMode {
matchInfo := ""
if m.searchQuery != "" {
if count := m.viewport.TotalLineCount(); count == 0 {
matchInfo = " [no matches]"
} else {
matchInfo = fmt.Sprintf(" [%d lines]", count)
}
}
prompt := lipgloss.NewStyle().Foreground(colorGreen).Render(fmt.Sprintf("| %s▌%s", m.searchQuery, matchInfo))
return footerStyle.Width(m.width - 2).Render(m.joinPromptWithHelp(prompt, m.keys.FilterModeHelp()))
} else if m.searchMode {
matchInfo := ""
if m.searchQuery != "" {
if len(m.searchMatches) == 0 {
matchInfo = " [no matches]"
} else {
matchInfo = fmt.Sprintf(" [%d/%d]", m.searchCursor+1, len(m.searchMatches))
}
}
prompt := lipgloss.NewStyle().Foreground(colorYellow).Render(fmt.Sprintf("/ %s▌%s", m.searchQuery, matchInfo))
return footerStyle.Width(m.width - 2).Render(m.joinPromptWithHelp(prompt, m.keys.SearchModeHelp()))
} else if m.setupMode {
var hint string
if m.setupError != "" {
escAction := "cancel"
if m.setupStep == 2 {
escAction = "back"
}
hint = "-- SETUP -- " + m.setupError + " esc: " + escAction
} else if m.setupStep == 1 {
hint = "-- SETUP -- ↑/↓: navigate space: toggle enter: next esc: cancel"
} else {
hint = "-- SETUP -- ↑/↓: navigate space: toggle enter: save & apply esc: back"
}
return footerStyle.Width(m.width - 2).Render(
lipgloss.NewStyle().Foreground(colorGreen).Render(hint),
)
}
if m.searchQuery != "" {
var matchInfo string
if len(m.searchMatches) == 0 {
matchInfo = fmt.Sprintf("search: %q [no matches] esc: cancel", m.searchQuery)
} else {
matchInfo = fmt.Sprintf("search: %q [%d/%d] ↵/⇧↵: navigate esc: cancel", m.searchQuery, m.searchCursor+1, len(m.searchMatches))
}
return footerStyle.Width(m.width - 2).Render(
lipgloss.NewStyle().Foreground(colorYellow).Render(matchInfo),
)
}
if m.hideHelp {
return ""
}
var content string
if m.showHelp {
content = m.help.FullHelpView(m.keys.FullHelp())
} else {
content = m.help.ShortHelpView(m.keys.ShortHelp())
}
return footerStyle.Width(m.width - 2).Render(content)
}
// Joins a prompt line with a help bar, or returns the prompt alone when help
// is hidden — keeps search/filter footer height consistent with footerHeight().
func (m Model) joinPromptWithHelp(prompt string, helpBindings []key.Binding) string {
if m.hideHelp {
return prompt
}
return lipgloss.JoinVertical(lipgloss.Left, prompt, m.help.ShortHelpView(helpBindings))
}
// Rebuilds the info content and sets it on the viewport.
func (m *Model) refreshInfoContent() {
info := m.renderInfo()
lines := strings.Split(info, "\n")
m.viewport.SetContent(strings.Join(lines, "\n"))
}
func (m Model) renderInfo() string {
p := m.activeProc()
if p == nil {
return ""
}
snap := p.Snapshot()
titleStyle := lipgloss.NewStyle().Bold(true).Foreground(colorYellow)
labelStyle := lipgloss.NewStyle().Foreground(colorBrightBlack).Width(20)
valueStyle := lipgloss.NewStyle()
row := func(label, value string) string {
return labelStyle.Render(label) + valueStyle.Render(value)
}
var lines []string
// High memory warning banner
if snap.MemRSSMB != nil && *snap.MemRSSMB >= highMemoryMB {
lines = append(lines, warnStyle.Width(m.viewport.Width()).Render(fmt.Sprintf(" %s High memory usage: %.0f MB", sharedpalette.IconWarning, *snap.MemRSSMB)))
}
lines = append(lines, "")
// Status
icon := statusIconChar(p.Status())
iconColor := statusIconColor(p.Status())
styledIcon := lipgloss.NewStyle().Foreground(iconColor).Render(icon)
lines = append(lines, labelStyle.Render(" Status")+styledIcon+" "+valueStyle.Render(snap.Status))
// PID
if snap.PID > 0 {
lines = append(lines, row(" PID", fmt.Sprintf("%d", snap.PID)))
}
// Ready
readyStr := "no"
if snap.Ready {
readyStr = "yes"
}
lines = append(lines, row(" Ready", readyStr))
// Exit code
if snap.ExitCode != nil {
lines = append(lines, row(" Exit code", fmt.Sprintf("%d", *snap.ExitCode)))
}
// Timing
lines = append(lines, "")
lines = append(lines, titleStyle.Render(" Timing"))
if !snap.StartedAt.IsZero() {
lines = append(lines, row(" Started", snap.StartedAt.Format(time.RFC3339)))
lines = append(lines, row(" Uptime", formatDuration(time.Since(snap.StartedAt))))
}
if snap.StartupDurationS != nil {
lines = append(lines, row(" Startup", fmt.Sprintf("%.1fs", *snap.StartupDurationS)))
}
// Resources (only if metrics have been sampled)
if snap.MemRSSMB != nil {
lines = append(lines, "")
lines = append(lines, titleStyle.Render(" Resources"))
lines = append(lines, row(" Memory (RSS)", fmt.Sprintf("%.1f MB", *snap.MemRSSMB)))
if snap.PeakMemRSSMB != nil {
lines = append(lines, row(" Peak memory", fmt.Sprintf("%.1f MB", *snap.PeakMemRSSMB)))
}
if snap.CPUPercent != nil {
lines = append(lines, row(" CPU", fmt.Sprintf("%.1f%%", *snap.CPUPercent)))
}
if snap.CPUTimeS != nil {
lines = append(lines, row(" CPU time", fmt.Sprintf("%.1fs", *snap.CPUTimeS)))
}
if snap.ThreadCount != nil {
lines = append(lines, row(" Threads", fmt.Sprintf("%d", *snap.ThreadCount)))
}
if snap.ChildProcessCount != nil {
lines = append(lines, row(" Children", fmt.Sprintf("%d", *snap.ChildProcessCount)))
}
if snap.FDCount != nil {
lines = append(lines, row(" File descriptors", fmt.Sprintf("%d", *snap.FDCount)))
}
}
// Config
lines = append(lines, "")
lines = append(lines, titleStyle.Render(" Config"))
if len(p.Cfg.Cmd) > 0 {
lines = append(lines, row(" Command", strings.Join(p.Cfg.Cmd, " ")))
} else {
lines = append(lines, row(" Command", p.Cfg.Shell))
}
if p.Cfg.ReadyPattern != "" {
lines = append(lines, row(" Ready pattern", p.Cfg.ReadyPattern))
}
if p.Cfg.Autorestart {
lines = append(lines, row(" Autorestart", "yes"))
}
// Buffered lines
lines = append(lines, row(" Buffered lines", fmt.Sprintf("%d", len(p.Lines()))))
return strings.Join(lines, "\n")
}
func formatDuration(d time.Duration) string {
if d < time.Minute {
return fmt.Sprintf("%.0fs", d.Seconds())
}
if d < time.Hour {
return fmt.Sprintf("%dm %ds", int(d.Minutes()), int(d.Seconds())%60)
}
return fmt.Sprintf("%dh %dm", int(d.Hours()), int(d.Minutes())%60)
}