Refactor bee CLI and LiveCD integration

audit/internal/tui/forms.go

@@ -0,0 +1,98 @@
+package tui
+
+import tea "github.com/charmbracelet/bubbletea"
+
+func (m model) updateStaticForm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "esc":
+		m.screen = screenNetwork
+		m.formFields = nil
+		m.formIndex = 0
+		return m, nil
+	case "up", "shift+tab":
+		if m.formIndex > 0 {
+			m.formIndex--
+		}
+	case "down", "tab":
+		if m.formIndex < len(m.formFields)-1 {
+			m.formIndex++
+		}
+	case "enter":
+		if m.formIndex < len(m.formFields)-1 {
+			m.formIndex++
+			return m, nil
+		}
+		cfg := m.app.ParseStaticIPv4Config(m.selectedIface, []string{
+			m.formFields[0].Value,
+			m.formFields[1].Value,
+			m.formFields[2].Value,
+			m.formFields[3].Value,
+		})
+		m.busy = true
+		return m, func() tea.Msg {
+			result, err := m.app.SetStaticIPv4Result(cfg)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenNetwork}
+		}
+	case "backspace":
+		field := &m.formFields[m.formIndex]
+		if len(field.Value) > 0 {
+			field.Value = field.Value[:len(field.Value)-1]
+		}
+	default:
+		if msg.Type == tea.KeyRunes && len(msg.Runes) > 0 {
+			m.formFields[m.formIndex].Value += string(msg.Runes)
+		}
+	}
+	return m, nil
+}
+
+func (m model) updateConfirm(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch msg.String() {
+	case "left", "up", "tab":
+		if m.cursor > 0 {
+			m.cursor--
+		}
+	case "right", "down":
+		if m.cursor < 1 {
+			m.cursor++
+		}
+	case "esc":
+		m.screen = m.confirmCancelTarget()
+		m.cursor = 0
+		return m, nil
+	case "enter":
+		if m.cursor == 1 {
+			m.screen = m.confirmCancelTarget()
+			m.cursor = 0
+			return m, nil
+		}
+		m.busy = true
+		switch m.pendingAction {
+		case actionExportAudit:
+			target := *m.selectedTarget
+			return m, func() tea.Msg {
+				result, err := m.app.ExportLatestAuditResult(target)
+				return resultMsg{title: result.Title, body: result.Body, err: err, back: screenMain}
+			}
+		case actionRunNvidiaSAT:
+			return m, func() tea.Msg {
+				result, err := m.app.RunNvidiaAcceptancePackResult("")
+				return resultMsg{title: result.Title, body: result.Body, err: err, back: screenAcceptance}
+			}
+		}
+	case "ctrl+c":
+		return m, tea.Quit
+	}
+	return m, nil
+}
+
+func (m model) confirmCancelTarget() screen {
+	switch m.pendingAction {
+	case actionExportAudit:
+		return screenExportTargets
+	case actionRunNvidiaSAT:
+		return screenAcceptance
+	default:
+		return screenMain
+	}
+}

audit/internal/tui/messages.go

@@ -0,0 +1,25 @@
+package tui
+
+import "bee/audit/internal/platform"
+
+type resultMsg struct {
+	title string
+	body  string
+	err   error
+	back  screen
+}
+
+type servicesMsg struct {
+	services []string
+	err      error
+}
+
+type interfacesMsg struct {
+	ifaces []platform.InterfaceInfo
+	err    error
+}
+
+type exportTargetsMsg struct {
+	targets []platform.RemovableTarget
+	err     error
+}

audit/internal/tui/screen_acceptance.go

@@ -0,0 +1,14 @@
+package tui
+
+import tea "github.com/charmbracelet/bubbletea"
+
+func (m model) handleAcceptanceMenu() (tea.Model, tea.Cmd) {
+	if m.cursor == 1 {
+		m.screen = screenMain
+		m.cursor = 0
+		return m, nil
+	}
+	m.pendingAction = actionRunNvidiaSAT
+	m.screen = screenConfirm
+	return m, nil
+}

audit/internal/tui/screen_export.go

@@ -0,0 +1,14 @@
+package tui
+
+import tea "github.com/charmbracelet/bubbletea"
+
+func (m model) handleExportTargetsMenu() (tea.Model, tea.Cmd) {
+	if len(m.targets) == 0 {
+		return m, resultCmd("Export audit", "No removable filesystems found", nil, screenMain)
+	}
+	target := m.targets[m.cursor]
+	m.selectedTarget = &target
+	m.pendingAction = actionExportAudit
+	m.screen = screenConfirm
+	return m, nil
+}

audit/internal/tui/screen_main.go

@@ -0,0 +1,51 @@
+package tui
+
+import (
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m model) handleMainMenu() (tea.Model, tea.Cmd) {
+	switch m.cursor {
+	case 0:
+		m.screen = screenNetwork
+		m.cursor = 0
+		return m, nil
+	case 1:
+		m.busy = true
+		return m, func() tea.Msg {
+			services, err := m.app.ListBeeServices()
+			return servicesMsg{services: services, err: err}
+		}
+	case 2:
+		m.screen = screenAcceptance
+		m.cursor = 0
+		return m, nil
+	case 3:
+		m.busy = true
+		return m, func() tea.Msg {
+			result, err := m.app.RunAuditNow(m.runtimeMode)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenMain}
+		}
+	case 4:
+		m.busy = true
+		return m, func() tea.Msg {
+			targets, err := m.app.ListRemovableTargets()
+			return exportTargetsMsg{targets: targets, err: err}
+		}
+	case 5:
+		m.busy = true
+		return m, func() tea.Msg {
+			result := m.app.ToolCheckResult([]string{"dmidecode", "smartctl", "nvme", "ipmitool", "lspci", "bee", "nvidia-smi", "dhclient", "lsblk", "mount"})
+			return resultMsg{title: result.Title, body: result.Body, back: screenMain}
+		}
+	case 6:
+		m.busy = true
+		return m, func() tea.Msg {
+			result := m.app.AuditLogTailResult()
+			return resultMsg{title: result.Title, body: result.Body, back: screenMain}
+		}
+	case 7:
+		return m, tea.Quit
+	}
+	return m, nil
+}

audit/internal/tui/screen_network.go

@@ -0,0 +1,71 @@
+package tui
+
+import (
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m model) handleNetworkMenu() (tea.Model, tea.Cmd) {
+	switch m.cursor {
+	case 0:
+		m.busy = true
+		return m, func() tea.Msg {
+			result, err := m.app.NetworkStatus()
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenNetwork}
+		}
+	case 1:
+		m.busy = true
+		return m, func() tea.Msg {
+			result, err := m.app.DHCPAllResult()
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenNetwork}
+		}
+	case 2:
+		m.pendingAction = actionDHCPOne
+		m.busy = true
+		return m, func() tea.Msg {
+			ifaces, err := m.app.ListInterfaces()
+			return interfacesMsg{ifaces: ifaces, err: err}
+		}
+	case 3:
+		m.pendingAction = actionStaticIPv4
+		m.busy = true
+		return m, func() tea.Msg {
+			ifaces, err := m.app.ListInterfaces()
+			return interfacesMsg{ifaces: ifaces, err: err}
+		}
+	case 4:
+		m.screen = screenMain
+		m.cursor = 0
+		return m, nil
+	}
+	return m, nil
+}
+
+func (m model) handleInterfacePickMenu() (tea.Model, tea.Cmd) {
+	if len(m.interfaces) == 0 {
+		return m, resultCmd("interfaces", "No physical interfaces found", nil, screenNetwork)
+	}
+	m.selectedIface = m.interfaces[m.cursor].Name
+	switch m.pendingAction {
+	case actionDHCPOne:
+		m.busy = true
+		return m, func() tea.Msg {
+			result, err := m.app.DHCPOneResult(m.selectedIface)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenNetwork}
+		}
+	case actionStaticIPv4:
+		defaults := m.app.DefaultStaticIPv4FormFields(m.selectedIface)
+		m.formFields = []formField{
+			{Label: "IPv4 address", Value: defaults[0]},
+			{Label: "Prefix", Value: defaults[1]},
+			{Label: "Gateway", Value: strings.TrimSpace(defaults[2])},
+			{Label: "DNS (space-separated)", Value: defaults[3]},
+		}
+		m.formIndex = 0
+		m.screen = screenStaticForm
+		return m, nil
+	default:
+		return m, nil
+	}
+}

audit/internal/tui/screen_services.go

@@ -0,0 +1,46 @@
+package tui
+
+import (
+	"bee/audit/internal/platform"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m model) handleServicesMenu() (tea.Model, tea.Cmd) {
+	if len(m.services) == 0 {
+		return m, resultCmd("bee services", "No bee-* services found", nil, screenMain)
+	}
+	m.selectedService = m.services[m.cursor]
+	m.screen = screenServiceAction
+	m.cursor = 0
+	return m, nil
+}
+
+func (m model) handleServiceActionMenu() (tea.Model, tea.Cmd) {
+	action := m.serviceMenu[m.cursor]
+	if action == "back" {
+		m.screen = screenServices
+		m.cursor = 0
+		return m, nil
+	}
+
+	m.busy = true
+	return m, func() tea.Msg {
+		switch action {
+		case "status":
+			result, err := m.app.ServiceStatusResult(m.selectedService)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenServiceAction}
+		case "restart":
+			result, err := m.app.ServiceActionResult(m.selectedService, platform.ServiceRestart)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenServiceAction}
+		case "start":
+			result, err := m.app.ServiceActionResult(m.selectedService, platform.ServiceStart)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenServiceAction}
+		case "stop":
+			result, err := m.app.ServiceActionResult(m.selectedService, platform.ServiceStop)
+			return resultMsg{title: result.Title, body: result.Body, err: err, back: screenServiceAction}
+		default:
+			return resultMsg{title: "service", body: "unknown action", back: screenServiceAction}
+		}
+	}
+}

audit/internal/tui/tui_test.go

@@ -0,0 +1,349 @@
+package tui
+
+import (
+	"testing"
+
+	"bee/audit/internal/app"
+	"bee/audit/internal/platform"
+	"bee/audit/internal/runtimeenv"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func newTestModel() model {
+	return newModel(app.New(platform.New()), runtimeenv.ModeLocal)
+}
+
+func sendKey(t *testing.T, m model, key tea.KeyType) model {
+	t.Helper()
+
+	next, _ := m.Update(tea.KeyMsg{Type: key})
+	return next.(model)
+}
+
+func TestUpdateMainMenuCursorNavigation(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+
+	m = sendKey(t, m, tea.KeyDown)
+	if m.cursor != 1 {
+		t.Fatalf("cursor=%d want 1 after down", m.cursor)
+	}
+
+	m = sendKey(t, m, tea.KeyDown)
+	if m.cursor != 2 {
+		t.Fatalf("cursor=%d want 2 after second down", m.cursor)
+	}
+
+	m = sendKey(t, m, tea.KeyUp)
+	if m.cursor != 1 {
+		t.Fatalf("cursor=%d want 1 after up", m.cursor)
+	}
+}
+
+func TestUpdateMainMenuEnterActions(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		cursor     int
+		wantScreen screen
+		wantBusy   bool
+		wantCmd    bool
+	}{
+		{name: "network", cursor: 0, wantScreen: screenNetwork},
+		{name: "services", cursor: 1, wantScreen: screenMain, wantBusy: true, wantCmd: true},
+		{name: "acceptance", cursor: 2, wantScreen: screenAcceptance},
+		{name: "run audit", cursor: 3, wantScreen: screenMain, wantBusy: true, wantCmd: true},
+		{name: "export", cursor: 4, wantScreen: screenMain, wantBusy: true, wantCmd: true},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			m := newTestModel()
+			m.cursor = test.cursor
+
+			next, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
+			got := next.(model)
+
+			if got.screen != test.wantScreen {
+				t.Fatalf("screen=%q want %q", got.screen, test.wantScreen)
+			}
+			if got.busy != test.wantBusy {
+				t.Fatalf("busy=%v want %v", got.busy, test.wantBusy)
+			}
+			if (cmd != nil) != test.wantCmd {
+				t.Fatalf("cmd present=%v want %v", cmd != nil, test.wantCmd)
+			}
+		})
+	}
+}
+
+func TestUpdateConfirmCancelViaKeys(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.screen = screenConfirm
+	m.pendingAction = actionRunNvidiaSAT
+
+	next, _ := m.Update(tea.KeyMsg{Type: tea.KeyRight})
+	got := next.(model)
+	if got.cursor != 1 {
+		t.Fatalf("cursor=%d want 1 after right", got.cursor)
+	}
+
+	next, _ = got.Update(tea.KeyMsg{Type: tea.KeyEnter})
+	got = next.(model)
+	if got.screen != screenAcceptance {
+		t.Fatalf("screen=%q want %q", got.screen, screenAcceptance)
+	}
+	if got.cursor != 0 {
+		t.Fatalf("cursor=%d want 0 after cancel", got.cursor)
+	}
+}
+
+func TestMainMenuSimpleTransitions(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		cursor     int
+		wantScreen screen
+	}{
+		{name: "network", cursor: 0, wantScreen: screenNetwork},
+		{name: "acceptance", cursor: 2, wantScreen: screenAcceptance},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			m := newTestModel()
+			m.cursor = test.cursor
+
+			next, cmd := m.handleMainMenu()
+			got := next.(model)
+
+			if cmd != nil {
+				t.Fatalf("expected nil cmd for %s", test.name)
+			}
+			if got.screen != test.wantScreen {
+				t.Fatalf("screen=%q want %q", got.screen, test.wantScreen)
+			}
+			if got.cursor != 0 {
+				t.Fatalf("cursor=%d want 0", got.cursor)
+			}
+		})
+	}
+}
+
+func TestMainMenuAsyncActionsSetBusy(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name   string
+		cursor int
+	}{
+		{name: "services", cursor: 1},
+		{name: "run audit", cursor: 3},
+		{name: "export", cursor: 4},
+		{name: "check tools", cursor: 5},
+		{name: "log tail", cursor: 6},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			m := newTestModel()
+			m.cursor = test.cursor
+
+			next, cmd := m.handleMainMenu()
+			got := next.(model)
+
+			if !got.busy {
+				t.Fatalf("busy=false for %s", test.name)
+			}
+			if cmd == nil {
+				t.Fatalf("expected async cmd for %s", test.name)
+			}
+		})
+	}
+}
+
+func TestEscapeNavigation(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name       string
+		screen     screen
+		wantScreen screen
+	}{
+		{name: "network to main", screen: screenNetwork, wantScreen: screenMain},
+		{name: "services to main", screen: screenServices, wantScreen: screenMain},
+		{name: "acceptance to main", screen: screenAcceptance, wantScreen: screenMain},
+		{name: "service action to services", screen: screenServiceAction, wantScreen: screenServices},
+		{name: "export targets to main", screen: screenExportTargets, wantScreen: screenMain},
+		{name: "interface pick to network", screen: screenInterfacePick, wantScreen: screenNetwork},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			t.Parallel()
+
+			m := newTestModel()
+			m.screen = test.screen
+			m.cursor = 3
+
+			next, _ := m.updateKey(tea.KeyMsg{Type: tea.KeyEsc})
+			got := next.(model)
+
+			if got.screen != test.wantScreen {
+				t.Fatalf("screen=%q want %q", got.screen, test.wantScreen)
+			}
+			if got.cursor != 0 {
+				t.Fatalf("cursor=%d want 0", got.cursor)
+			}
+		})
+	}
+}
+
+func TestOutputScreenReturnsToPreviousScreen(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.screen = screenOutput
+	m.prevScreen = screenNetwork
+	m.title = "title"
+	m.body = "body"
+
+	next, _ := m.updateKey(tea.KeyMsg{Type: tea.KeyEnter})
+	got := next.(model)
+
+	if got.screen != screenNetwork {
+		t.Fatalf("screen=%q want %q", got.screen, screenNetwork)
+	}
+	if got.title != "" || got.body != "" {
+		t.Fatalf("expected output state cleared, got title=%q body=%q", got.title, got.body)
+	}
+}
+
+func TestAcceptanceConfirmFlow(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.screen = screenAcceptance
+	m.cursor = 0
+
+	next, cmd := m.handleAcceptanceMenu()
+	got := next.(model)
+
+	if cmd != nil {
+		t.Fatal("expected nil cmd")
+	}
+	if got.screen != screenConfirm {
+		t.Fatalf("screen=%q want %q", got.screen, screenConfirm)
+	}
+	if got.pendingAction != actionRunNvidiaSAT {
+		t.Fatalf("pendingAction=%q want %q", got.pendingAction, actionRunNvidiaSAT)
+	}
+
+	next, _ = got.updateConfirm(tea.KeyMsg{Type: tea.KeyEsc})
+	got = next.(model)
+	if got.screen != screenAcceptance {
+		t.Fatalf("screen after esc=%q want %q", got.screen, screenAcceptance)
+	}
+}
+
+func TestExportTargetSelectionOpensConfirm(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.screen = screenExportTargets
+	m.targets = []platform.RemovableTarget{{Device: "/dev/sdb1", FSType: "vfat", Size: "16G"}}
+
+	next, cmd := m.handleExportTargetsMenu()
+	got := next.(model)
+
+	if cmd != nil {
+		t.Fatal("expected nil cmd")
+	}
+	if got.screen != screenConfirm {
+		t.Fatalf("screen=%q want %q", got.screen, screenConfirm)
+	}
+	if got.pendingAction != actionExportAudit {
+		t.Fatalf("pendingAction=%q want %q", got.pendingAction, actionExportAudit)
+	}
+	if got.selectedTarget == nil || got.selectedTarget.Device != "/dev/sdb1" {
+		t.Fatalf("selectedTarget=%+v want /dev/sdb1", got.selectedTarget)
+	}
+}
+
+func TestInterfacePickStaticIPv4OpensForm(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.pendingAction = actionStaticIPv4
+	m.interfaces = []platform.InterfaceInfo{{Name: "eth0"}}
+
+	next, cmd := m.handleInterfacePickMenu()
+	got := next.(model)
+
+	if cmd != nil {
+		t.Fatal("expected nil cmd")
+	}
+	if got.screen != screenStaticForm {
+		t.Fatalf("screen=%q want %q", got.screen, screenStaticForm)
+	}
+	if got.selectedIface != "eth0" {
+		t.Fatalf("selectedIface=%q want eth0", got.selectedIface)
+	}
+	if len(got.formFields) != 4 {
+		t.Fatalf("len(formFields)=%d want 4", len(got.formFields))
+	}
+}
+
+func TestResultMsgUsesExplicitBackScreen(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+	m.screen = screenConfirm
+
+	next, _ := m.Update(resultMsg{title: "done", body: "ok", back: screenNetwork})
+	got := next.(model)
+
+	if got.screen != screenOutput {
+		t.Fatalf("screen=%q want %q", got.screen, screenOutput)
+	}
+	if got.prevScreen != screenNetwork {
+		t.Fatalf("prevScreen=%q want %q", got.prevScreen, screenNetwork)
+	}
+}
+
+func TestConfirmCancelTarget(t *testing.T) {
+	t.Parallel()
+
+	m := newTestModel()
+
+	m.pendingAction = actionExportAudit
+	if got := m.confirmCancelTarget(); got != screenExportTargets {
+		t.Fatalf("export cancel target=%q want %q", got, screenExportTargets)
+	}
+
+	m.pendingAction = actionRunNvidiaSAT
+	if got := m.confirmCancelTarget(); got != screenAcceptance {
+		t.Fatalf("sat cancel target=%q want %q", got, screenAcceptance)
+	}
+
+	m.pendingAction = actionNone
+	if got := m.confirmCancelTarget(); got != screenMain {
+		t.Fatalf("default cancel target=%q want %q", got, screenMain)
+	}
+}

audit/internal/tui/types.go

@@ -0,0 +1,107 @@
+package tui
+
+import (
+	"bee/audit/internal/app"
+	"bee/audit/internal/platform"
+	"bee/audit/internal/runtimeenv"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type screen string
+
+const (
+	screenMain          screen = "main"
+	screenNetwork       screen = "network"
+	screenInterfacePick screen = "interface_pick"
+	screenServices      screen = "services"
+	screenServiceAction screen = "service_action"
+	screenAcceptance    screen = "acceptance"
+	screenExportTargets screen = "export_targets"
+	screenOutput        screen = "output"
+	screenStaticForm    screen = "static_form"
+	screenConfirm       screen = "confirm"
+)
+
+type actionKind string
+
+const (
+	actionNone         actionKind = ""
+	actionDHCPOne      actionKind = "dhcp_one"
+	actionStaticIPv4   actionKind = "static_ipv4"
+	actionExportAudit  actionKind = "export_audit"
+	actionRunNvidiaSAT actionKind = "run_nvidia_sat"
+)
+
+type model struct {
+	app         *app.App
+	runtimeMode runtimeenv.Mode
+
+	screen      screen
+	prevScreen  screen
+	cursor      int
+	busy        bool
+	title       string
+	body        string
+	mainMenu    []string
+	networkMenu []string
+	serviceMenu []string
+
+	services        []string
+	interfaces      []platform.InterfaceInfo
+	targets         []platform.RemovableTarget
+	selectedService string
+	selectedIface   string
+	selectedTarget  *platform.RemovableTarget
+	pendingAction   actionKind
+
+	formFields []formField
+	formIndex  int
+}
+
+type formField struct {
+	Label string
+	Value string
+}
+
+func Run(application *app.App, runtimeMode runtimeenv.Mode) error {
+	program := tea.NewProgram(newModel(application, runtimeMode), tea.WithAltScreen())
+	_, err := program.Run()
+	return err
+}
+
+func newModel(application *app.App, runtimeMode runtimeenv.Mode) model {
+	return model{
+		app:         application,
+		runtimeMode: runtimeMode,
+		screen:      screenMain,
+		mainMenu: []string{
+			"Network setup",
+			"bee service management",
+			"System acceptance tests",
+			"Run audit now",
+			"Export audit to removable drive",
+			"Check required tools",
+			"Show last audit log tail",
+			"Exit",
+		},
+		networkMenu: []string{
+			"Show network status",
+			"DHCP on all interfaces",
+			"DHCP on one interface",
+			"Set static IPv4 on one interface",
+			"Back",
+		},
+		serviceMenu: []string{
+			"status",
+			"restart",
+			"start",
+			"stop",
+			"back",
+		},
+	}
+}
+
+func (m model) Init() tea.Cmd {
+	return nil
+}

audit/internal/tui/update.go

@@ -0,0 +1,154 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.KeyMsg:
+		if m.busy {
+			switch msg.String() {
+			case "ctrl+c":
+				return m, tea.Quit
+			default:
+				return m, nil
+			}
+		}
+		return m.updateKey(msg)
+	case resultMsg:
+		m.busy = false
+		m.title = msg.title
+		if msg.err != nil {
+			m.body = fmt.Sprintf("%s\n\nERROR: %v", strings.TrimSpace(msg.body), msg.err)
+		} else {
+			m.body = msg.body
+		}
+		if msg.back != "" {
+			m.prevScreen = msg.back
+		} else {
+			m.prevScreen = m.screen
+		}
+		m.screen = screenOutput
+		m.cursor = 0
+		return m, nil
+	case servicesMsg:
+		m.busy = false
+		if msg.err != nil {
+			m.title = "bee services"
+			m.body = msg.err.Error()
+			m.prevScreen = screenMain
+			m.screen = screenOutput
+			return m, nil
+		}
+		m.services = msg.services
+		m.screen = screenServices
+		m.cursor = 0
+		return m, nil
+	case interfacesMsg:
+		m.busy = false
+		if msg.err != nil {
+			m.title = "interfaces"
+			m.body = msg.err.Error()
+			m.prevScreen = screenMain
+			m.screen = screenOutput
+			return m, nil
+		}
+		m.interfaces = msg.ifaces
+		m.screen = screenInterfacePick
+		m.cursor = 0
+		return m, nil
+	case exportTargetsMsg:
+		m.busy = false
+		if msg.err != nil {
+			m.title = "export"
+			m.body = msg.err.Error()
+			m.prevScreen = screenMain
+			m.screen = screenOutput
+			return m, nil
+		}
+		m.targets = msg.targets
+		m.screen = screenExportTargets
+		m.cursor = 0
+		return m, nil
+	}
+
+	return m, nil
+}
+
+func (m model) updateKey(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
+	switch m.screen {
+	case screenMain:
+		return m.updateMenu(msg, len(m.mainMenu), m.handleMainMenu)
+	case screenNetwork:
+		return m.updateMenu(msg, len(m.networkMenu), m.handleNetworkMenu)
+	case screenServices:
+		return m.updateMenu(msg, len(m.services), m.handleServicesMenu)
+	case screenServiceAction:
+		return m.updateMenu(msg, len(m.serviceMenu), m.handleServiceActionMenu)
+	case screenAcceptance:
+		return m.updateMenu(msg, 2, m.handleAcceptanceMenu)
+	case screenExportTargets:
+		return m.updateMenu(msg, len(m.targets), m.handleExportTargetsMenu)
+	case screenInterfacePick:
+		return m.updateMenu(msg, len(m.interfaces), m.handleInterfacePickMenu)
+	case screenOutput:
+		switch msg.String() {
+		case "esc", "enter", "q":
+			m.screen = m.prevScreen
+			m.body = ""
+			m.title = ""
+			return m, nil
+		case "ctrl+c":
+			return m, tea.Quit
+		}
+	case screenStaticForm:
+		return m.updateStaticForm(msg)
+	case screenConfirm:
+		return m.updateConfirm(msg)
+	}
+
+	if msg.String() == "ctrl+c" {
+		return m, tea.Quit
+	}
+	return m, nil
+}
+
+func (m model) updateMenu(msg tea.KeyMsg, size int, onEnter func() (tea.Model, tea.Cmd)) (tea.Model, tea.Cmd) {
+	if size == 0 {
+		size = 1
+	}
+	switch msg.String() {
+	case "up", "k":
+		if m.cursor > 0 {
+			m.cursor--
+		}
+	case "down", "j":
+		if m.cursor < size-1 {
+			m.cursor++
+		}
+	case "enter":
+		return onEnter()
+	case "esc":
+		switch m.screen {
+		case screenNetwork, screenServices, screenAcceptance:
+			m.screen = screenMain
+			m.cursor = 0
+		case screenServiceAction:
+			m.screen = screenServices
+			m.cursor = 0
+		case screenExportTargets:
+			m.screen = screenMain
+			m.cursor = 0
+		case screenInterfacePick:
+			m.screen = screenNetwork
+			m.cursor = 0
+		}
+	case "q", "ctrl+c":
+		return m, tea.Quit
+	}
+	return m, nil
+}

audit/internal/tui/view.go

@@ -0,0 +1,137 @@
+package tui
+
+import (
+	"fmt"
+	"strings"
+
+	"bee/audit/internal/platform"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func (m model) View() string {
+	if m.busy {
+		return "bee\n\nWorking...\n"
+	}
+	switch m.screen {
+	case screenMain:
+		return renderMenu("bee", "Select action", m.mainMenu, m.cursor)
+	case screenNetwork:
+		return renderMenu("Network", "Select action", m.networkMenu, m.cursor)
+	case screenServices:
+		return renderMenu("bee services", "Select service", m.services, m.cursor)
+	case screenServiceAction:
+		items := make([]string, len(m.serviceMenu))
+		copy(items, m.serviceMenu)
+		return renderMenu("Service: "+m.selectedService, "Select action", items, m.cursor)
+	case screenAcceptance:
+		return renderMenu("System acceptance tests", "Select action", []string{"Run NVIDIA command pack", "Back"}, m.cursor)
+	case screenExportTargets:
+		return renderMenu("Export audit", "Select removable filesystem", renderTargetItems(m.targets), m.cursor)
+	case screenInterfacePick:
+		return renderMenu("Interfaces", "Select interface", renderInterfaceItems(m.interfaces), m.cursor)
+	case screenStaticForm:
+		return renderForm("Static IPv4: "+m.selectedIface, m.formFields, m.formIndex)
+	case screenConfirm:
+		title, body := m.confirmBody()
+		return renderConfirm(title, body, m.cursor)
+	case screenOutput:
+		return fmt.Sprintf("%s\n\n%s\n\n[enter/esc] back  [ctrl+c] quit\n", m.title, strings.TrimSpace(m.body))
+	default:
+		return "bee\n"
+	}
+}
+
+func (m model) confirmBody() (string, string) {
+	switch m.pendingAction {
+	case actionExportAudit:
+		if m.selectedTarget == nil {
+			return "Export audit", "No target selected"
+		}
+		return "Export audit", fmt.Sprintf("Copy latest audit JSON to %s?", m.selectedTarget.Device)
+	case actionRunNvidiaSAT:
+		return "NVIDIA SAT", "Run NVIDIA acceptance command pack?"
+	default:
+		return "Confirm", "Proceed?"
+	}
+}
+
+func renderTargetItems(targets []platform.RemovableTarget) []string {
+	items := make([]string, 0, len(targets))
+	for _, target := range targets {
+		desc := fmt.Sprintf("%s [%s %s]", target.Device, target.FSType, target.Size)
+		if target.Label != "" {
+			desc += " label=" + target.Label
+		}
+		if target.Mountpoint != "" {
+			desc += " mounted=" + target.Mountpoint
+		}
+		items = append(items, desc)
+	}
+	return items
+}
+
+func renderInterfaceItems(interfaces []platform.InterfaceInfo) []string {
+	items := make([]string, 0, len(interfaces))
+	for _, iface := range interfaces {
+		label := iface.Name
+		if len(iface.IPv4) > 0 {
+			label += " [" + strings.Join(iface.IPv4, ", ") + "]"
+		}
+		items = append(items, label)
+	}
+	return items
+}
+
+func renderMenu(title, subtitle string, items []string, cursor int) string {
+	var body strings.Builder
+	fmt.Fprintf(&body, "%s\n\n%s\n\n", title, subtitle)
+	if len(items) == 0 {
+		body.WriteString("(no items)\n")
+	} else {
+		for i, item := range items {
+			prefix := "  "
+			if i == cursor {
+				prefix = "> "
+			}
+			fmt.Fprintf(&body, "%s%s\n", prefix, item)
+		}
+	}
+	body.WriteString("\n[↑/↓] move  [enter] select  [esc] back  [ctrl+c] quit\n")
+	return body.String()
+}
+
+func renderForm(title string, fields []formField, idx int) string {
+	var body strings.Builder
+	fmt.Fprintf(&body, "%s\n\n", title)
+	for i, field := range fields {
+		prefix := "  "
+		if i == idx {
+			prefix = "> "
+		}
+		fmt.Fprintf(&body, "%s%s: %s\n", prefix, field.Label, field.Value)
+	}
+	body.WriteString("\n[tab/↑/↓] move  [enter] next/submit  [backspace] delete  [esc] cancel\n")
+	return body.String()
+}
+
+func renderConfirm(title, body string, cursor int) string {
+	options := []string{"Confirm", "Cancel"}
+	var out strings.Builder
+	fmt.Fprintf(&out, "%s\n\n%s\n\n", title, body)
+	for i, option := range options {
+		prefix := "  "
+		if i == cursor {
+			prefix = "> "
+		}
+		fmt.Fprintf(&out, "%s%s\n", prefix, option)
+	}
+	out.WriteString("\n[←/→/↑/↓] move  [enter] select  [esc] cancel\n")
+	return out.String()
+}
+
+func resultCmd(title, body string, err error, back screen) tea.Cmd {
+	return func() tea.Msg {
+		return resultMsg{title: title, body: body, err: err, back: back}
+	}
+}