Merge pull request #2658 from cachix/auto-reload-shell

Auto-reload shell environment instead of requiring Ctrl-Alt-R

Author: domenkozar

CHANGELOG.md

@@ -21,6 +21,7 @@
 - Added Ctrl+X keybinding to stop individual processes from the TUI while keeping them visible and restartable.
 - Tasks can now display messages when entering the shell by writing `{"devenv":{"messages":["..."]}}` to `$DEVENV_TASK_OUTPUT_FILE` ([#2500](https://github.com/cachix/devenv/issues/2500)).
 - Added `devenv hook <shell>` for native directory based auto-activation without direnv. Supports bash, zsh, fish, and nushell. Automatically deactivates when you leave the project directory. Add `eval "$(devenv hook bash)"` to your shell config to activate. Use `devenv allow` and `devenv revoke` to manage trust ([#2488](https://github.com/cachix/devenv/issues/2488)).
+- Shell environment now auto-reloads at the next prompt when watched files change, instead of requiring a manual Ctrl-Alt-R keybind ([#2595](https://github.com/cachix/devenv/issues/2595)).
 - Added `nixpkgs.rocmSupport` option to enable ROCm support in nixpkgs configuration.
 - Added process management subcommands and MCP tools: `devenv processes list`, `status`, `logs`, `restart`, `start`, `stop` for interacting with running native processes ([#2621](https://github.com/cachix/devenv/issues/2621)).
 ## 2.0.6 (2026-03-22)

Cargo.nix

@@ -1,6 +1,6 @@
 
 # This file was @generated by crate2nix 0.15.0 with the command:
-#   "generate"
+#   "generate" "-h" "nix/crate-hashes.json"
 # See https://github.com/kolloch/crate2nix for more info.
 
 { nixpkgs ? <nixpkgs>

devenv-event-sources/src/fs.rs

@@ -83,6 +83,55 @@ impl WatcherHandle {
         }
     }
 
+    /// Force all watched paths to be re-registered with the OS.
+    ///
+    /// On Linux, inotify watches track file inodes. When an editor does an
+    /// atomic save (write temp + rename), the inode changes and the old watch
+    /// becomes stale. The watchexec fs worker's diff logic skips paths already
+    /// in its pathset, so stale watches are never refreshed.
+    ///
+    /// This method forces a full refresh by briefly clearing the pathset
+    /// (causing the fs worker to drop all watches) and then re-setting it
+    /// (causing fresh watches to be created on current inodes).
+    pub async fn rewatch_all(&self) {
+        let mut ready = self.config.as_ref().map(|c| c.fs_ready());
+
+        {
+            let paths = self.watched_paths.lock().unwrap();
+            if paths.is_empty() {
+                return;
+            }
+
+            if let Some(ref config) = self.config {
+                // Clear forces the fs worker to unwatch everything
+                config.pathset(std::iter::empty::<WatchedPath>());
+            }
+        }
+
+        // Wait for the clear to be processed
+        if let Some(ref mut rx) = ready {
+            let _ = rx.changed().await;
+        }
+
+        // Now re-subscribe for the re-add
+        let mut ready = self.config.as_ref().map(|c| c.fs_ready());
+
+        {
+            let paths = self.watched_paths.lock().unwrap();
+            if let Some(ref config) = self.config {
+                config.pathset(
+                    paths
+                        .iter()
+                        .map(|p| WatchedPath::non_recursive(p.as_path())),
+                );
+            }
+        }
+
+        if let Some(ref mut rx) = ready {
+            let _ = rx.changed().await;
+        }
+    }
+
     pub fn watched_paths(&self) -> Vec<PathBuf> {
         self.watched_paths.lock().unwrap().iter().cloned().collect()
     }

devenv-reload/src/coordinator.rs

@@ -269,6 +269,13 @@ impl ShellCoordinator {
                 Event::ReloadBuildComplete { result, activity } => {
                     current_build = None;
 
+                    // Refresh all inotify watches. Editors using atomic save
+                    // (write temp + rename) replace the file inode, which
+                    // silently invalidates the kernel-level inotify watch.
+                    // The watchexec diff logic won't re-watch paths it thinks
+                    // are already watched, so we force a full refresh.
+                    watcher_handle.rewatch_all().await;
+
                     // Collect changed files as relative paths
                     let files: Vec<PathBuf> = pending_changes
                         .drain(..)

devenv-shell/src/dialect/bash.rs

@@ -65,7 +65,7 @@ if [[ -n "${{GHOSTTY_RESOURCES_DIR:-}}" && -r "${{GHOSTTY_RESOURCES_DIR}}/shell-
     source "${{GHOSTTY_RESOURCES_DIR}}/shell-integration/bash/ghostty.bash"
 fi
 
-# Hot-reload hook (keybinding and PROMPT_COMMAND integration)
+# Hot-reload hook (PROMPT_COMMAND integration)
 {reload_hook}
 
 # Re-enable history after init
@@ -235,14 +235,10 @@ __devenv_restore_path() {{
 }}
 
 __devenv_reload_hook() {{
+    __devenv_reload_apply
     __devenv_restore_path
 }}
 
-if [[ $- == *i* ]] && command -v bind >/dev/null 2>&1; then
-    __devenv_reload_keybind="${{DEVENV_RELOAD_KEYBIND:-\\e\\C-r}}"
-    bind -x "\"${{__devenv_reload_keybind}}\":__devenv_reload_apply"
-fi
-
 # Append hook so it runs AFTER direnv's _direnv_hook (only if not already added)
 if [[ "$PROMPT_COMMAND" != *"__devenv_reload_hook"* ]]; then
     PROMPT_COMMAND="${{PROMPT_COMMAND:+$PROMPT_COMMAND;}}__devenv_reload_hook"

devenv-shell/src/dialect/mod.rs

@@ -27,7 +27,7 @@ pub trait ShellDialect: Send + Sync {
     /// Generate environment diff helper functions (for hot-reload tracking).
     fn env_diff_helpers(&self) -> &str;
 
-    /// Generate the hot-reload hook script (keybinding + prompt hook).
+    /// Generate the hot-reload hook script (prompt hook).
     fn reload_hook(&self, reload_file: &Path) -> String;
 
     /// Path to the user's shell rc file (e.g., ~/.bashrc, ~/.zshrc).

devenv-shell/src/protocol.rs

@@ -27,7 +27,7 @@ pub enum ShellCommand {
         changed_files: Vec<PathBuf>,
         error: String,
     },
-    /// User applied the reload (pressed keybind). Clear status line.
+    /// Reload was applied at the prompt. Update status line.
     ReloadApplied,
     /// File watching paused/resumed.
     WatchingPaused { paused: bool },

devenv-shell/src/session.rs

@@ -997,6 +997,21 @@ impl ShellSession {
                         continue;
                     }
                 }
+            } else if let Some(remaining) = self.status_line.state().reloaded_remaining() {
+                tokio::select! {
+                    event = event_rx.recv() => event,
+                    _ = tokio::time::sleep(remaining) => {
+                        self.status_line.state_mut().clear_reloaded();
+                        if self.config.show_status_line {
+                            queue!(stdout, terminal::BeginSynchronizedUpdate)?;
+                            self.status_line.draw(stdout, self.size.cols, self.size.rows)?;
+                            renderer.write_cursor(stdout, vt)?;
+                            queue!(stdout, terminal::EndSynchronizedUpdate)?;
+                            stdout.flush()?;
+                        }
+                        continue;
+                    }
+                }
             } else {
                 event_rx.recv().await
             };
@@ -1264,7 +1279,7 @@ impl ShellSession {
             }
 
             ShellCommand::ReloadApplied => {
-                self.status_line.state_mut().clear();
+                self.status_line.state_mut().set_reloaded();
             }
 
             ShellCommand::WatchedFiles { files } => {

devenv-shell/src/status_line.rs

@@ -48,7 +48,6 @@ pub const CHECKMARK: &str = "✓";
 pub const XMARK: &str = "✗";
 
 /// Keybind labels (short, long) for status line actions
-const KEYBIND_RELOAD: (&str, &str) = ("^⌥r", "Ctrl-Alt-R");
 const KEYBIND_ERROR: (&str, &str) = ("^⌥e", "Ctrl-Alt-E");
 const KEYBIND_PAUSE: (&str, &str) = ("^⌥d", "Ctrl-Alt-D");
 
@@ -59,8 +58,12 @@ pub struct StatusState {
     pub changed_files: Vec<PathBuf>,
     /// Whether a build is in progress (evaluating nix).
     pub building: bool,
-    /// Whether a reload is ready (waiting for user).
+    /// Whether a reload is ready (auto-applies at next prompt).
     pub reload_ready: bool,
+    /// Whether the environment was just reloaded.
+    pub reloaded: bool,
+    /// When the reloaded state was set (for auto-clearing after timeout).
+    pub reloaded_at: Option<Instant>,
     /// Error message if build failed.
     pub error: Option<String>,
     /// Whether the error details are expanded (toggled by keybind).
@@ -85,6 +88,8 @@ impl StatusState {
     pub fn set_building(&mut self, changed_files: Vec<PathBuf>) {
         self.building = true;
         self.reload_ready = false;
+        self.reloaded = false;
+        self.reloaded_at = None;
         self.changed_files = changed_files;
         self.error = None;
         self.show_error = false;
@@ -116,10 +121,43 @@ impl StatusState {
         self.error = Some(error);
     }
 
+    /// Update state after reload was applied.
+    pub fn set_reloaded(&mut self) {
+        self.building = false;
+        self.reload_ready = false;
+        self.reloaded = true;
+        self.reloaded_at = Some(Instant::now());
+        self.changed_files.clear();
+        self.error = None;
+        self.show_error = false;
+        // keep build_duration and watched_file_count
+    }
+
+    /// Duration until the reloaded state should auto-clear.
+    pub fn reloaded_remaining(&self) -> Option<std::time::Duration> {
+        const RELOADED_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3);
+        self.reloaded_at.and_then(|at| {
+            let elapsed = at.elapsed();
+            if elapsed >= RELOADED_TIMEOUT {
+                None
+            } else {
+                Some(RELOADED_TIMEOUT - elapsed)
+            }
+        })
+    }
+
+    /// Clear the reloaded state (called when timeout expires).
+    pub fn clear_reloaded(&mut self) {
+        self.reloaded = false;
+        self.reloaded_at = None;
+    }
+
     /// Clear the status.
     pub fn clear(&mut self) {
         self.building = false;
         self.reload_ready = false;
+        self.reloaded = false;
+        self.reloaded_at = None;
         self.changed_files.clear();
         self.error = None;
         self.show_error = false;
@@ -139,6 +177,7 @@ impl StatusState {
     pub fn has_status(&self) -> bool {
         self.building
             || self.reload_ready
+            || self.reloaded
             || self.error.is_some()
             || self.paused
             || self.watched_file_count > 0
@@ -380,10 +419,9 @@ impl StatusLine {
             }
             .into_any()
         } else if self.state.reload_ready {
-            // Ready state
+            // Ready state (auto-reloads at next prompt)
             let duration = duration_elements(&self.state);
             let watching = watching_elements(self.state.watched_file_count);
-            let keybind = keybind_label(KEYBIND_RELOAD, use_short);
 
             element! {
                 View(width: width as u32, height: 1, flex_direction: FlexDirection::Row, justify_content: JustifyContent::SpaceBetween, padding_left: 1, padding_right: 1) {
@@ -396,9 +434,24 @@ impl StatusLine {
                         #(duration)
                         #(watching)
                     }
-                    View(flex_direction: FlexDirection::Row, flex_shrink: 0.0, margin_left: 2) {
-                        Text(content: keybind, color: COLOR_INTERACTIVE)
-                        Text(content: " reload")
+                }
+            }
+            .into_any()
+        } else if self.state.reloaded {
+            // Reloaded state (environment was applied)
+            let duration = duration_elements(&self.state);
+            let watching = watching_elements(self.state.watched_file_count);
+
+            element! {
+                View(width: width as u32, height: 1, flex_direction: FlexDirection::Row, justify_content: JustifyContent::SpaceBetween, padding_left: 1, padding_right: 1) {
+                    View(flex_direction: FlexDirection::Row, flex_grow: 1.0, min_width: 0, overflow: Overflow::Hidden) {
+                        View(margin_right: 1) {
+                            Text(content: CHECKMARK, color: COLOR_COMPLETED)
+                        }
+                        Text(content: "devenv ", color: COLOR_SECONDARY)
+                        Text(content: "reloaded", weight: Weight::Bold, color: COLOR_COMPLETED)
+                        #(duration)
+                        #(watching)
                     }
                 }
             }

devenv-shell/tests/snapshots/session_tests__reload_ready.snap

@@ -2,4 +2,4 @@
 source: devenv-shell/tests/session_tests.rs
 expression: "&rows[23]"
 ---
- ✓ devenv ready in [TIME] | watching 2 files                  Ctrl-Alt-R reload
+ ✓ devenv ready in [TIME] | watching 2 files