Fix config reload detection when machine resumes from suspend

Previously, config reload detection compared the config file's modTime
against the hook's start time. This failed to detect changes made while
the machine was suspended because the file modification time predated
the hook execution.

Now, reload detection compares against when the config was last loaded
(configLoadTime), which correctly detects any changes since the last
load, including those made during machine suspension.

Changes:
- Add configLoadTime parameter to ShouldReloadConfig
- Update ExecuteServerHooksWithReload to accept configLoadTime
- Add configLoadTime field to idle.Manager and ServerLifecycle
- Pass configLoadTime through CGI handler and CreateHandler
- Update all tests for new signatures

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: rubys

cmd/navigator/main.go

@@ -52,6 +52,7 @@ func main() {
 		slog.Error("Failed to load configuration", "error", err)
 		os.Exit(1)
 	}
+	configLoadTime := time.Now() // Track when config was loaded for reload detection
 	slog.Info("Loaded configuration",
 		"tenants", len(cfg.Applications.Tenants),
 		"reverseProxies", len(cfg.Routes.ReverseProxies),
@@ -86,7 +87,7 @@ func main() {
 
 	// Create reload channel for resume hook config reload
 	resumeReloadChan := make(chan string, 1)
-	idleManager := idle.NewManager(cfg, configFile, func(path string) {
+	idleManager := idle.NewManager(cfg, configFile, configLoadTime, func(path string) {
 		// Non-blocking send to avoid deadlock if channel is full
 		select {
 		case resumeReloadChan <- path:
@@ -127,6 +128,7 @@ func main() {
 	lifecycle := &ServerLifecycle{
 		configFile:       configFile,
 		cfg:              cfg,
+		configLoadTime:   configLoadTime,
 		appManager:       appManager,
 		processManager:   processManager,
 		basicAuth:        basicAuth,
@@ -232,6 +234,7 @@ func printHelp() {
 type ServerLifecycle struct {
 	configFile       string
 	cfg              *config.Config
+	configLoadTime   time.Time // When the current config was loaded (used for reload detection)
 	appManager       *process.AppManager
 	processManager   *process.Manager
 	basicAuth        *auth.BasicAuth
@@ -258,8 +261,9 @@ func (l *ServerLifecycle) Run() error {
 		l.basicAuth,
 		l.idleManager,
 		l.cableHandler,
-		func() string { return l.configFile }, // Get current config file
-		func(path string) { l.reloadChan <- path }, // Trigger reload
+		func() string { return l.configFile },       // Get current config file
+		func() time.Time { return l.configLoadTime }, // Get config load time for reload detection
+		func(path string) { l.reloadChan <- path },  // Trigger reload
 	)
 
 	// Create HTTP server
@@ -290,7 +294,8 @@ func (l *ServerLifecycle) Run() error {
 		time.Sleep(100 * time.Millisecond)
 
 		// Execute server ready hooks with reload check
-		result := process.ExecuteServerHooksWithReload(l.cfg.Hooks.Ready, "ready", l.configFile)
+		// Pass configLoadTime to detect changes since config was loaded (including during suspend)
+		result := process.ExecuteServerHooksWithReload(l.cfg.Hooks.Ready, "ready", l.configFile, l.configLoadTime)
 		if result.Error != nil {
 			slog.Error("Failed to execute ready hooks", "error", result.Error)
 		} else if result.ReloadDecision.ShouldReload {
@@ -357,10 +362,14 @@ func (l *ServerLifecycle) handleReload() {
 		"trust_proxy", newConfig.Server.TrustProxy,
 		"config_file", l.configFile)
 
+	// Replace config and update load time
+	l.cfg = newConfig
+	l.configLoadTime = time.Now()
+
 	// Update configuration in all managers
 	l.appManager.UpdateConfig(newConfig)
 	l.processManager.UpdateManagedProcesses(newConfig)
-	l.idleManager.UpdateConfig(newConfig, l.configFile)
+	l.idleManager.UpdateConfig(newConfig, l.configFile, l.configLoadTime)
 
 	// Update proxy settings
 	proxy.SetTrustProxy(newConfig.Server.TrustProxy)
@@ -372,9 +381,6 @@ func (l *ServerLifecycle) handleReload() {
 	// Update logging format if changed
 	setupLogging(newConfig)
 
-	// Replace config
-	l.cfg = newConfig
-
 	// Execute server start hooks BEFORE loading auth
 	// This is important because hooks may update the htpasswd file
 	if err := process.ExecuteServerHooks(newConfig.Hooks.Start, "start"); err != nil {
@@ -410,8 +416,9 @@ func (l *ServerLifecycle) handleReload() {
 			l.basicAuth,
 			l.idleManager,
 			l.cableHandler,
-			func() string { return l.configFile }, // Get current config file
-			func(path string) { l.reloadChan <- path }, // Trigger reload
+			func() string { return l.configFile },       // Get current config file
+			func() time.Time { return l.configLoadTime }, // Get config load time for reload detection
+			func(path string) { l.reloadChan <- path },  // Trigger reload
 		)
 		l.srv.Handler = newHandler
 	}

cmd/navigator/main_ready_hook_test.go

@@ -63,7 +63,7 @@ logging:
 	// Create managers
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg, "", nil)
+	idleManager := idle.NewManager(cfg, "", time.Time{}, nil)
 
 	// Create lifecycle
 	lifecycle := &ServerLifecycle{

cmd/navigator/main_test.go

@@ -7,6 +7,7 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/rubys/navigator/internal/auth"
 	"github.com/rubys/navigator/internal/config"
@@ -263,7 +264,7 @@ func TestHandleConfigReload(t *testing.T) {
 	// Create real managers to avoid nil pointer issues
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg, "", nil)
+	idleManager := idle.NewManager(cfg, "", time.Time{}, nil)
 
 	// Create lifecycle with nonexistent config file
 	lifecycle := &ServerLifecycle{
@@ -315,7 +316,7 @@ logging:
 	// Create real managers to avoid nil pointer issues
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg, "", nil)
+	idleManager := idle.NewManager(cfg, "", time.Time{}, nil)
 
 	// Create lifecycle with valid config file
 	lifecycle := &ServerLifecycle{
@@ -393,7 +394,7 @@ logging:
 		t.Error("Expected non-nil app manager")
 	}
 
-	idleManager := idle.NewManager(cfg, "", nil)
+	idleManager := idle.NewManager(cfg, "", time.Time{}, nil)
 	if idleManager == nil {
 		t.Error("Expected non-nil idle manager")
 	}
@@ -495,7 +496,7 @@ logging:
 	// Create real managers to avoid nil pointer issues
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg, "", nil)
+	idleManager := idle.NewManager(cfg, "", time.Time{}, nil)
 
 	// Create lifecycle with valid config file
 	lifecycle := &ServerLifecycle{
@@ -598,7 +599,7 @@ logging:
 	// Create managers
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg, "", nil)
+	idleManager := idle.NewManager(cfg, "", time.Time{}, nil)
 
 	// Create lifecycle
 	lifecycle := &ServerLifecycle{
@@ -690,7 +691,7 @@ logging:
 	// Create real managers to avoid nil pointer issues
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg, "", nil)
+	idleManager := idle.NewManager(cfg, "", time.Time{}, nil)
 
 	// Create lifecycle with valid config file
 	lifecycle := &ServerLifecycle{

internal/cgi/handler.go

@@ -21,19 +21,20 @@ import (
 
 // Handler implements CGI script execution with user switching support
 type Handler struct {
-	Script          string
-	User            string
-	Group           string
-	AllowedUsers    []string
-	Env             map[string]string
-	ReloadConfig    string
-	Timeout         time.Duration
-	CurrentConfigFn func() string // Function to get current config file path
-	TriggerReloadFn func(string)  // Function to trigger config reload
+	Script           string
+	User             string
+	Group            string
+	AllowedUsers     []string
+	Env              map[string]string
+	ReloadConfig     string
+	Timeout          time.Duration
+	CurrentConfigFn  func() string    // Function to get current config file path
+	ConfigLoadTimeFn func() time.Time // Function to get when config was last loaded
+	TriggerReloadFn  func(string)     // Function to trigger config reload
 }
 
 // NewHandler creates a new CGI handler from configuration
-func NewHandler(cfg *config.CGIScriptConfig, currentConfigFn func() string, triggerReloadFn func(string)) (*Handler, error) {
+func NewHandler(cfg *config.CGIScriptConfig, currentConfigFn func() string, configLoadTimeFn func() time.Time, triggerReloadFn func(string)) (*Handler, error) {
 	// Validate script path
 	if cfg.Script == "" {
 		return nil, fmt.Errorf("CGI script path is required")
@@ -58,15 +59,16 @@ func NewHandler(cfg *config.CGIScriptConfig, currentConfigFn func() string, trig
 	})
 
 	return &Handler{
-		Script:          cfg.Script,
-		User:            cfg.User,
-		Group:           cfg.Group,
-		AllowedUsers:    cfg.AllowedUsers,
-		Env:             cfg.Env,
-		ReloadConfig:    cfg.ReloadConfig,
-		Timeout:         timeout,
-		CurrentConfigFn: currentConfigFn,
-		TriggerReloadFn: triggerReloadFn,
+		Script:           cfg.Script,
+		User:             cfg.User,
+		Group:            cfg.Group,
+		AllowedUsers:     cfg.AllowedUsers,
+		Env:              cfg.Env,
+		ReloadConfig:     cfg.ReloadConfig,
+		Timeout:          timeout,
+		CurrentConfigFn:  currentConfigFn,
+		ConfigLoadTimeFn: configLoadTimeFn,
+		TriggerReloadFn:  triggerReloadFn,
 	}, nil
 }
 
@@ -241,9 +243,10 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		"duration", time.Since(startTime))
 
 	// Check if config should be reloaded
-	if h.ReloadConfig != "" && h.CurrentConfigFn != nil && h.TriggerReloadFn != nil {
+	if h.ReloadConfig != "" && h.CurrentConfigFn != nil && h.ConfigLoadTimeFn != nil && h.TriggerReloadFn != nil {
 		currentConfig := h.CurrentConfigFn()
-		decision := utils.ShouldReloadConfig(h.ReloadConfig, currentConfig, startTime)
+		configLoadTime := h.ConfigLoadTimeFn()
+		decision := utils.ShouldReloadConfig(h.ReloadConfig, currentConfig, configLoadTime)
 		if decision.ShouldReload {
 			slog.Info("CGI script triggered config reload",
 				"script", h.Script,

internal/cgi/handler_test.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/rubys/navigator/internal/config"
 )
@@ -66,7 +67,7 @@ func TestNewHandler(t *testing.T) {
 				}
 			}
 
-			handler, err := NewHandler(tt.cfg, nil, nil)
+			handler, err := NewHandler(tt.cfg, nil, nil, nil)
 
 			if tt.wantError && err == nil {
 				t.Error("Expected error but got none")
@@ -106,7 +107,7 @@ echo "Query: $QUERY_STRING"
 		},
 	}
 
-	handler, err := NewHandler(cfg, nil, nil)
+	handler, err := NewHandler(cfg, nil, nil, nil)
 	if err != nil {
 		t.Fatalf("Failed to create handler: %v", err)
 	}
@@ -195,9 +196,11 @@ echo "Config updated"
 		ReloadConfig: configPath,
 	}
 
+	configLoadTime := time.Now().Add(-1 * time.Hour) // Simulate config was loaded an hour ago
 	handler, err := NewHandler(
 		cfg,
 		func() string { return configPath },
+		func() time.Time { return configLoadTime },
 		func(path string) {
 			reloadTriggered = true
 			reloadConfigPath = path
@@ -330,7 +333,7 @@ echo "Access granted"
 				AllowedUsers: tt.allowedUsers,
 			}
 
-			handler, err := NewHandler(cfg, nil, nil)
+			handler, err := NewHandler(cfg, nil, nil, nil)
 			if err != nil {
 				t.Fatalf("Failed to create handler: %v", err)
 			}

internal/idle/manager.go

@@ -12,28 +12,31 @@ import (
 
 // Manager tracks active requests and handles machine idle actions
 type Manager struct {
-	enabled        bool
-	action         string // "suspend" or "stop"
-	idleTimeout    time.Duration
-	activeRequests int64
-	lastActivity   time.Time
-	mutex          sync.RWMutex
-	timer          *time.Timer
-	config         *config.Config
-	configFile     string                  // Current config file path for reload_config support
-	reloadCallback func(configPath string) // Callback to trigger config reload
-	idleActioned   bool                    // Track if idle action was performed
-	resuming       bool                    // Track if resume hooks are currently running
-	resumeCond     *sync.Cond              // Condition variable to wait for resume completion
-	testMode       bool                    // Prevents actual signal sending during tests
+	enabled          bool
+	action           string // "suspend" or "stop"
+	idleTimeout      time.Duration
+	activeRequests   int64
+	lastActivity     time.Time
+	mutex            sync.RWMutex
+	timer            *time.Timer
+	config           *config.Config
+	configFile       string                  // Current config file path for reload_config support
+	configLoadTime   time.Time               // When the config was last loaded (for reload detection)
+	reloadCallback   func(configPath string) // Callback to trigger config reload
+	idleActioned     bool                    // Track if idle action was performed
+	resuming         bool                    // Track if resume hooks are currently running
+	resumeCond       *sync.Cond              // Condition variable to wait for resume completion
+	testMode         bool                    // Prevents actual signal sending during tests
 }
 
 // NewManager creates a new idle manager
 // The reloadCallback is called when a resume hook specifies reload_config and the config file was modified
-func NewManager(cfg *config.Config, configFile string, reloadCallback func(configPath string)) *Manager {
+// configLoadTime is when the config was last loaded (for detecting changes since last load)
+func NewManager(cfg *config.Config, configFile string, configLoadTime time.Time, reloadCallback func(configPath string)) *Manager {
 	m := &Manager{
 		config:         cfg,
 		configFile:     configFile,
+		configLoadTime: configLoadTime,
 		reloadCallback: reloadCallback,
 		lastActivity:   time.Now(),
 	}
@@ -94,10 +97,13 @@ func (m *Manager) RequestStarted() {
 		configFile := m.configFile
 		reloadCallback := m.reloadCallback
 
+		// Capture configLoadTime for the goroutine
+		configLoadTime := m.configLoadTime
+
 		// Execute resume hooks asynchronously
 		go func() {
 			slog.Info("Executing server resume hooks")
-			result := process.ExecuteServerHooksWithReload(m.config.Hooks.Resume, "resume", configFile)
+			result := process.ExecuteServerHooksWithReload(m.config.Hooks.Resume, "resume", configFile, configLoadTime)
 			if result.Error != nil {
 				slog.Error("Failed to execute resume hooks", "error", result.Error)
 			} else if result.ReloadDecision.ShouldReload && reloadCallback != nil {
@@ -243,12 +249,13 @@ func (m *Manager) GetStats() (activeRequests int64, lastActivity time.Time) {
 }
 
 // UpdateConfig updates the idle manager configuration after a reload
-func (m *Manager) UpdateConfig(newConfig *config.Config, configFile string) {
+func (m *Manager) UpdateConfig(newConfig *config.Config, configFile string, configLoadTime time.Time) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
 	m.config = newConfig
 	m.configFile = configFile
+	m.configLoadTime = configLoadTime
 
 	// Re-configure idle settings from new config
 	if newConfig.Server.Idle.Action != "" && (newConfig.Server.Idle.Action == "suspend" || newConfig.Server.Idle.Action == "stop") {