fixes

Author: mohammeds1992

cmd/push-validator/cmd_version.go

@@ -71,7 +71,7 @@ type updateChecker interface {
 }
 
 // checkForUpdateBackground performs a non-blocking update check.
-// Uses cache to avoid checking more than once per 24 hours.
+// Uses cache to avoid checking more than once per 10 minutes.
 // Stores result in updateCheckResult global for use by PersistentPostRun.
 func checkForUpdateBackground() {
 	cfg := loadCfg()
@@ -85,6 +85,21 @@ func checkForUpdateBackground() {
 	}
 }
 
+// checkForUpdateFresh performs a fresh update check, bypassing cache.
+// Used by status and dashboard commands for immediate notification.
+func checkForUpdateFresh() {
+	cfg := loadCfg()
+	result, err := update.ForceCheck(cfg.HomeDir, Version)
+	if err != nil {
+		return // Silently fail
+	}
+	if result != nil && result.UpdateAvailable {
+		updateCheckMu.Lock()
+		updateCheckResult = result
+		updateCheckMu.Unlock()
+	}
+}
+
 // checkForUpdateWith is the testable core of checkForUpdateBackground.
 func checkForUpdateWith(
 	homeDir string,
@@ -176,3 +191,10 @@ func shouldSkipUpdateCheck(cmd *cobra.Command) bool {
 	}
 	return false
 }
+
+// shouldForceFreshUpdateCheck returns true for commands that need immediate update notification.
+// These commands bypass the cache and always make a fresh network call to GitHub.
+func shouldForceFreshUpdateCheck(cmd *cobra.Command) bool {
+	cmdName := cmd.Name()
+	return cmdName == "status" || cmdName == "dashboard"
+}

cmd/push-validator/cmd_version_extra_test.go

@@ -21,7 +21,7 @@ func (m *mockUpdateChecker) Check() (*update.CheckResult, error) {
 func TestCheckForUpdateWith_CacheValid_UpdateAvailable(t *testing.T) {
 	loadCache := func(homeDir string) (*update.CacheEntry, error) {
 		return &update.CacheEntry{
-			CheckedAt:       time.Now().Add(-1 * time.Hour),
+			CheckedAt:       time.Now().Add(-5 * time.Minute), // Within 10-minute cache TTL
 			LatestVersion:   "2.0.0",
 			UpdateAvailable: true,
 		}, nil
@@ -47,7 +47,7 @@ func TestCheckForUpdateWith_CacheValid_UpdateAvailable(t *testing.T) {
 func TestCheckForUpdateWith_CacheValid_NoUpdate(t *testing.T) {
 	loadCache := func(homeDir string) (*update.CacheEntry, error) {
 		return &update.CacheEntry{
-			CheckedAt:       time.Now().Add(-1 * time.Hour),
+			CheckedAt:       time.Now().Add(-5 * time.Minute), // Within 10-minute cache TTL
 			LatestVersion:   "1.0.0",
 			UpdateAvailable: false,
 		}, nil
@@ -153,7 +153,7 @@ func TestCheckForUpdateWith_CacheValid_SameVersion(t *testing.T) {
 	// Cache says update available but we're now on the latest version
 	loadCache := func(homeDir string) (*update.CacheEntry, error) {
 		return &update.CacheEntry{
-			CheckedAt:       time.Now().Add(-1 * time.Hour),
+			CheckedAt:       time.Now().Add(-5 * time.Minute), // Within 10-minute cache TTL
 			LatestVersion:   "1.0.0",
 			UpdateAvailable: true,
 		}, nil

cmd/push-validator/root_cobra.go

@@ -58,7 +58,13 @@ var rootCmd = &cobra.Command{
 		// Start background update check (non-blocking)
 		// Skip for installation-related commands where notifications are disruptive
 		if !shouldSkipUpdateCheck(cmd) {
-			go checkForUpdateBackground()
+			// Use fresh check (bypass cache) for status/dashboard commands
+			// to ensure immediate notification of new versions
+			if shouldForceFreshUpdateCheck(cmd) {
+				go checkForUpdateFresh()
+			} else {
+				go checkForUpdateBackground()
+			}
 		}
 	},
 	PersistentPostRun: func(cmd *cobra.Command, args []string) {

internal/dashboard/dashboard.go

@@ -201,10 +201,23 @@ func (m *Dashboard) Init() tea.Cmd {
 	return tea.Batch(
 		m.spinner.Tick,
 		m.fetchCmd(),
+		m.updateCheckCmd(), // Fresh update check on startup
 		tickCmd(m.opts.RefreshInterval),
 	)
 }
 
+// updateCheckCmd performs a fresh update check on dashboard startup.
+// This bypasses the cache to ensure immediate notification of new versions.
+func (m *Dashboard) updateCheckCmd() tea.Cmd {
+	return func() tea.Msg {
+		result, err := update.ForceCheck(m.opts.Config.HomeDir, m.opts.CLIVersion)
+		if err != nil {
+			return updateCheckResultMsg{result: nil}
+		}
+		return updateCheckResultMsg{result: result}
+	}
+}
+
 // Update handles messages (Bubble Tea lifecycle)
 func (m *Dashboard) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
@@ -274,6 +287,14 @@ func (m *Dashboard) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		var cmd tea.Cmd
 		m.spinner, cmd = m.spinner.Update(msg)
 		return m, cmd
+
+	case updateCheckResultMsg:
+		// Fresh update check completed on startup
+		if msg.result != nil && msg.result.UpdateAvailable {
+			m.data.UpdateInfo.Available = true
+			m.data.UpdateInfo.LatestVersion = msg.result.LatestVersion
+		}
+		return m, nil
 	}
 
 	return m, nil

internal/dashboard/types.go

@@ -7,6 +7,7 @@ import (
 	"github.com/pushchain/push-validator-cli/internal/config"
 	"github.com/pushchain/push-validator-cli/internal/metrics"
 	"github.com/pushchain/push-validator-cli/internal/process"
+	"github.com/pushchain/push-validator-cli/internal/update"
 )
 
 // Message types for Bubble Tea event loop - ensures deterministic control flow
@@ -34,6 +35,11 @@ type forceRefreshMsg struct{}
 // toggleHelpMsg is sent when user presses '?' to toggle help overlay
 type toggleHelpMsg struct{}
 
+// updateCheckResultMsg is sent when the startup update check completes
+type updateCheckResultMsg struct {
+	result *update.CheckResult
+}
+
 // DashboardData aggregates all data shown in the dashboard
 type DashboardData struct {
 	// Reuse existing metrics collector

internal/update/cache.go

@@ -55,3 +55,27 @@ func SaveCache(homeDir string, entry *CacheEntry) error {
 func IsCacheValid(entry *CacheEntry) bool {
 	return time.Since(entry.CheckedAt) < cacheDuration
 }
+
+// ForceCheck performs a fresh update check, ignoring cache.
+// Used by status and dashboard commands for immediate notification.
+// Updates the cache after checking.
+func ForceCheck(homeDir, currentVersion string) (*CheckResult, error) {
+	updater, err := New(currentVersion)
+	if err != nil {
+		return nil, err
+	}
+
+	result, err := updater.Check()
+	if err != nil {
+		return nil, err
+	}
+
+	// Update cache with fresh result
+	_ = SaveCache(homeDir, &CacheEntry{
+		CheckedAt:       time.Now(),
+		LatestVersion:   result.LatestVersion,
+		UpdateAvailable: result.UpdateAvailable,
+	})
+
+	return result, nil
+}

internal/update/cache_test.go

@@ -111,6 +111,7 @@ func TestLoadCache_InvalidJSON(t *testing.T) {
 }
 
 func TestIsCacheValid(t *testing.T) {
+	// Note: cacheDuration is 10 minutes
 	tests := []struct {
 		name      string
 		checkedAt time.Time
@@ -122,28 +123,28 @@ func TestIsCacheValid(t *testing.T) {
 			want:      true,
 		},
 		{
-			name:      "fresh cache - 1 hour ago",
-			checkedAt: time.Now().Add(-1 * time.Hour),
+			name:      "fresh cache - 5 minutes ago",
+			checkedAt: time.Now().Add(-5 * time.Minute),
 			want:      true,
 		},
 		{
-			name:      "fresh cache - 23 hours ago",
-			checkedAt: time.Now().Add(-23 * time.Hour),
+			name:      "fresh cache - 9 minutes ago",
+			checkedAt: time.Now().Add(-9 * time.Minute),
 			want:      true,
 		},
 		{
-			name:      "stale cache - 25 hours ago",
-			checkedAt: time.Now().Add(-25 * time.Hour),
+			name:      "stale cache - 11 minutes ago",
+			checkedAt: time.Now().Add(-11 * time.Minute),
 			want:      false,
 		},
 		{
-			name:      "stale cache - 48 hours ago",
-			checkedAt: time.Now().Add(-48 * time.Hour),
+			name:      "stale cache - 1 hour ago",
+			checkedAt: time.Now().Add(-1 * time.Hour),
 			want:      false,
 		},
 		{
-			name:      "stale cache - 7 days ago",
-			checkedAt: time.Now().Add(-7 * 24 * time.Hour),
+			name:      "stale cache - 24 hours ago",
+			checkedAt: time.Now().Add(-24 * time.Hour),
 			want:      false,
 		},
 	}