Support reload_config on resume hooks

When a Fly.io machine resumes from suspension and a resume hook
specifies reload_config, the configuration is now properly reloaded.
This triggers ready hooks (including prerender) to run after the
resume hook completes.

Changes:
- Add configFile and reloadCallback fields to idle.Manager
- Use ExecuteServerHooksWithReload for resume hooks
- Add resumeReloadChan to ServerLifecycle for async reload
- Update all test files with new NewManager signature

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

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

Author: rubys

cmd/navigator/main.go

@@ -83,7 +83,16 @@ func main() {
 	// Create managers
 	processManager := process.NewManager(cfg)
 	appManager := process.NewAppManager(cfg)
-	idleManager := idle.NewManager(cfg)
+
+	// Create reload channel for resume hook config reload
+	resumeReloadChan := make(chan string, 1)
+	idleManager := idle.NewManager(cfg, configFile, func(path string) {
+		// Non-blocking send to avoid deadlock if channel is full
+		select {
+		case resumeReloadChan <- path:
+		default:
+		}
+	})
 
 	// Load authentication if configured
 	var basicAuth *auth.BasicAuth
@@ -116,12 +125,13 @@ func main() {
 
 	// Create and run server lifecycle
 	lifecycle := &ServerLifecycle{
-		configFile:     configFile,
-		cfg:            cfg,
-		appManager:     appManager,
-		processManager: processManager,
-		basicAuth:      basicAuth,
-		idleManager:    idleManager,
+		configFile:       configFile,
+		cfg:              cfg,
+		appManager:       appManager,
+		processManager:   processManager,
+		basicAuth:        basicAuth,
+		idleManager:      idleManager,
+		resumeReloadChan: resumeReloadChan,
 	}
 
 	if err := lifecycle.Run(); err != nil {
@@ -220,15 +230,16 @@ func printHelp() {
 
 // ServerLifecycle manages the HTTP server lifecycle and signal handling
 type ServerLifecycle struct {
-	configFile     string
-	cfg            *config.Config
-	appManager     *process.AppManager
-	processManager *process.Manager
-	basicAuth      *auth.BasicAuth
-	idleManager    *idle.Manager
-	cableHandler   *cable.Handler
-	srv            *http.Server
-	reloadChan     chan string // Channel for triggering config reload from CGI scripts
+	configFile       string
+	cfg              *config.Config
+	appManager       *process.AppManager
+	processManager   *process.Manager
+	basicAuth        *auth.BasicAuth
+	idleManager      *idle.Manager
+	cableHandler     *cable.Handler
+	srv              *http.Server
+	reloadChan       chan string // Channel for triggering config reload from CGI scripts
+	resumeReloadChan chan string // Channel for triggering config reload from resume hooks
 }
 
 // Run starts the server and handles signals until shutdown
@@ -311,6 +322,13 @@ func (l *ServerLifecycle) Run() error {
 			}
 			l.handleReload()
 
+		case configPath := <-l.resumeReloadChan:
+			// Resume hook triggered reload
+			if configPath != l.configFile {
+				l.configFile = configPath
+			}
+			l.handleReload()
+
 		case sig := <-sigChan:
 			switch sig {
 			case syscall.SIGHUP:
@@ -342,7 +360,7 @@ func (l *ServerLifecycle) handleReload() {
 	// Update configuration in all managers
 	l.appManager.UpdateConfig(newConfig)
 	l.processManager.UpdateManagedProcesses(newConfig)
-	l.idleManager.UpdateConfig(newConfig)
+	l.idleManager.UpdateConfig(newConfig, l.configFile)
 
 	// Update proxy settings
 	proxy.SetTrustProxy(newConfig.Server.TrustProxy)

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)
+	idleManager := idle.NewManager(cfg, "", nil)
 
 	// Create lifecycle
 	lifecycle := &ServerLifecycle{

cmd/navigator/main_test.go

@@ -263,7 +263,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)
+	idleManager := idle.NewManager(cfg, "", nil)
 
 	// Create lifecycle with nonexistent config file
 	lifecycle := &ServerLifecycle{
@@ -315,7 +315,7 @@ logging:
 	// Create real managers to avoid nil pointer issues
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg)
+	idleManager := idle.NewManager(cfg, "", nil)
 
 	// Create lifecycle with valid config file
 	lifecycle := &ServerLifecycle{
@@ -393,7 +393,7 @@ logging:
 		t.Error("Expected non-nil app manager")
 	}
 
-	idleManager := idle.NewManager(cfg)
+	idleManager := idle.NewManager(cfg, "", nil)
 	if idleManager == nil {
 		t.Error("Expected non-nil idle manager")
 	}
@@ -495,7 +495,7 @@ logging:
 	// Create real managers to avoid nil pointer issues
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg)
+	idleManager := idle.NewManager(cfg, "", nil)
 
 	// Create lifecycle with valid config file
 	lifecycle := &ServerLifecycle{
@@ -598,7 +598,7 @@ logging:
 	// Create managers
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg)
+	idleManager := idle.NewManager(cfg, "", nil)
 
 	// Create lifecycle
 	lifecycle := &ServerLifecycle{
@@ -690,7 +690,7 @@ logging:
 	// Create real managers to avoid nil pointer issues
 	appManager := process.NewAppManager(cfg)
 	processManager := process.NewManager(cfg)
-	idleManager := idle.NewManager(cfg)
+	idleManager := idle.NewManager(cfg, "", nil)
 
 	// Create lifecycle with valid config file
 	lifecycle := &ServerLifecycle{

internal/idle/manager.go

@@ -20,17 +20,22 @@ type Manager struct {
 	mutex          sync.RWMutex
 	timer          *time.Timer
 	config         *config.Config
-	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
+	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
 }
 
 // NewManager creates a new idle manager
-func NewManager(cfg *config.Config) *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 {
 	m := &Manager{
-		config:       cfg,
-		lastActivity: time.Now(),
+		config:         cfg,
+		configFile:     configFile,
+		reloadCallback: reloadCallback,
+		lastActivity:   time.Now(),
 	}
 
 	// Initialize condition variable
@@ -85,11 +90,22 @@ func (m *Manager) RequestStarted() {
 		m.idleActioned = false
 		m.resuming = true
 
+		// Capture values needed in goroutine
+		configFile := m.configFile
+		reloadCallback := m.reloadCallback
+
 		// Execute resume hooks asynchronously
 		go func() {
 			slog.Info("Executing server resume hooks")
-			if err := process.ExecuteServerHooks(m.config.Hooks.Resume, "resume"); err != nil {
-				slog.Error("Failed to execute resume hooks", "error", err)
+			result := process.ExecuteServerHooksWithReload(m.config.Hooks.Resume, "resume", configFile)
+			if result.Error != nil {
+				slog.Error("Failed to execute resume hooks", "error", result.Error)
+			} else if result.ReloadDecision.ShouldReload && reloadCallback != nil {
+				// Resume hook triggered config reload
+				slog.Info("Resume hook triggered config reload",
+					"reason", result.ReloadDecision.Reason,
+					"configFile", result.ReloadDecision.NewConfigFile)
+				reloadCallback(result.ReloadDecision.NewConfigFile)
 			}
 
 			m.mutex.Lock()
@@ -227,11 +243,12 @@ 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) {
+func (m *Manager) UpdateConfig(newConfig *config.Config, configFile string) {
 	m.mutex.Lock()
 	defer m.mutex.Unlock()
 
 	m.config = newConfig
+	m.configFile = configFile
 
 	// Re-configure idle settings from new config
 	if newConfig.Server.Idle.Action != "" && (newConfig.Server.Idle.Action == "suspend" || newConfig.Server.Idle.Action == "stop") {