Skip to content

: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.

16.2 KB
Raw Blame
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)
}