mirror of
https://github.com/lukaszraczylo/kportal.git
synced 2026-10-12 04:35:10 +00:00
4d263319ab
* feat: add --context to forward only selected contexts
kportal forwards every context in the config file. When the file describes
several clusters that host the same services, that means holding connections
open to clusters nobody is using, and - because all contexts are active at once
- every localPort has to be globally unique. The same service therefore lands on
a different local port per cluster, so switching clusters means reconfiguring
the app being developed.
--context limits a run to the contexts you name. It is repeatable and accepts
comma-separated values, and composes with -headless:
kportal --context development-team-a
kportal --context team-a,team-b -headless
kportal --context team-a --context team-b
An unknown name is an error listing the contexts the file defines, so a typo
fails loudly instead of silently forwarding nothing.
Local-port and mDNS-hostname conflicts are now scoped to forwards that could run
at the same time: same context, or both contexts in the active selection. With
no selection every context is active, so existing behaviour is unchanged.
Contexts that are never selected together may reuse the same localPort, which is
what lets a service keep one fixed local port in every cluster.
Validation still covers the whole file, so a problem in a context outside the
selection is still reported and --check does not get weaker. Loading, validating
and filtering are shared by every path that re-reads the config (startup, file
watcher, SIGHUP in both headless and verbose modes), so no path can forget the
selection.
Also fixes a latent identity bug this makes reachable: Forward.ID() is only
"alias:localPort" when an alias is set, which was unique across contexts only
because duplicate local ports were globally rejected. With ports now shareable,
deleting or editing a forward from the TUI could have matched same-alias
forwards in other contexts and silently removed them. Delete and edit are now
scoped to the context the row came from.
* fix(config): keep the running config when no selected context remains
A reload dropped selected contexts that no longer exist in the file.
When all of them vanished, the reload returned an empty config and the
manager stopped every forward after a single rename.
LoadForRuntime now returns an error in that case. The watcher keeps the
previous config, as it does for any other invalid reload.
Refs #80
* fix(ui): apply new table columns after a successful SIGHUP reload
The context selection moved the SIGHUP reload into reloadFromSignal,
which had no way to update the verbose table columns. The function now
takes a callback that runs only after the manager reloads without error.
The verbose table passes SetColumns.
Refs #80
* style: gofmt run_test.go
---------
Co-authored-by: André Cruz <[email protected]>
1550 lines
41 KiB
Go
1550 lines
41 KiB
Go
package ui
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os/exec"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/lukaszraczylo/kportal/internal/config"
|
|
"github.com/lukaszraczylo/kportal/internal/k8s"
|
|
)
|
|
|
|
// keyTypedText routes j and k to text input while a text field has focus.
|
|
const keyTypedText = "<typed-text>"
|
|
|
|
// isFilterableStep returns true if the step supports search/filter
|
|
func isFilterableStep(step AddWizardStep) bool {
|
|
switch step {
|
|
case StepSelectContext, StepSelectNamespace:
|
|
return true
|
|
case StepEnterResource:
|
|
// Only service selection is filterable (pod prefix and selector are text input)
|
|
return true // We'll check resource type in the handler
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// handleMainViewKeys handles keyboard input in the main view
|
|
func (m model) handleMainViewKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
// If delete confirmation is showing, handle it separately
|
|
if m.ui.deleteConfirming {
|
|
return m.handleDeleteConfirmation(msg)
|
|
}
|
|
|
|
switch msg.String() {
|
|
case "ctrl+c", "q":
|
|
return m, tea.Quit
|
|
|
|
case "up", "k":
|
|
m.ui.moveSelection(-1)
|
|
|
|
case "down", "j":
|
|
m.ui.moveSelection(1)
|
|
|
|
case "pgup", "ctrl+u":
|
|
m.ui.moveSelection(-10)
|
|
|
|
case "pgdown", "ctrl+d":
|
|
m.ui.moveSelection(10)
|
|
|
|
case " ", "enter":
|
|
m.ui.toggleSelected()
|
|
|
|
case "n": // Enter add wizard
|
|
m.ui.mu.Lock()
|
|
// Don't create a new wizard if one is already active
|
|
if m.ui.addWizard != nil || m.ui.removeWizard != nil || m.ui.benchmarkState != nil || m.ui.httpLogState != nil {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
if m.ui.discovery == nil || m.ui.mutator == nil {
|
|
// Dependencies not set up
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
m.ui.viewMode = ViewModeAddWizard
|
|
m.ui.addWizard = newAddWizardState()
|
|
m.ui.addWizard.loading = true
|
|
m.ui.mu.Unlock()
|
|
|
|
// Load contexts
|
|
return m, loadContextsCmd(m.ui.discovery)
|
|
|
|
case "e": // Edit selected forward
|
|
m.ui.mu.Lock()
|
|
// Don't create a new wizard if one is already active
|
|
if m.ui.addWizard != nil || m.ui.removeWizard != nil || m.ui.benchmarkState != nil || m.ui.httpLogState != nil {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
if len(m.ui.forwardOrder) == 0 {
|
|
// No forwards to edit
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
if m.ui.discovery == nil || m.ui.mutator == nil {
|
|
// Dependencies not set up
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
// Get the currently selected forward
|
|
currentSelectedIndex := m.ui.selectedIndex
|
|
if currentSelectedIndex < 0 || currentSelectedIndex >= len(m.ui.forwardOrder) {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
selectedID := m.ui.forwardOrder[currentSelectedIndex]
|
|
selectedForward, ok := m.ui.forwards[selectedID]
|
|
if !ok {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
// Create an add wizard pre-filled with the current forward's values
|
|
m.ui.viewMode = ViewModeAddWizard
|
|
m.ui.addWizard = newAddWizardState()
|
|
|
|
// Pre-fill the wizard with current values
|
|
m.ui.addWizard.selectedContext = selectedForward.Context
|
|
m.ui.addWizard.selectedNamespace = selectedForward.Namespace
|
|
m.ui.addWizard.resourceValue = selectedForward.Resource
|
|
m.ui.addWizard.remotePort = selectedForward.RemotePort
|
|
m.ui.addWizard.localPort = selectedForward.LocalPort
|
|
m.ui.addWizard.alias = selectedForward.Alias
|
|
m.ui.addWizard.httpLogOriginal = selectedForward.HTTPLog
|
|
m.ui.addWizard.httpLog = selectedForward.HTTPLog != nil && selectedForward.HTTPLog.Enabled
|
|
|
|
// Determine resource type from the resource string
|
|
if strings.HasPrefix(selectedForward.Type, "service") {
|
|
m.ui.addWizard.selectedResourceType = ResourceTypeService
|
|
} else {
|
|
m.ui.addWizard.selectedResourceType = ResourceTypePodPrefix
|
|
}
|
|
|
|
// Mark as edit mode and store original ID
|
|
m.ui.addWizard.isEditing = true
|
|
m.ui.addWizard.originalID = selectedID
|
|
m.ui.addWizard.originalContext = selectedForward.Context
|
|
|
|
// Start at the remote port step (skip context/namespace/resource selection)
|
|
m.ui.addWizard.step = StepEnterRemotePort
|
|
|
|
// Load resources to detect ports
|
|
m.ui.addWizard.loading = true
|
|
m.ui.mu.Unlock()
|
|
|
|
// Load pods or services to detect available ports
|
|
if m.ui.addWizard.selectedResourceType == ResourceTypeService {
|
|
return m, loadServicesCmd(m.ui.discovery, selectedForward.Context, selectedForward.Namespace)
|
|
}
|
|
return m, loadPodsCmd(m.ui.discovery, selectedForward.Context, selectedForward.Namespace)
|
|
|
|
case "d": // Delete currently selected forward - show confirmation
|
|
m.ui.mu.Lock()
|
|
|
|
// Don't overwrite existing confirmation dialog
|
|
if m.ui.deleteConfirming {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
if len(m.ui.forwardOrder) == 0 {
|
|
// No forwards to delete
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
if m.ui.mutator == nil {
|
|
// Dependencies not set up
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
// Get the currently selected forward
|
|
currentSelectedIndex := m.ui.selectedIndex
|
|
if currentSelectedIndex < 0 || currentSelectedIndex >= len(m.ui.forwardOrder) {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
selectedID := m.ui.forwardOrder[currentSelectedIndex]
|
|
selectedForward, ok := m.ui.forwards[selectedID]
|
|
if !ok {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
// Show confirmation dialog
|
|
m.ui.deleteConfirming = true
|
|
m.ui.deleteConfirmID = selectedID
|
|
m.ui.deleteConfirmContext = selectedForward.Context
|
|
m.ui.deleteConfirmAlias = selectedForward.Alias
|
|
m.ui.deleteConfirmCursor = 1 // Default to "No" for safety
|
|
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
|
|
case "b": // Benchmark selected forward
|
|
m.ui.mu.Lock()
|
|
// Don't create benchmark view if another modal is active
|
|
if m.ui.addWizard != nil || m.ui.removeWizard != nil || m.ui.benchmarkState != nil || m.ui.httpLogState != nil {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
if len(m.ui.forwardOrder) == 0 {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
currentSelectedIndex := m.ui.selectedIndex
|
|
if currentSelectedIndex < 0 || currentSelectedIndex >= len(m.ui.forwardOrder) {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
selectedID := m.ui.forwardOrder[currentSelectedIndex]
|
|
selectedForward, ok := m.ui.forwards[selectedID]
|
|
if !ok {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
// Create benchmark state
|
|
m.ui.viewMode = ViewModeBenchmark
|
|
m.ui.benchmarkState = newBenchmarkState(selectedID, selectedForward.Alias, selectedForward.LocalPort)
|
|
// Initialize textInput with the first field's value
|
|
m.ui.benchmarkState.textInput = m.ui.benchmarkState.urlPath
|
|
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
|
|
case "l": // View HTTP logs for selected forward
|
|
m.ui.mu.Lock()
|
|
// Don't create log view if another modal is active
|
|
if m.ui.addWizard != nil || m.ui.removeWizard != nil || m.ui.benchmarkState != nil || m.ui.httpLogState != nil {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
if len(m.ui.forwardOrder) == 0 {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
currentSelectedIndex := m.ui.selectedIndex
|
|
if currentSelectedIndex < 0 || currentSelectedIndex >= len(m.ui.forwardOrder) {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
selectedID := m.ui.forwardOrder[currentSelectedIndex]
|
|
selectedForward, ok := m.ui.forwards[selectedID]
|
|
if !ok {
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
// Create HTTP log state
|
|
m.ui.viewMode = ViewModeHTTPLog
|
|
m.ui.httpLogState = newHTTPLogState(selectedID, selectedForward.Alias)
|
|
|
|
// Capture subscriber and UI reference for the callback
|
|
subscriber := m.ui.httpLogSubscriber
|
|
ui := m.ui
|
|
m.ui.mu.Unlock()
|
|
|
|
// Subscribe to HTTP logs if subscriber is available
|
|
// This is done outside the lock to prevent deadlocks in the callback
|
|
if subscriber != nil {
|
|
cleanup := subscriber(selectedID, func(entry HTTPLogEntry) {
|
|
// Recover from panics in the callback
|
|
defer safeRecover("HTTPLogSubscriber callback")
|
|
|
|
// Use RLock to safely access program
|
|
ui.mu.RLock()
|
|
program := ui.program
|
|
ui.mu.RUnlock()
|
|
|
|
// Send entry to program (thread-safe via Send)
|
|
if program != nil {
|
|
program.Send(HTTPLogEntryMsg{Entry: entry})
|
|
}
|
|
})
|
|
ui.mu.Lock()
|
|
ui.httpLogCleanup = cleanup
|
|
ui.mu.Unlock()
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// handleDeleteConfirmation handles keyboard input for delete confirmation dialog
|
|
func (m model) handleDeleteConfirmation(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
|
|
switch msg.String() {
|
|
case "ctrl+c", "esc":
|
|
// Cancel deletion
|
|
m.ui.resetDeleteConfirmation()
|
|
m.ui.mu.Unlock()
|
|
return m, tea.ClearScreen
|
|
|
|
case "left", "h", "right", "l":
|
|
// Toggle between Yes/No
|
|
m.ui.deleteConfirmCursor = 1 - m.ui.deleteConfirmCursor
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
|
|
case "enter", "y":
|
|
// Confirm deletion (either Enter on Yes or pressing 'y')
|
|
if m.ui.deleteConfirmCursor == 0 || msg.String() == "y" {
|
|
id := m.ui.deleteConfirmID
|
|
contextName := m.ui.deleteConfirmContext
|
|
m.ui.resetDeleteConfirmation()
|
|
m.ui.mu.Unlock()
|
|
return m, removeForwardByIDCmd(m.ui.mutator, contextName, id)
|
|
}
|
|
// Enter on No = cancel
|
|
m.ui.resetDeleteConfirmation()
|
|
m.ui.mu.Unlock()
|
|
return m, tea.ClearScreen
|
|
|
|
case "n":
|
|
// Quick 'n' for no
|
|
m.ui.resetDeleteConfirmation()
|
|
m.ui.mu.Unlock()
|
|
return m, tea.ClearScreen
|
|
}
|
|
|
|
m.ui.mu.Unlock()
|
|
return m, nil
|
|
}
|
|
|
|
// handleAddWizardKeys handles keyboard input in the add wizard
|
|
func (m model) handleAddWizardKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
wizard := m.ui.addWizard
|
|
if wizard == nil {
|
|
return m, nil
|
|
}
|
|
|
|
key := msg.String()
|
|
if (key == "j" || key == "k") && wizard.isTypingText() {
|
|
key = keyTypedText
|
|
}
|
|
|
|
switch key {
|
|
case "ctrl+c":
|
|
// Hard cancel
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.addWizard = nil
|
|
return m, tea.ClearScreen
|
|
|
|
case "esc":
|
|
// If there's an active search filter, clear it instead of going back
|
|
if wizard.searchFilter != "" && isFilterableStep(wizard.step) {
|
|
wizard.clearSearchFilter()
|
|
return m, nil
|
|
}
|
|
|
|
// In edit mode, Esc always cancels (don't navigate back through skipped steps)
|
|
if wizard.isEditing {
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.addWizard = nil
|
|
return m, tea.ClearScreen
|
|
}
|
|
|
|
// In add mode, go back or cancel
|
|
if wizard.step == StepSelectContext {
|
|
// On first step, cancel entirely
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.addWizard = nil
|
|
return m, tea.ClearScreen
|
|
} else {
|
|
// Go back one step
|
|
wizard.step--
|
|
wizard.resetInput()
|
|
|
|
// Reset input mode based on the step we're going back to
|
|
switch wizard.step {
|
|
case StepSelectContext, StepSelectResourceType:
|
|
wizard.inputMode = InputModeList
|
|
case StepSelectNamespace:
|
|
if wizard.namespaceManual {
|
|
wizard.inputMode = InputModeText
|
|
} else {
|
|
wizard.inputMode = InputModeList
|
|
}
|
|
case StepEnterResource:
|
|
if wizard.selectedResourceType == ResourceTypeService {
|
|
wizard.inputMode = InputModeList
|
|
} else {
|
|
wizard.inputMode = InputModeText
|
|
}
|
|
case StepEnterRemotePort, StepEnterLocalPort:
|
|
wizard.inputMode = InputModeText
|
|
case StepConfirmation:
|
|
wizard.inputMode = InputModeList
|
|
}
|
|
}
|
|
return m, nil
|
|
|
|
case "up", "k":
|
|
// In confirmation step, toggle between alias and buttons
|
|
if wizard.step == StepConfirmation {
|
|
if wizard.confirmationFocus == FocusButtons {
|
|
wizard.confirmationFocus = FocusAlias
|
|
}
|
|
} else {
|
|
wizard.moveCursor(-1)
|
|
}
|
|
|
|
case "down", "j":
|
|
// In confirmation step, toggle between alias and buttons
|
|
if wizard.step == StepConfirmation {
|
|
if wizard.confirmationFocus == FocusAlias {
|
|
wizard.confirmationFocus = FocusButtons
|
|
wizard.cursor = 0
|
|
} else {
|
|
wizard.moveCursor(1) // Navigate between buttons
|
|
}
|
|
} else {
|
|
wizard.moveCursor(1)
|
|
}
|
|
|
|
case "pgup", "ctrl+u":
|
|
// Page up - move 10 items
|
|
wizard.moveCursor(-10)
|
|
|
|
case "pgdown", "ctrl+d":
|
|
// Page down - move 10 items
|
|
wizard.moveCursor(10)
|
|
|
|
case "tab":
|
|
// Tab moves between alias field and buttons in confirmation
|
|
if wizard.step == StepConfirmation {
|
|
if wizard.confirmationFocus == FocusAlias {
|
|
wizard.confirmationFocus = FocusButtons
|
|
wizard.cursor = 0
|
|
} else {
|
|
wizard.confirmationFocus = FocusAlias
|
|
}
|
|
}
|
|
|
|
case "h":
|
|
// In confirmation step (when not typing into the alias field), 'h'
|
|
// toggles whether this forward has HTTP traffic logging enabled.
|
|
// When the alias field is focused, fall through to text input below.
|
|
if wizard.step == StepConfirmation && wizard.confirmationFocus != FocusAlias {
|
|
wizard.httpLog = !wizard.httpLog
|
|
return m, nil
|
|
}
|
|
// Otherwise treat as text input (filter or alias).
|
|
canTypeText := wizard.inputMode == InputModeText ||
|
|
(wizard.step == StepConfirmation && wizard.confirmationFocus == FocusAlias) ||
|
|
(wizard.inputMode == InputModeList && isFilterableStep(wizard.step))
|
|
if canTypeText {
|
|
if wizard.inputMode == InputModeList && isFilterableStep(wizard.step) {
|
|
wizard.searchFilter += "h"
|
|
wizard.cursor = 0
|
|
wizard.scrollOffset = 0
|
|
} else {
|
|
wizard.handleTextInput('h')
|
|
}
|
|
}
|
|
return m, nil
|
|
|
|
case "enter":
|
|
return m.handleAddWizardEnter()
|
|
|
|
case "backspace":
|
|
// Allow backspace in text input mode OR when focused on alias in confirmation OR when filtering
|
|
canBackspace := wizard.inputMode == InputModeText ||
|
|
(wizard.step == StepConfirmation && wizard.confirmationFocus == FocusAlias) ||
|
|
(wizard.inputMode == InputModeList && isFilterableStep(wizard.step) && len(wizard.searchFilter) > 0)
|
|
|
|
if canBackspace {
|
|
if isFilterableStep(wizard.step) && wizard.inputMode == InputModeList && len(wizard.searchFilter) > 0 {
|
|
// Backspace in search filter
|
|
wizard.searchFilter = wizard.searchFilter[:len(wizard.searchFilter)-1]
|
|
wizard.cursor = 0
|
|
wizard.scrollOffset = 0
|
|
} else if len(wizard.textInput) > 0 {
|
|
wizard.textInput = wizard.textInput[:len(wizard.textInput)-1]
|
|
}
|
|
}
|
|
|
|
default:
|
|
// Handle text input
|
|
canTypeText := wizard.inputMode == InputModeText ||
|
|
(wizard.step == StepConfirmation && wizard.confirmationFocus == FocusAlias) ||
|
|
(wizard.inputMode == InputModeList && isFilterableStep(wizard.step))
|
|
|
|
if canTypeText && len(msg.String()) == 1 {
|
|
// If in list mode on filterable step, add to search filter instead of textInput
|
|
if wizard.inputMode == InputModeList && isFilterableStep(wizard.step) {
|
|
char := rune(msg.String()[0])
|
|
// Only allow printable characters
|
|
if char >= 32 && char < 127 {
|
|
wizard.searchFilter += string(char)
|
|
wizard.cursor = 0
|
|
wizard.scrollOffset = 0
|
|
}
|
|
} else {
|
|
wizard.handleTextInput(rune(msg.String()[0]))
|
|
|
|
// Trigger validation for selector
|
|
if wizard.step == StepEnterResource && wizard.selectedResourceType == ResourceTypePodSelector {
|
|
if len(wizard.textInput) > 0 {
|
|
wizard.loading = true
|
|
wizard.error = nil
|
|
return m, validateSelectorCmd(m.ui.discovery, wizard.selectedContext, wizard.selectedNamespace, wizard.textInput)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// handleAddWizardEnter handles Enter key in the add wizard
|
|
func (m model) handleAddWizardEnter() (tea.Model, tea.Cmd) {
|
|
wizard := m.ui.addWizard
|
|
|
|
// Don't process Enter if we're currently loading
|
|
if wizard.loading {
|
|
return m, nil
|
|
}
|
|
|
|
switch wizard.step {
|
|
case StepSelectContext:
|
|
filteredContexts := wizard.getFilteredContexts()
|
|
if wizard.cursor >= 0 && wizard.cursor < len(filteredContexts) {
|
|
wizard.selectedContext = filteredContexts[wizard.cursor]
|
|
wizard.step = StepSelectNamespace
|
|
wizard.cursor = 0
|
|
wizard.clearSearchFilter()
|
|
wizard.loading = true
|
|
wizard.namespaceManual = false
|
|
wizard.namespaceListErr = nil
|
|
wizard.inputMode = InputModeList
|
|
return m, loadNamespacesCmd(m.ui.discovery, wizard.selectedContext)
|
|
}
|
|
|
|
case StepSelectNamespace:
|
|
if wizard.namespaceManual {
|
|
name := strings.TrimSpace(wizard.textInput)
|
|
if err := config.ValidateNamespaceName(name); err != nil {
|
|
wizard.error = err
|
|
return m, nil
|
|
}
|
|
wizard.error = nil
|
|
wizard.selectedNamespace = name
|
|
wizard.step = StepSelectResourceType
|
|
wizard.cursor = 0
|
|
wizard.clearTextInput()
|
|
wizard.inputMode = InputModeList
|
|
return m, nil
|
|
}
|
|
filteredNamespaces := wizard.getFilteredNamespaces()
|
|
if wizard.cursor >= 0 && wizard.cursor < len(filteredNamespaces) {
|
|
wizard.selectedNamespace = filteredNamespaces[wizard.cursor]
|
|
wizard.step = StepSelectResourceType
|
|
wizard.cursor = 0
|
|
wizard.clearSearchFilter()
|
|
wizard.inputMode = InputModeList
|
|
}
|
|
|
|
case StepSelectResourceType:
|
|
if wizard.cursor >= 0 && wizard.cursor < 3 {
|
|
wizard.selectedResourceType = ResourceType(wizard.cursor)
|
|
wizard.step = StepEnterResource
|
|
wizard.cursor = 0
|
|
|
|
if wizard.selectedResourceType == ResourceTypeService {
|
|
wizard.inputMode = InputModeList
|
|
wizard.loading = true
|
|
return m, loadServicesCmd(m.ui.discovery, wizard.selectedContext, wizard.selectedNamespace)
|
|
} else {
|
|
wizard.inputMode = InputModeText
|
|
wizard.loading = true
|
|
return m, loadPodsCmd(m.ui.discovery, wizard.selectedContext, wizard.selectedNamespace)
|
|
}
|
|
}
|
|
|
|
case StepEnterResource:
|
|
switch wizard.selectedResourceType {
|
|
case ResourceTypePodPrefix:
|
|
if wizard.textInput != "" {
|
|
wizard.resourceValue = wizard.textInput
|
|
wizard.step = StepEnterRemotePort
|
|
wizard.clearTextInput()
|
|
|
|
// Detect ports from matching pods
|
|
wizard.detectedPorts = k8s.GetUniquePorts(wizard.pods)
|
|
if len(wizard.detectedPorts) > 0 {
|
|
wizard.inputMode = InputModeList
|
|
wizard.cursor = 0
|
|
} else {
|
|
wizard.inputMode = InputModeText
|
|
}
|
|
}
|
|
|
|
case ResourceTypePodSelector:
|
|
if wizard.textInput != "" && len(wizard.matchingPods) > 0 {
|
|
wizard.resourceValue = "pod"
|
|
wizard.selector = wizard.textInput
|
|
wizard.step = StepEnterRemotePort
|
|
wizard.clearTextInput()
|
|
|
|
// Detect ports from matching pods
|
|
wizard.detectedPorts = k8s.GetUniquePorts(wizard.matchingPods)
|
|
if len(wizard.detectedPorts) > 0 {
|
|
wizard.inputMode = InputModeList
|
|
wizard.cursor = 0
|
|
} else {
|
|
wizard.inputMode = InputModeText
|
|
}
|
|
}
|
|
|
|
case ResourceTypeService:
|
|
filteredServices := wizard.getFilteredServices()
|
|
if wizard.cursor >= 0 && wizard.cursor < len(filteredServices) {
|
|
wizard.resourceValue = filteredServices[wizard.cursor].Name
|
|
|
|
// Get ports from selected service (must do this BEFORE clearing search filter)
|
|
wizard.detectedPorts = filteredServices[wizard.cursor].Ports
|
|
|
|
wizard.step = StepEnterRemotePort
|
|
wizard.clearTextInput()
|
|
wizard.clearSearchFilter()
|
|
|
|
if len(wizard.detectedPorts) > 0 {
|
|
wizard.inputMode = InputModeList
|
|
wizard.cursor = 0
|
|
} else {
|
|
wizard.inputMode = InputModeText
|
|
}
|
|
}
|
|
}
|
|
|
|
case StepEnterRemotePort:
|
|
if wizard.inputMode == InputModeList && len(wizard.detectedPorts) > 0 {
|
|
// List mode - user selected from detected ports
|
|
if wizard.cursor == len(wizard.detectedPorts) {
|
|
// Selected "Manual entry" option
|
|
wizard.inputMode = InputModeText
|
|
wizard.clearTextInput()
|
|
} else if wizard.cursor >= 0 && wizard.cursor < len(wizard.detectedPorts) {
|
|
// Selected a detected port
|
|
// For services, use TargetPort (actual pod port) if available
|
|
// For pods, TargetPort is 0, so use Port (container port)
|
|
selectedPort := wizard.detectedPorts[wizard.cursor]
|
|
if selectedPort.TargetPort > 0 {
|
|
wizard.remotePort = int(selectedPort.TargetPort)
|
|
} else {
|
|
wizard.remotePort = int(selectedPort.Port)
|
|
}
|
|
wizard.step = StepEnterLocalPort
|
|
wizard.clearTextInput()
|
|
wizard.inputMode = InputModeText
|
|
wizard.error = nil
|
|
}
|
|
} else {
|
|
// Text mode - manual entry
|
|
port, err := strconv.Atoi(wizard.textInput)
|
|
if err != nil || !config.IsValidPort(port) {
|
|
wizard.error = fmt.Errorf("invalid port number")
|
|
} else {
|
|
wizard.remotePort = port
|
|
wizard.step = StepEnterLocalPort
|
|
wizard.clearTextInput()
|
|
wizard.error = nil
|
|
}
|
|
}
|
|
|
|
case StepEnterLocalPort:
|
|
port, err := strconv.Atoi(wizard.textInput)
|
|
if err != nil || !config.IsValidPort(port) {
|
|
wizard.error = fmt.Errorf("invalid port number")
|
|
} else {
|
|
// Check port availability before proceeding
|
|
wizard.localPort = port
|
|
wizard.loading = true
|
|
wizard.error = nil
|
|
excludeID := ""
|
|
if wizard.isEditing {
|
|
excludeID = wizard.originalID
|
|
}
|
|
return m, checkPortCmd(port, m.ui.configPath, excludeID, wizard.selectedContext, m.ui.activeContexts)
|
|
}
|
|
|
|
case StepConfirmation:
|
|
// If focused on alias field, move to buttons
|
|
if wizard.confirmationFocus == FocusAlias {
|
|
wizard.confirmationFocus = FocusButtons
|
|
wizard.cursor = 0
|
|
return m, nil
|
|
}
|
|
|
|
// Handle button selection
|
|
if wizard.cursor == 0 {
|
|
// Check if port is available before saving
|
|
if !wizard.portAvailable {
|
|
wizard.error = fmt.Errorf("port %d is not available. Please choose a different port", wizard.localPort)
|
|
return m, nil
|
|
}
|
|
|
|
// Confirmed - save the forward
|
|
wizard.alias = wizard.textInput
|
|
|
|
// Build the forward config
|
|
fwd := config.Forward{
|
|
Protocol: "tcp",
|
|
Port: wizard.remotePort,
|
|
LocalPort: wizard.localPort,
|
|
Alias: wizard.alias,
|
|
}
|
|
|
|
switch wizard.selectedResourceType {
|
|
case ResourceTypePodPrefix:
|
|
fwd.Resource = "pod/" + wizard.resourceValue
|
|
case ResourceTypePodSelector:
|
|
fwd.Resource = wizard.resourceValue
|
|
fwd.Selector = wizard.selector
|
|
case ResourceTypeService:
|
|
fwd.Resource = "service/" + wizard.resourceValue
|
|
}
|
|
|
|
// HTTPLog: when toggled on, preserve any advanced fields the
|
|
// user had configured in YAML (logFile, includeHeaders, etc.)
|
|
// so the wizard does not silently strip them. When toggled
|
|
// off, leave HTTPLog nil (= absent in YAML = disabled).
|
|
if wizard.httpLog {
|
|
if wizard.httpLogOriginal != nil {
|
|
spec := *wizard.httpLogOriginal
|
|
spec.Enabled = true
|
|
fwd.HTTPLog = &spec
|
|
} else {
|
|
fwd.HTTPLog = &config.HTTPLogSpec{Enabled: true}
|
|
}
|
|
}
|
|
|
|
wizard.loading = true
|
|
|
|
// If editing, use atomic update operation
|
|
if wizard.isEditing {
|
|
return m, updateForwardCmd(m.ui.mutator, wizard.originalContext, wizard.originalID, wizard.selectedContext, wizard.selectedNamespace, fwd)
|
|
}
|
|
|
|
return m, saveForwardCmd(m.ui.mutator, wizard.selectedContext, wizard.selectedNamespace, fwd)
|
|
} else {
|
|
// Cancelled - return to main view with screen clear
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.addWizard = nil
|
|
return m, tea.ClearScreen
|
|
}
|
|
|
|
case StepSuccess:
|
|
if wizard.cursor == 0 {
|
|
// Add another
|
|
m.ui.addWizard = newAddWizardState()
|
|
m.ui.addWizard.loading = true
|
|
return m, loadContextsCmd(m.ui.discovery)
|
|
} else {
|
|
// Return to main view with screen clear
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.addWizard = nil
|
|
return m, tea.ClearScreen
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// handleRemoveWizardKeys handles keyboard input in the remove wizard
|
|
func (m model) handleRemoveWizardKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
wizard := m.ui.removeWizard
|
|
if wizard == nil {
|
|
return m, nil
|
|
}
|
|
|
|
switch msg.String() {
|
|
case "ctrl+c":
|
|
// Hard cancel - always exit
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.removeWizard = nil
|
|
return m, tea.ClearScreen
|
|
|
|
case "esc":
|
|
if wizard.confirming {
|
|
// In confirmation mode, Esc cancels the confirmation (matches help text "Esc: Cancel")
|
|
// Returns to selection state without dispatching removal.
|
|
wizard.confirming = false
|
|
wizard.confirmCursor = 0
|
|
return m, nil
|
|
}
|
|
// Not confirming yet - cancel entirely
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.removeWizard = nil
|
|
return m, tea.ClearScreen
|
|
|
|
case "up", "k":
|
|
wizard.moveCursor(-1)
|
|
|
|
case "down", "j":
|
|
wizard.moveCursor(1)
|
|
|
|
case "pgup", "ctrl+u":
|
|
wizard.moveCursor(-10)
|
|
|
|
case "pgdown", "ctrl+d":
|
|
wizard.moveCursor(10)
|
|
|
|
case " ":
|
|
if !wizard.confirming {
|
|
wizard.toggleSelection()
|
|
}
|
|
|
|
case "a":
|
|
wizard.selectAll()
|
|
|
|
case "n":
|
|
wizard.selectNone()
|
|
|
|
case "enter":
|
|
if !wizard.confirming {
|
|
if wizard.getSelectedCount() == 0 {
|
|
// Nothing selected
|
|
return m, nil
|
|
}
|
|
// Show confirmation
|
|
wizard.confirming = true
|
|
wizard.confirmCursor = 0
|
|
} else {
|
|
// Confirmed
|
|
if wizard.confirmCursor == 0 {
|
|
// Yes, remove
|
|
selectedForwards := wizard.getSelectedForwards()
|
|
return m, removeForwardsCmd(m.ui.mutator, selectedForwards)
|
|
} else {
|
|
// No, cancel
|
|
wizard.confirming = false
|
|
}
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// Message handlers
|
|
|
|
func (m model) handleContextsLoaded(msg ContextsLoadedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.addWizard != nil {
|
|
m.ui.addWizard.loading = false
|
|
m.ui.addWizard.error = msg.err
|
|
if msg.err == nil {
|
|
// Get current context and move it to the top (if discovery is available)
|
|
if m.ui.discovery != nil {
|
|
currentCtx, err := m.ui.discovery.GetCurrentContext()
|
|
if err == nil && currentCtx != "" {
|
|
// Reorder contexts with current first
|
|
reordered := []string{currentCtx}
|
|
for _, ctx := range msg.contexts {
|
|
if ctx != currentCtx {
|
|
reordered = append(reordered, ctx)
|
|
}
|
|
}
|
|
m.ui.addWizard.contexts = reordered
|
|
} else {
|
|
m.ui.addWizard.contexts = msg.contexts
|
|
}
|
|
} else {
|
|
m.ui.addWizard.contexts = msg.contexts
|
|
}
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m model) handleNamespacesLoaded(msg NamespacesLoadedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.addWizard != nil {
|
|
w := m.ui.addWizard
|
|
w.loading = false
|
|
w.error = nil
|
|
if msg.err == nil {
|
|
w.namespaces = msg.namespaces
|
|
}
|
|
// Without permission to list namespaces the user types the name instead.
|
|
if (msg.err != nil || len(msg.namespaces) == 0) && w.step == StepSelectNamespace {
|
|
w.namespaceManual = true
|
|
w.namespaceListErr = msg.err
|
|
w.inputMode = InputModeText
|
|
w.textInput = ""
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m model) handlePodsLoaded(msg PodsLoadedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.addWizard != nil {
|
|
m.ui.addWizard.loading = false
|
|
m.ui.addWizard.error = msg.err
|
|
if msg.err == nil {
|
|
m.ui.addWizard.pods = msg.pods
|
|
|
|
// If we're at the remote port step (edit mode), detect ports now
|
|
if m.ui.addWizard.step == StepEnterRemotePort {
|
|
m.ui.addWizard.detectedPorts = k8s.GetUniquePorts(msg.pods)
|
|
if len(m.ui.addWizard.detectedPorts) > 0 {
|
|
m.ui.addWizard.inputMode = InputModeList
|
|
m.ui.addWizard.cursor = 0
|
|
} else {
|
|
m.ui.addWizard.inputMode = InputModeText
|
|
m.ui.addWizard.textInput = fmt.Sprintf("%d", m.ui.addWizard.remotePort)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m model) handleServicesLoaded(msg ServicesLoadedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.addWizard != nil {
|
|
m.ui.addWizard.loading = false
|
|
m.ui.addWizard.error = msg.err
|
|
if msg.err == nil {
|
|
m.ui.addWizard.services = msg.services
|
|
|
|
// If we're at the remote port step (edit mode), detect ports now
|
|
if m.ui.addWizard.step == StepEnterRemotePort {
|
|
// Find the service by name
|
|
for _, svc := range msg.services {
|
|
if svc.Name == m.ui.addWizard.resourceValue {
|
|
m.ui.addWizard.detectedPorts = svc.Ports
|
|
if len(m.ui.addWizard.detectedPorts) > 0 {
|
|
m.ui.addWizard.inputMode = InputModeList
|
|
m.ui.addWizard.cursor = 0
|
|
} else {
|
|
m.ui.addWizard.inputMode = InputModeText
|
|
m.ui.addWizard.textInput = fmt.Sprintf("%d", m.ui.addWizard.remotePort)
|
|
}
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m model) handleSelectorValidated(msg SelectorValidatedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.addWizard != nil {
|
|
m.ui.addWizard.loading = false
|
|
m.ui.addWizard.error = msg.err
|
|
if msg.valid {
|
|
m.ui.addWizard.matchingPods = msg.pods
|
|
} else {
|
|
m.ui.addWizard.matchingPods = nil
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m model) handlePortChecked(msg PortCheckedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.addWizard != nil {
|
|
m.ui.addWizard.loading = false
|
|
m.ui.addWizard.portAvailable = msg.available
|
|
m.ui.addWizard.portCheckMsg = msg.message
|
|
|
|
// Only proceed to confirmation if port is available
|
|
if msg.available {
|
|
m.ui.addWizard.step = StepConfirmation
|
|
m.ui.addWizard.clearTextInput()
|
|
m.ui.addWizard.cursor = 0
|
|
m.ui.addWizard.inputMode = InputModeList
|
|
} else {
|
|
// Port is not available - show error and stay on local port step
|
|
m.ui.addWizard.error = fmt.Errorf("port %d is in use, please choose another port", msg.port)
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m model) handleForwardSaved(msg ForwardSavedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.addWizard != nil {
|
|
m.ui.addWizard.loading = false
|
|
if msg.success {
|
|
// Move to success step
|
|
m.ui.addWizard.step = StepSuccess
|
|
m.ui.addWizard.cursor = 0
|
|
m.ui.addWizard.inputMode = InputModeList
|
|
} else {
|
|
m.ui.addWizard.error = msg.err
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
func (m model) handleForwardsRemoved(msg ForwardsRemovedMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
// Delete now happens directly without wizard
|
|
// Just ensure we're back in main view
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.removeWizard = nil
|
|
|
|
// If there was an error, it will be logged but we don't show it in UI for now
|
|
// The config watcher will either reload (success) or keep old config (failure)
|
|
|
|
return m, tea.ClearScreen
|
|
}
|
|
|
|
// handleBenchmarkKeys handles keyboard input in the benchmark view
|
|
func (m model) handleBenchmarkKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
state := m.ui.benchmarkState
|
|
if state == nil {
|
|
return m, nil
|
|
}
|
|
|
|
switch msg.String() {
|
|
case "ctrl+c", "esc":
|
|
// Cancel the running benchmark if active
|
|
if state.cancelFunc != nil {
|
|
state.cancelFunc()
|
|
}
|
|
// Return to main view
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.benchmarkState = nil
|
|
return m, tea.ClearScreen
|
|
|
|
case "up", "k":
|
|
if state.step == BenchmarkStepConfig && state.cursor > 0 {
|
|
state.cursor--
|
|
// Load current field value into textInput
|
|
state.textInput = m.getBenchmarkFieldValue(state.cursor)
|
|
}
|
|
|
|
case "down", "j":
|
|
if state.step == BenchmarkStepConfig && state.cursor < 3 {
|
|
state.cursor++
|
|
// Load current field value into textInput
|
|
state.textInput = m.getBenchmarkFieldValue(state.cursor)
|
|
}
|
|
|
|
case "tab":
|
|
// Tab also cycles through fields
|
|
if state.step == BenchmarkStepConfig {
|
|
state.cursor = (state.cursor + 1) % 4
|
|
state.textInput = m.getBenchmarkFieldValue(state.cursor)
|
|
}
|
|
|
|
case "enter":
|
|
switch state.step {
|
|
case BenchmarkStepConfig:
|
|
// Start running the benchmark
|
|
state.step = BenchmarkStepRunning
|
|
state.running = true
|
|
state.progress = 0
|
|
state.total = state.requests
|
|
// Create progress channel with buffer for non-blocking sends
|
|
state.progressCh = make(chan BenchmarkProgressMsg, 10)
|
|
// Create cancellable context for the benchmark
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
state.cancelFunc = cancel
|
|
// Return batch command to run benchmark and listen for progress
|
|
return m, tea.Batch(
|
|
runBenchmarkCmd(ctx, state.forwardID, state.localPort, state.urlPath, state.method, state.concurrency, state.requests, state.progressCh),
|
|
listenBenchmarkProgressCmd(state.progressCh),
|
|
)
|
|
case BenchmarkStepResults:
|
|
// Return to main view
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.benchmarkState = nil
|
|
return m, tea.ClearScreen
|
|
}
|
|
|
|
case "backspace":
|
|
if state.step == BenchmarkStepConfig {
|
|
if len(state.textInput) > 0 {
|
|
state.textInput = state.textInput[:len(state.textInput)-1]
|
|
m.applyBenchmarkTextInput()
|
|
}
|
|
}
|
|
|
|
default:
|
|
// Handle text input in config step
|
|
if state.step == BenchmarkStepConfig && len(msg.String()) == 1 {
|
|
char := rune(msg.String()[0])
|
|
if char >= 32 && char < 127 {
|
|
state.textInput += string(char)
|
|
m.applyBenchmarkTextInput()
|
|
}
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// getBenchmarkFieldValue returns the current value of the selected benchmark field
|
|
func (m model) getBenchmarkFieldValue(cursor int) string {
|
|
state := m.ui.benchmarkState
|
|
if state == nil {
|
|
return ""
|
|
}
|
|
|
|
switch cursor {
|
|
case 0:
|
|
return state.urlPath
|
|
case 1:
|
|
return state.method
|
|
case 2:
|
|
return fmt.Sprintf("%d", state.concurrency)
|
|
case 3:
|
|
return fmt.Sprintf("%d", state.requests)
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
// applyBenchmarkTextInput applies the current text input to the selected field
|
|
func (m model) applyBenchmarkTextInput() {
|
|
state := m.ui.benchmarkState
|
|
if state == nil {
|
|
return
|
|
}
|
|
|
|
switch state.cursor {
|
|
case 0: // URL path
|
|
state.urlPath = state.textInput
|
|
case 1: // Method
|
|
state.method = strings.ToUpper(state.textInput)
|
|
case 2: // Concurrency
|
|
if val, err := strconv.Atoi(state.textInput); err == nil && val > 0 {
|
|
state.concurrency = val
|
|
// Cap concurrency at requests
|
|
if state.concurrency > state.requests {
|
|
state.concurrency = state.requests
|
|
}
|
|
}
|
|
case 3: // Requests
|
|
if val, err := strconv.Atoi(state.textInput); err == nil && val > 0 {
|
|
state.requests = val
|
|
// Cap concurrency at requests
|
|
if state.concurrency > state.requests {
|
|
state.concurrency = state.requests
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// handleHTTPLogKeys handles keyboard input in the HTTP log view
|
|
func (m model) handleHTTPLogKeys(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
state := m.ui.httpLogState
|
|
if state == nil {
|
|
return m, nil
|
|
}
|
|
|
|
// If filter input is active, handle text input
|
|
if state.filterActive {
|
|
switch msg.String() {
|
|
case "esc":
|
|
// Cancel filter input, clear text
|
|
state.filterActive = false
|
|
state.filterText = ""
|
|
state.cursor = 0
|
|
state.scrollOffset = 0
|
|
return m, nil
|
|
case "enter":
|
|
// Confirm filter
|
|
state.filterActive = false
|
|
state.cursor = 0
|
|
state.scrollOffset = 0
|
|
return m, nil
|
|
case "backspace":
|
|
if len(state.filterText) > 0 {
|
|
state.filterText = state.filterText[:len(state.filterText)-1]
|
|
}
|
|
return m, nil
|
|
default:
|
|
// Add character to filter
|
|
if len(msg.String()) == 1 {
|
|
char := rune(msg.String()[0])
|
|
if char >= 32 && char < 127 {
|
|
state.filterText += string(char)
|
|
state.cursor = 0
|
|
state.scrollOffset = 0
|
|
}
|
|
}
|
|
return m, nil
|
|
}
|
|
}
|
|
|
|
filteredEntries := state.getFilteredEntries()
|
|
|
|
// If viewing detail, handle detail view keys
|
|
if state.showingDetail {
|
|
switch msg.String() {
|
|
case "esc", "q", "enter":
|
|
// Return to list view
|
|
state.showingDetail = false
|
|
state.detailScroll = 0
|
|
state.copyMessage = ""
|
|
return m, nil
|
|
case "up", "k":
|
|
if state.detailScroll > 0 {
|
|
state.detailScroll--
|
|
}
|
|
return m, nil
|
|
case "down", "j":
|
|
state.detailScroll++
|
|
return m, nil
|
|
case "pgup", "ctrl+u":
|
|
state.detailScroll -= 20
|
|
if state.detailScroll < 0 {
|
|
state.detailScroll = 0
|
|
}
|
|
return m, nil
|
|
case "pgdown", "ctrl+d":
|
|
state.detailScroll += 20
|
|
return m, nil
|
|
case "g":
|
|
state.detailScroll = 0
|
|
return m, nil
|
|
case "c":
|
|
// Copy response body to clipboard
|
|
if state.cursor >= 0 && state.cursor < len(filteredEntries) {
|
|
entry := filteredEntries[state.cursor]
|
|
if entry.ResponseBody != "" {
|
|
// Decompress if needed before copying
|
|
body := decompressContent(entry.ResponseBody, entry.ResponseHeaders)
|
|
if err := copyToClipboard(body); err == nil {
|
|
state.copyMessage = "Copied!"
|
|
} else {
|
|
state.copyMessage = "Clipboard unavailable"
|
|
}
|
|
// Clear the message after 2 seconds
|
|
return m, tea.Tick(2*time.Second, func(t time.Time) tea.Msg {
|
|
return clearCopyMessageMsg{}
|
|
})
|
|
}
|
|
}
|
|
return m, nil
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
switch msg.String() {
|
|
case "ctrl+c", "esc", "q":
|
|
// Cleanup subscription before closing
|
|
if m.ui.httpLogCleanup != nil {
|
|
m.ui.httpLogCleanup()
|
|
m.ui.httpLogCleanup = nil
|
|
}
|
|
// Return to main view
|
|
m.ui.viewMode = ViewModeMain
|
|
m.ui.httpLogState = nil
|
|
return m, tea.ClearScreen
|
|
|
|
case "enter":
|
|
// Show detail view for selected entry
|
|
if len(filteredEntries) > 0 && state.cursor >= 0 && state.cursor < len(filteredEntries) {
|
|
state.showingDetail = true
|
|
state.detailScroll = 0
|
|
}
|
|
return m, nil
|
|
|
|
case "up", "k":
|
|
if state.cursor > 0 {
|
|
state.cursor--
|
|
state.autoScroll = false
|
|
}
|
|
|
|
case "down", "j":
|
|
if state.cursor < len(filteredEntries)-1 {
|
|
state.cursor++
|
|
}
|
|
// If at bottom, enable auto-scroll
|
|
if state.cursor >= len(filteredEntries)-1 {
|
|
state.autoScroll = true
|
|
}
|
|
|
|
case "pgup", "ctrl+u":
|
|
// Page up - move 20 entries
|
|
state.cursor -= 20
|
|
if state.cursor < 0 {
|
|
state.cursor = 0
|
|
}
|
|
state.autoScroll = false
|
|
|
|
case "pgdown", "ctrl+d":
|
|
// Page down - move 20 entries
|
|
state.cursor += 20
|
|
if state.cursor >= len(filteredEntries) {
|
|
state.cursor = len(filteredEntries) - 1
|
|
}
|
|
if state.cursor < 0 {
|
|
state.cursor = 0
|
|
}
|
|
// If at bottom, enable auto-scroll
|
|
if state.cursor >= len(filteredEntries)-1 {
|
|
state.autoScroll = true
|
|
}
|
|
|
|
case "g":
|
|
// Go to top
|
|
state.cursor = 0
|
|
state.scrollOffset = 0
|
|
state.autoScroll = false
|
|
|
|
case "G":
|
|
// Go to bottom
|
|
if len(filteredEntries) > 0 {
|
|
state.cursor = len(filteredEntries) - 1
|
|
state.autoScroll = true
|
|
}
|
|
|
|
case "a":
|
|
// Toggle auto-scroll
|
|
state.autoScroll = !state.autoScroll
|
|
|
|
case "f":
|
|
// Cycle filter mode (skip Text mode when cycling - use '/' for text filter)
|
|
state.filterMode = (state.filterMode + 1) % 4
|
|
if state.filterMode == HTTPLogFilterText {
|
|
// Skip Text mode when using 'f' - it's only accessible via '/'
|
|
state.filterMode = HTTPLogFilterNon200
|
|
}
|
|
state.cursor = 0
|
|
state.scrollOffset = 0
|
|
|
|
case "/":
|
|
// Enter text filter mode
|
|
state.filterActive = true
|
|
state.filterText = ""
|
|
|
|
case "c":
|
|
// Clear all filters
|
|
state.filterMode = HTTPLogFilterNone
|
|
state.filterText = ""
|
|
state.cursor = 0
|
|
state.scrollOffset = 0
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// handleHTTPLogEntry handles incoming HTTP log entries
|
|
func (m model) handleHTTPLogEntry(msg HTTPLogEntryMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.httpLogState == nil {
|
|
return m, nil
|
|
}
|
|
|
|
state := m.ui.httpLogState
|
|
entry := msg.Entry
|
|
|
|
// If this is a response, try to find and merge with the matching request
|
|
if entry.Direction == "response" && entry.RequestID != "" {
|
|
// Search backwards (responses follow requests closely)
|
|
for i := len(state.entries) - 1; i >= 0 && i >= len(state.entries)-100; i-- {
|
|
if state.entries[i].RequestID == entry.RequestID && state.entries[i].Direction == "request" {
|
|
// Merge response data into the existing request entry
|
|
state.entries[i].Direction = "response"
|
|
state.entries[i].StatusCode = entry.StatusCode
|
|
state.entries[i].LatencyMs = entry.LatencyMs
|
|
state.entries[i].BodySize = entry.BodySize
|
|
state.entries[i].ResponseHeaders = entry.ResponseHeaders
|
|
state.entries[i].ResponseBody = entry.ResponseBody
|
|
state.entries[i].Error = entry.Error
|
|
return m, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
// For requests or unmatched responses, append as new entry
|
|
state.entries = append(state.entries, entry)
|
|
|
|
// Cap entries to prevent memory growth (keep last 10000 entries)
|
|
const maxEntries = 10000
|
|
if len(state.entries) > maxEntries {
|
|
// Remove oldest entries
|
|
state.entries = state.entries[len(state.entries)-maxEntries:]
|
|
// Adjust cursor if needed
|
|
if state.cursor >= len(state.entries) {
|
|
state.cursor = len(state.entries) - 1
|
|
}
|
|
}
|
|
|
|
// Auto-scroll to bottom if enabled
|
|
if state.autoScroll && len(state.entries) > 0 {
|
|
filteredEntries := state.getFilteredEntries()
|
|
state.cursor = len(filteredEntries) - 1
|
|
if state.cursor < 0 {
|
|
state.cursor = 0
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// handleBenchmarkProgress handles progress updates during benchmark execution
|
|
func (m model) handleBenchmarkProgress(msg BenchmarkProgressMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.benchmarkState == nil || !m.ui.benchmarkState.running {
|
|
return m, nil
|
|
}
|
|
|
|
state := m.ui.benchmarkState
|
|
state.progress = msg.Completed
|
|
state.total = msg.Total
|
|
|
|
// Continue listening for more progress updates
|
|
if state.progressCh != nil {
|
|
return m, listenBenchmarkProgressCmd(state.progressCh)
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// handleBenchmarkComplete handles the benchmark completion message
|
|
func (m model) handleBenchmarkComplete(msg BenchmarkCompleteMsg) (tea.Model, tea.Cmd) {
|
|
m.ui.mu.Lock()
|
|
defer m.ui.mu.Unlock()
|
|
|
|
if m.ui.benchmarkState == nil {
|
|
return m, nil
|
|
}
|
|
|
|
state := m.ui.benchmarkState
|
|
state.running = false
|
|
state.step = BenchmarkStepResults
|
|
state.progressCh = nil // Clear progress channel since benchmark is complete
|
|
|
|
if msg.Error != nil {
|
|
state.error = msg.Error
|
|
state.results = nil
|
|
} else if msg.Results != nil {
|
|
stats := msg.Results.CalculateStats()
|
|
state.results = &BenchmarkResults{
|
|
TotalRequests: msg.Results.TotalRequests,
|
|
Successful: msg.Results.Successful,
|
|
Failed: msg.Results.Failed,
|
|
MinLatency: float64(stats.MinLatency.Milliseconds()),
|
|
MaxLatency: float64(stats.MaxLatency.Milliseconds()),
|
|
AvgLatency: float64(stats.AvgLatency.Milliseconds()),
|
|
P50Latency: float64(stats.P50Latency.Milliseconds()),
|
|
P95Latency: float64(stats.P95Latency.Milliseconds()),
|
|
P99Latency: float64(stats.P99Latency.Milliseconds()),
|
|
Throughput: stats.Throughput,
|
|
BytesRead: msg.Results.BytesRead,
|
|
StatusCodes: msg.Results.StatusCodes,
|
|
}
|
|
}
|
|
|
|
return m, nil
|
|
}
|
|
|
|
// copyToClipboard copies text to the system clipboard using OS-specific commands.
|
|
// This avoids CGO dependencies that cause issues in CI environments.
|
|
func copyToClipboard(text string) error {
|
|
var cmd *exec.Cmd
|
|
|
|
switch runtime.GOOS {
|
|
case "darwin":
|
|
cmd = exec.Command("pbcopy")
|
|
case "linux":
|
|
// Try xclip first, fall back to xsel
|
|
if _, err := exec.LookPath("xclip"); err == nil {
|
|
cmd = exec.Command("xclip", "-selection", "clipboard")
|
|
} else if _, err := exec.LookPath("xsel"); err == nil {
|
|
cmd = exec.Command("xsel", "--clipboard", "--input")
|
|
} else {
|
|
return fmt.Errorf("no clipboard tool found (install xclip or xsel)")
|
|
}
|
|
case "windows":
|
|
cmd = exec.Command("clip")
|
|
default:
|
|
return fmt.Errorf("unsupported platform: %s", runtime.GOOS)
|
|
}
|
|
|
|
stdin, err := cmd.StdinPipe()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if _, err := stdin.Write([]byte(text)); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := stdin.Close(); err != nil {
|
|
return err
|
|
}
|
|
|
|
return cmd.Wait()
|
|
}
|