TUI Browse Modal & Tests (#358)

* Prevent log spam in ServiceFWD by tracking "no pods" warnings

- Added `noPodsLogged` flag to avoid repeatedly logging "no pods" warnings for a service.
- Reset flag when pods become available, allowing future warnings if pods disappear again.

* Add a TUI browse modal for discovering and forwarding namespaces and services

* Improve namespace manager integration for clientSet retrieval in TUI pod logs streamer

* Ensure `clientSet` is correctly initialized to prevent nil interface issues in TUI pod logs streamer

* Add hint style and update header with browse hint, enable "left" key for navigation in browse modal

* Add extensive unit tests for RootModel and event handling logic

- Added tests for various RootModel functionalities, including focus cycling, resizing, and key/mouse interactions.
- Implemented event handler tests for pod lifecycle events, service removals, and metrics updates.
- Added TUI component tests for header, services, and detail models.

* Add unit tests for BrowseModel navigation, visibility, loading states, and error handling

- Introduced comprehensive tests for BrowseModel initialization, navigation across contexts, namespaces, and services, and visibility toggling.
- Verified loading state behavior and ensured error state handling clears on user interaction.
- Improved test coverage for edge scenarios like zero visible items and invalid user inputs.

* Pin `codeql-action/upload-sarif` version in Scorecard workflow for dependency stability

Author: cjimti

.github/workflows/scorecard.yml

@@ -73,6 +73,6 @@ jobs:
       # Upload the results to GitHub's code scanning dashboard (optional).
       # Commenting out will disable upload of results to your repo's Code Scanning dashboard
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@v3
+        uses: github/codeql-action/upload-sarif@45c373516f557556c15d420e3f5e0aa3d64366bc # v3
         with:
           sarif_file: results.sarif

cmd/kubefwd/services/services.go

@@ -336,17 +336,36 @@ Try:
 	clientSets := make(map[string]*kubernetes.Clientset)
 	var clientSetsMu sync.RWMutex
 
+	// Declare nsManager here so it can be captured by closures below
+	// It will be assigned later after config validation
+	var nsManager *fwdns.NamespaceManager
+
 	if fwdtui.IsEnabled() {
 		tuiManager = fwdtui.Init(stopListenCh, triggerShutdown)
 
 		// Set up pod logs streamer
 		tuiManager.SetPodLogsStreamer(func(ctx context.Context, namespace, podName, containerName, k8sContext string, tailLines int64) (io.ReadCloser, error) {
+			// First try the local clientSets map (populated during namespace watcher startup)
 			clientSetsMu.RLock()
-			clientSet, ok := clientSets[k8sContext]
+			cs, ok := clientSets[k8sContext]
 			clientSetsMu.RUnlock()
 
-			if !ok {
-				return nil, fmt.Errorf("no clientset for context: %s", k8sContext)
+			// Use kubernetes.Interface to support both *Clientset and Interface types
+			// Note: Must check ok && cs != nil because assigning nil pointer to interface
+			// creates non-nil interface with nil concrete value (Go nil interface gotcha)
+			var clientSet kubernetes.Interface
+			if ok && cs != nil {
+				clientSet = cs
+			}
+
+			if clientSet == nil {
+				// Fall back to NamespaceManager's cache for individually-added services
+				if nsManager != nil {
+					clientSet = nsManager.GetClientSet(k8sContext)
+				}
+				if clientSet == nil {
+					return nil, fmt.Errorf("no clientset for context: %s", k8sContext)
+				}
 			}
 
 			opts := &v1.PodLogOptions{
@@ -470,7 +489,7 @@ Try:
 	}
 
 	// Create the namespace manager for dynamic watcher management
-	nsManager := fwdns.NewManager(fwdns.ManagerConfig{
+	nsManager = fwdns.NewManager(fwdns.ManagerConfig{
 		HostFile:        hostFileWithLock,
 		ConfigPath:      cfgFilePath,
 		Domain:          domain,
@@ -486,26 +505,36 @@ Try:
 		GlobalStopCh:    stopListenCh,
 	})
 
+	// Set up adapters for Kubernetes discovery and service CRUD
+	// These are used by both API and TUI for browse/forward operations
+	getNsManager := func() *fwdns.NamespaceManager { return nsManager }
+	k8sDiscovery := fwdapi.NewKubernetesDiscoveryAdapter(getNsManager, cfgFilePath)
+	serviceCRUD := fwdapi.NewServiceCRUDAdapter(fwdtui.GetStore, getNsManager, cfgFilePath)
+	nsController := fwdapi.NewNamespaceManagerAdapter(getNsManager)
+
 	// Register namespace manager with API if enabled
 	if apiManager != nil {
 		apiManager.SetNamespaceManager(nsManager)
-
-		// Set up Kubernetes discovery adapter
-		k8sDiscovery := fwdapi.NewKubernetesDiscoveryAdapter(
-			apiManager.GetNamespaceManager,
-			cfgFilePath,
-		)
 		apiManager.SetKubernetesDiscovery(k8sDiscovery)
-
-		// Set up ServiceCRUD adapter for add/remove operations
-		serviceCRUD := fwdapi.NewServiceCRUDAdapter(
-			fwdtui.GetStore,
-			apiManager.GetNamespaceManager,
-			cfgFilePath,
-		)
 		apiManager.SetServiceCRUD(serviceCRUD)
 	}
 
+	// Wire up TUI browse modal adapters
+	if tuiManager != nil {
+		tuiManager.SetBrowseDiscovery(k8sDiscovery)
+		tuiManager.SetBrowseServiceCRUD(serviceCRUD)
+		tuiManager.SetBrowseNamespaceController(nsController)
+		tuiManager.SetRemoveForwardCallback(func(key string) error {
+			fwdsvcregistry.RemoveByName(key)
+			return nil
+		})
+
+		// Set initial context in header
+		if len(contexts) > 0 {
+			tuiManager.SetHeaderContext(contexts[0])
+		}
+	}
+
 	// Start watchers for each context/namespace combination (skip in idle mode)
 	if !idleMode {
 		for _, ctx := range contexts {

pkg/fwdapi/adapters.go

@@ -633,8 +633,10 @@ func (a *KubernetesDiscoveryAdapter) ListNamespaces(ctx string) ([]types.K8sName
 		}
 	}
 
-	// List namespaces from the cluster
-	nsList, err := clientSet.CoreV1().Namespaces().List(context.Background(), metav1.ListOptions{})
+	// List namespaces from the cluster with timeout
+	ctx2, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	nsList, err := clientSet.CoreV1().Namespaces().List(ctx2, metav1.ListOptions{})
 	if err != nil {
 		return nil, fmt.Errorf("failed to list namespaces: %w", err)
 	}
@@ -688,8 +690,10 @@ func (a *KubernetesDiscoveryAdapter) ListServices(ctx, namespace string) ([]type
 		}
 	}
 
-	// List services from the cluster
-	svcList, err := clientSet.CoreV1().Services(namespace).List(context.Background(), metav1.ListOptions{})
+	// List services from the cluster with timeout
+	ctx2, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	svcList, err := clientSet.CoreV1().Services(namespace).List(ctx2, metav1.ListOptions{})
 	if err != nil {
 		return nil, fmt.Errorf("failed to list services: %w", err)
 	}
@@ -750,7 +754,9 @@ func (a *KubernetesDiscoveryAdapter) GetService(ctx, namespace, name string) (*t
 		}
 	}
 
-	svc, err := clientSet.CoreV1().Services(namespace).Get(context.Background(), name, metav1.GetOptions{})
+	ctx2, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	svc, err := clientSet.CoreV1().Services(namespace).Get(ctx2, name, metav1.GetOptions{})
 	if err != nil {
 		return nil, fmt.Errorf("service not found: %w", err)
 	}

pkg/fwdapi/manager.go

@@ -181,6 +181,18 @@ type namespaceManagerAdapter struct {
 	mgr *fwdns.NamespaceManager
 }
 
+// NewNamespaceManagerAdapter creates a NamespaceController adapter from a NamespaceManager getter.
+// This allows the TUI and API to interact with the namespace manager through the NamespaceController interface.
+func NewNamespaceManagerAdapter(getMgr func() *fwdns.NamespaceManager) types.NamespaceController {
+	return &lazyNamespaceManagerAdapter{getMgr: getMgr}
+}
+
+// lazyNamespaceManagerAdapter is a lazy-loading adapter that fetches the manager on each call.
+// This is useful when the manager may not be available at adapter creation time.
+type lazyNamespaceManagerAdapter struct {
+	getMgr func() *fwdns.NamespaceManager
+}
+
 func (a *namespaceManagerAdapter) AddNamespace(ctx, namespace string, opts types.AddNamespaceOpts) (*types.NamespaceInfoResponse, error) {
 	info, err := a.mgr.StartWatcher(ctx, namespace, fwdns.WatcherOpts{
 		LabelSelector: opts.LabelSelector,
@@ -241,6 +253,84 @@ func (a *namespaceManagerAdapter) GetNamespace(ctx, namespace string) (*types.Na
 	}, nil
 }
 
+// lazyNamespaceManagerAdapter methods - these delegate to the manager obtained from getMgr()
+
+func (a *lazyNamespaceManagerAdapter) AddNamespace(ctx, namespace string, opts types.AddNamespaceOpts) (*types.NamespaceInfoResponse, error) {
+	mgr := a.getMgr()
+	if mgr == nil {
+		return nil, fmt.Errorf("namespace manager not available")
+	}
+	info, err := mgr.StartWatcher(ctx, namespace, fwdns.WatcherOpts{
+		LabelSelector: opts.LabelSelector,
+		FieldSelector: opts.FieldSelector,
+	})
+	if err != nil {
+		return nil, err
+	}
+	return &types.NamespaceInfoResponse{
+		Key:          info.Key,
+		Namespace:    info.Namespace,
+		Context:      info.Context,
+		ServiceCount: info.ServiceCount,
+		ActiveCount:  info.ActiveCount,
+		ErrorCount:   info.ErrorCount,
+	}, nil
+}
+
+func (a *lazyNamespaceManagerAdapter) RemoveNamespace(ctx, namespace string) error {
+	mgr := a.getMgr()
+	if mgr == nil {
+		return fmt.Errorf("namespace manager not available")
+	}
+	return mgr.StopWatcher(ctx, namespace)
+}
+
+func (a *lazyNamespaceManagerAdapter) ListNamespaces() []types.NamespaceInfoResponse {
+	mgr := a.getMgr()
+	if mgr == nil {
+		return nil
+	}
+	watchers := mgr.ListWatchers()
+	result := make([]types.NamespaceInfoResponse, len(watchers))
+	for i, w := range watchers {
+		result[i] = types.NamespaceInfoResponse{
+			Key:           w.Key,
+			Namespace:     w.Namespace,
+			Context:       w.Context,
+			ServiceCount:  w.ServiceCount,
+			ActiveCount:   w.ActiveCount,
+			ErrorCount:    w.ErrorCount,
+			Running:       w.Running,
+			LabelSelector: w.LabelSelector,
+			FieldSelector: w.FieldSelector,
+		}
+	}
+	return result
+}
+
+func (a *lazyNamespaceManagerAdapter) GetNamespace(ctx, namespace string) (*types.NamespaceInfoResponse, error) {
+	mgr := a.getMgr()
+	if mgr == nil {
+		return nil, fmt.Errorf("namespace manager not available")
+	}
+	w := mgr.GetWatcher(ctx, namespace)
+	if w == nil {
+		return nil, fmt.Errorf("namespace %s.%s not found", namespace, ctx)
+	}
+	info := w.Info()
+	return &types.NamespaceInfoResponse{
+		Key:           info.Key,
+		Namespace:     info.Namespace,
+		Context:       info.Context,
+		ServiceCount:  info.ServiceCount,
+		ActiveCount:   info.ActiveCount,
+		ErrorCount:    info.ErrorCount,
+		Running:       info.Running,
+		LabelSelector: info.LabelSelector,
+		FieldSelector: info.FieldSelector,
+	}, nil
+}
+
 // SetNamespaces sets the namespaces being forwarded (for info endpoint)
 func (m *Manager) SetNamespaces(namespaces []string) {
 	m.namespaces = namespaces

pkg/fwdservice/fwdservice.go

@@ -102,6 +102,10 @@ type ServiceFWD struct {
 
 	// reconnecting prevents multiple simultaneous reconnect attempts
 	reconnecting bool
+
+	// noPodsLogged tracks if we've already logged "no pods" warning for this service
+	// to avoid spamming logs with repeated warnings
+	noPodsLogged bool
 }
 
 type PortMap struct {
@@ -320,13 +324,22 @@ func (svcFwd *ServiceFWD) GetPodsForService() []v1.Pod {
 // that are no longer returned by k8s, should these not be correctly deleted.
 func (svcFwd *ServiceFWD) SyncPodForwards(force bool) {
 	doSync := func() {
-		log.Infof("SyncPodForwards starting for service %s (force=%v, currentForwards=%d)", svcFwd, force, len(svcFwd.PortForwards))
+		// Only log sync details if we haven't already logged "no pods" (avoid log spam)
+		if !svcFwd.noPodsLogged {
+			log.Infof("SyncPodForwards starting for service %s (force=%v, currentForwards=%d)", svcFwd, force, len(svcFwd.PortForwards))
+		}
 		k8sPods := svcFwd.GetPodsForService()
-		log.Infof("SyncPodForwards: Found %d eligible pods for service %s", len(k8sPods), svcFwd)
+		if !svcFwd.noPodsLogged || len(k8sPods) > 0 {
+			log.Infof("SyncPodForwards: Found %d eligible pods for service %s", len(k8sPods), svcFwd)
+		}
 
 		// If no pods are found currently, schedule a retry if configured.
 		if len(k8sPods) == 0 {
-			log.Warnf("WARNING: No Running Pods returned for service %s", svcFwd)
+			// Only log warning once to avoid spamming logs
+			if !svcFwd.noPodsLogged {
+				log.Warnf("WARNING: No Running Pods returned for service %s", svcFwd)
+				svcFwd.noPodsLogged = true
+			}
 			// Schedule retry - don't update LastSyncedAt so we retry sooner
 			if svcFwd.RetryInterval > 0 {
 				go func() {
@@ -341,6 +354,12 @@ func (svcFwd *ServiceFWD) SyncPodForwards(force bool) {
 			return
 		}
 
+		// Pods found - reset the no-pods log flag so we log again if they disappear
+		if svcFwd.noPodsLogged {
+			log.Infof("Pods now available for service %s", svcFwd)
+			svcFwd.noPodsLogged = false
+		}
+
 		// Only update LastSyncedAt after successful pod discovery
 		defer func() { svcFwd.LastSyncedAt = time.Now() }()