Fix stale preset state on included file changes (#4777)

- Unify FileWatcher to use single debounced callback for all events
  (change/create/delete), fixing race condition when external tools
  regenerate included files via atomic write (delete + create)
- Detect root presets file creation inside reapplyPresets() by comparing
  before/after presetsFileExists state instead of separate handler
- Add reapplyPresets() call in configureInternal() so explicit user
  commands always read fresh preset state from disk
- Update tests to reflect unified event handling
- Add CHANGELOG entry

Co-authored-by: hanniavalera <[email protected]>

Author: Copilot

.npmrc .npmrc.bak.npmrc renamed to .npmrc.bak

@@ -22,6 +22,7 @@ Improvements:
 - Display info tooltip when hovering over CMake policy identifiers (e.g., `CMP0177`), showing the CMake version that introduced the policy, a short description, and a link to the official documentation. [#4544](https://github.com/microsoft/vscode-cmake-tools/issues/4544)
 
 Bug Fixes:
+- Fix changes to files referenced via `include` in CMakePresets.json or CMakeUserPresets.json not being detected until VS Code restart. The file watcher now uniformly handles create events (from atomic writes) on included files, and explicit reconfigure commands always refresh presets from disk. [#4777](https://github.com/microsoft/vscode-cmake-tools/issues/4777)
 - Fix configure/build sometimes using stale preset values when unsaved changes to included preset files are auto-saved before configure. The extension now explicitly refreshes presets from disk after saving, instead of relying solely on the asynchronous file watcher. [#4502](https://github.com/microsoft/vscode-cmake-tools/issues/4502)
 - Reduce overly verbose logging when CMake configure or build fails. The Output panel no longer floods with duplicated output, and the channel is only revealed on error rather than unconditionally. [#4749](https://github.com/microsoft/vscode-cmake-tools/issues/4749)
 - Fix Test Results panel not hyperlinking file paths for GoogleTest failures. The default `cmake.ctest.failurePatterns` now includes a pattern matching GoogleTest's `file:line: Failure` output format. [#4589](https://github.com/microsoft/vscode-cmake-tools/issues/4589)

CHANGELOG.md

@@ -1638,6 +1638,14 @@ export class CMakeProject {
     }
 
     async configureInternal(trigger: ConfigureTrigger = ConfigureTrigger.api, extraArgs: string[] = [], type: ConfigureType = ConfigureType.Normal, debuggerInformation?: DebuggerInformation, cancellationToken?: vscode.CancellationToken): Promise<ConfigureResult> {
+        // Explicitly refresh presets from disk so that explicit user commands
+        // (configure, clean-configure, etc.) always use up-to-date preset state,
+        // even if the asynchronous file watcher hasn't processed recent changes
+        // to included preset files yet. See issue #4777.
+        if (this.useCMakePresets) {
+            await this.presetsController.reapplyPresets();
+        }
+
         const drv: CMakeDriver | null = await this.getCMakeDriverInstance();
 
         // Don't show a progress bar when the extension is using Cache for configuration.

src/cmakeProject.ts

@@ -181,6 +181,9 @@ export class PresetsController implements vscode.Disposable {
     // in setConfigurePreset and to ensure consistent preset state.
     async reapplyPresets() {
         const doReapply = async () => {
+            // Capture pre-reload state to detect root presets file creation.
+            const existedBefore = this.presetsFileExist;
+
             const referencedFiles: Map<string, preset.PresetsFile | undefined> =
                 new Map();
 
@@ -202,6 +205,13 @@ export class PresetsController implements vscode.Disposable {
             // Don't need to set build/test presets here since they are reapplied in setConfigurePreset
 
             await this.watchPresetsChange();
+
+            // If a root presets file was freshly created (transitioned from absent to present),
+            // update the active project so the UI reflects preset mode. This replaces
+            // the previous onCreatePresetsFile() handler that was wired only to onDidCreate.
+            if (!existedBefore && this.presetsFileExist) {
+                await this.project.projectController?.updateActiveProject(this.workspaceFolder);
+            }
         };
         this._reapplyInProgress = this._reapplyInProgress.then(doReapply, doReapply);
         return this._reapplyInProgress;
@@ -1706,23 +1716,14 @@ export class PresetsController implements vscode.Disposable {
         return vscode.window.showTextDocument(vscode.Uri.file(presetsFilePath));
     }
 
-    // this is used for the file watcher on adding a new presets file
-    async onCreatePresetsFile() {
-        await this.reapplyPresets();
-        await this.project.projectController?.updateActiveProject(this.workspaceFolder);
-    }
-
     private async watchPresetsChange() {
 
         const presetChangeHandler = () => {
             void this.reapplyPresets();
         };
-        const presetCreatedHandler = () => {
-            void this.onCreatePresetsFile();
-        };
 
         this._presetsWatchers?.dispose();
-        this._presetsWatchers = new FileWatcher(this._referencedFiles, presetChangeHandler, presetCreatedHandler);
+        this._presetsWatchers = new FileWatcher(this._referencedFiles, presetChangeHandler);
     };
 
     dispose() {
@@ -1746,7 +1747,7 @@ class FileWatcher implements vscode.Disposable {
     // Two change events are coming in rapid succession without this.
     private canRunChangeHandler = true;
 
-    public constructor(filePaths: string[], changeHandler: () => void, createHandler: () => void) {
+    public constructor(filePaths: string[], changeHandler: () => void) {
         const debouncedOnChange = () => {
             if (this.canRunChangeHandler) {
                 changeHandler();
@@ -1762,7 +1763,7 @@ class FileWatcher implements vscode.Disposable {
                 const watcher = vscode.workspace.createFileSystemWatcher(pattern);
 
                 watcher.onDidChange(debouncedOnChange);
-                watcher.onDidCreate(createHandler);
+                watcher.onDidCreate(debouncedOnChange);
                 watcher.onDidDelete(debouncedOnChange);
 
                 this.watchers.push(watcher);

src/presets/presetsController.ts

@@ -239,22 +239,61 @@ suite('PresetsController file watcher protection', () => {
     });
 
     /**
-     * Test that create events are not debounced and always fire immediately.
-     * The FileWatcher treats create events differently from change events.
+     * Test that all filesystem events (change, create, delete) are debounced uniformly.
+     * After unifying the FileWatcher handler (fix for #4777), create events are
+     * debounced the same way as change and delete events to prevent race conditions
+     * when external tools regenerate included files via atomic write (delete + create).
      */
-    test('Create events are not debounced', () => {
-        let createCount = 0;
+    test('All events including create are debounced', () => {
+        let canRunChangeHandler = true;
+        let eventCount = 0;
+        const debounceMs = 100;
+
+        // Simulates the unified debounced handler used for all events
+        const handler = () => {
+            if (canRunChangeHandler) {
+                eventCount++;
+                canRunChangeHandler = false;
+                setTimeout(() => (canRunChangeHandler = true), debounceMs);
+            }
+        };
+
+        // Rapid create events should be debounced (only first fires)
+        handler(); // create event
+        handler(); // another create event
+        handler(); // yet another create event
+
+        expect(eventCount).to.equal(1);
+    });
+
+    /**
+     * Test that a delete followed by a create (atomic write pattern) is handled
+     * as a single reload. This simulates the scenario where an external tool like
+     * Conan regenerates an included preset file. See issue #4777.
+     */
+    test('Delete followed by create triggers single debounced reload', async () => {
+        let canRunChangeHandler = true;
+        let eventCount = 0;
+        const debounceMs = 100;
 
-        const createHandler = () => {
-            createCount++;
+        const handler = () => {
+            if (canRunChangeHandler) {
+                eventCount++;
+                canRunChangeHandler = false;
+                setTimeout(() => (canRunChangeHandler = true), debounceMs);
+            }
         };
 
-        // Multiple create events should all fire
-        createHandler();
-        createHandler();
-        createHandler();
+        // Simulate atomic write: delete event immediately followed by create event
+        handler(); // delete event
+        handler(); // create event (should be debounced)
+
+        expect(eventCount).to.equal(1);
 
-        expect(createCount).to.equal(3);
+        // After debounce period, another event should fire
+        await new Promise(resolve => setTimeout(resolve, debounceMs + 10));
+        handler();
+        expect(eventCount).to.equal(2);
     });
 
     /**