Make configure-on-open resilient to delayed CMake availability (#4880)

* Fix false 'Bad CMake executable' error when vendor extension is still installing CMake

When a vendor extension (e.g., STM32 for VS Code, ESP-IDF) is still
downloading or installing CMake at the time CMake Tools activates,
the automatic configure-on-open would immediately show a misleading
'Bad CMake executable' error popup.

This change checks cmake availability before the initial configure
attempt. When cmake is not found, it polls with exponential backoff
(2s, 4s, 8s, 16s) using a lightweight getCMakeExecutable() probe
that does not enter the driver strand or trigger error popups. If
cmake becomes available during the retry window, a single configure
runs. If not, the standard error popup fires once after retries
exhaust.

Also fixes reloadCMakeDriver() silently doing nothing when the CMake
driver was never created (null). The method now always disposes the
old driver if present and (re)creates a new one when cmake is
available, or resets to null otherwise. This ensures that changing
cmake.cmakePath in settings takes effect even if the initial cmake
lookup failed.

* Wait for vendor-managed CMake before failing configure-on-open

Add `cmake.vendorIntegrators`, a string array that defaults to
`["ST", "Espressif", "NXP", "Nordic"]`.

During automatic configure-on-open, if CMake is missing but one of
those vendor extensions is installed, do not fail right away. Some of
those extensions install or expose CMake asynchronously, so we now poll
for it with exponential backoff at 2s, 4s, 8s, and 16s before surfacing
the error.

For users without one of those extensions, nothing changes: they still
see the error immediately.

Also fix `reloadCMakeDriver()`. If the CMake driver was never created,
the method used to silently do nothing. It now creates or recreates the
driver when `cmake.cmakePath` changes, even if the initial lookup
failed.

* rename to be more comprehensive

---------

Co-authored-by: Hannia Valera <[email protected]>

Author: hanniavalera

docs/cmake-settings.md

@@ -28,6 +28,7 @@ Options that support substitution, in the table below, allow variable references
 | `cmake.configureEnvironment` | An object containing `key:value` pairs of environment variables, which will be passed to CMake only when configuring.| `null` (no environment variable pairs) | yes |
 | `cmake.configureOnEdit` | Automatically configure CMake project directories when the path in the `cmake.sourceDirectory` setting is updated or when `CMakeLists.txt` or `*.cmake` files are saved. | `true` | no |
 | `cmake.configureOnOpen` | Automatically configure CMake project directories when they are opened. | `true` | no |
+| `cmake.cmakeProviderExtensions` | List of VS Code extension IDs that provide or install their own CMake binary. When CMake is not found during automatic configure-on-open and one of these extensions is installed, CMake Tools will briefly poll for CMake availability instead of showing an immediate error. Set to an empty array to disable this behavior. | `["stmicroelectronics.stm32-vscode-extension", "espressif.esp-idf-extension", "NXPSemiconductors.mcuxpresso", "nordic-semiconductor.nrf-connect"]` | no |
 | `cmake.configureSettings` | An object containing `key:value` pairs, which will be passed to CMake when configuring. The same as passing `-DVAR_NAME=ON` via `cmake.configureArgs`. NOTE: Semicolons (`;`) in string values are automatically escaped to prevent CMake from interpreting them as list separators. If you want to pass a CMake list, use array notation instead, e.g. `"MY_LIST": [ "a", "b" ]`. | `{}` (no values) | yes |
 | `cmake.copyCompileCommands`| If not `null`, copies the `compile_commands.json` file generated by CMake to the path specified by this setting whenever CMake successfully configures. |  `null` (do not copy the file) | yes |
 | `cmake.postConfigureTask`| If not `null`, the task with this name is executed whenever CMake successfully configures. |  `null` (do not run any task) | yes |

package.json

@@ -3126,6 +3126,20 @@
           "description": "%cmake-tools.configuration.cmake.configureOnEdit.description%",
           "scope": "resource"
         },
+        "cmake.cmakeProviderExtensions": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "default": [
+            "stmicroelectronics.stm32-vscode-extension",
+            "espressif.esp-idf-extension",
+            "NXPSemiconductors.mcuxpresso",
+            "nordic-semiconductor.nrf-connect"
+          ],
+          "description": "%cmake-tools.configuration.cmake.cmakeProviderExtensions.description%",
+          "scope": "resource"
+        },
         "cmake.deleteBuildDirOnCleanConfigure": {
           "type": "boolean",
           "default": false,

package.nls.json

@@ -275,6 +275,7 @@
     "cmake-tools.configuration.cmake.postConfigureTask.description": "If set, this named task will be executed after a successful CMake configure.",
     "cmake-tools.configuration.cmake.configureOnOpen.description": "Automatically configure CMake project directories when they are opened.",
     "cmake-tools.configuration.cmake.configureOnEdit.description": "Automatically configure CMake project directories when cmake.sourceDirectory or CMakeLists.txt content are saved.",
+    "cmake-tools.configuration.cmake.cmakeProviderExtensions.description": "List of VS Code extension IDs that provide or install their own CMake binary. When CMake is not found during automatic configure-on-open and one of these extensions is installed, CMake Tools will briefly poll for CMake availability instead of showing an immediate error. Set to an empty array to disable this behavior.",
     "cmake-tools.configuration.cmake.deleteBuildDirOnCleanConfigure.description": "Delete the entire build directory when a clean configure is invoked.",
     "cmake-tools.configuration.cmake.setBuildTypeOnMultiConfig.description": "Set CMAKE_BUILD_TYPE also on multi config generators.",
     "cmake-tools.configuration.cmake.skipConfigureIfCachePresent.description": "Skip over the configure process if cache is present.",

src/cmakeProject.ts

@@ -1265,14 +1265,18 @@ export class CMakeProject {
     private async reloadCMakeDriver() {
         try {
             const drv = await this.cmakeDriver;
-            if (drv) {
-                log.debug(localize('reloading.driver', 'Reloading CMake driver'));
-                await drv?.asyncDispose();
-                return this.cmakeDriver = this.startNewCMakeDriver(await this.getCMakeExecutable());
-            }
+            log.debug(localize('reloading.driver', 'Reloading CMake driver'));
+            await drv?.asyncDispose();
         } catch {
-            return this.cmakeDriver = this.startNewCMakeDriver(await this.getCMakeExecutable());
+            // Driver was in a bad state — proceed to create a new one.
+        }
+        const cmake = await this.getCMakeExecutable();
+        if (cmake.isPresent) {
+            return this.cmakeDriver = this.startNewCMakeDriver(cmake);
         }
+        // CMake is still not available — reset to null so getCMakeDriverInstance()
+        // can surface the error when the user next triggers a command.
+        return this.cmakeDriver = Promise.resolve(null);
     }
 
     /**

src/config.ts

@@ -227,6 +227,7 @@ export interface ExtensionConfigurationSettings {
     loadCompileCommands: boolean;
     configureOnOpen: boolean;
     configureOnEdit: boolean;
+    cmakeProviderExtensions: string[];
     deleteBuildDirOnCleanConfigure: boolean;
     skipConfigureIfCachePresent: boolean | null;
     useCMakeServer: boolean;
@@ -504,6 +505,9 @@ export class ConfigurationReader implements vscode.Disposable {
     get configureOnEdit() {
         return this.configData.configureOnEdit;
     }
+    get cmakeProviderExtensions(): string[] {
+        return this.configData.cmakeProviderExtensions;
+    }
     get deleteBuildDirOnCleanConfigure() {
         return this.configData.deleteBuildDirOnCleanConfigure;
     }
@@ -738,6 +742,7 @@ export class ConfigurationReader implements vscode.Disposable {
         loadCompileCommands: new vscode.EventEmitter<boolean>(),
         configureOnOpen: new vscode.EventEmitter<boolean>(),
         configureOnEdit: new vscode.EventEmitter<boolean>(),
+        cmakeProviderExtensions: new vscode.EventEmitter<string[]>(),
         deleteBuildDirOnCleanConfigure: new vscode.EventEmitter<boolean>(),
         skipConfigureIfCachePresent: new vscode.EventEmitter<boolean | null>(),
         useCMakeServer: new vscode.EventEmitter<boolean>(),

src/extension.ts

@@ -13,6 +13,7 @@ import * as api from 'vscode-cmake-tools';
 import { CMakeCache } from '@cmt/cache';
 import { CMakeProject, ConfigureType, ConfigureTrigger, DiagnosticsConfiguration, DiagnosticsSettings } from '@cmt/cmakeProject';
 import { ConfigurationReader, getSettingsChangePromise, TouchBarConfig } from '@cmt/config';
+import { CMakeDriver, CMakePreconditionProblems, ConfigureResult, ConfigureResultType } from '@cmt/drivers/cmakeDriver';
 import { CppConfigurationProvider, DiagnosticsCpptools } from '@cmt/cpptools';
 import { ProjectController, AfterAcknowledgeFolderType} from '@cmt/projectController';
 
@@ -37,7 +38,6 @@ import { ProgressHandle, DummyDisposable, reportProgress, runCommand } from '@cm
 import { DEFAULT_VARIANTS } from '@cmt/kits/variant';
 import { expandString, KitContextVars } from '@cmt/expand';
 import paths from '@cmt/paths';
-import { CMakeDriver, CMakePreconditionProblems } from './drivers/cmakeDriver';
 import { platform } from 'os';
 import { CMakeToolsApiImpl } from '@cmt/api';
 import { DirectoryContext } from '@cmt/workspace';
@@ -65,6 +65,37 @@ export const hideLaunchCommandKey = 'cmake:hideLaunchCommand';
 export const hideDebugCommandKey = 'cmake:hideDebugCommand';
 export const hideBuildCommandKey = 'cmake:hideBuildCommand';
 
+/**
+ * Friendly display names for known vendor extensions. Used to show a nicer
+ * progress message (e.g., "Waiting for STM32 for VS Code..." instead of
+ * "Waiting for stmicroelectronics.stm32-vscode-extension...").
+ * Extensions not in this map fall back to their raw ID.
+ */
+const vendorExtensionLabels: ReadonlyMap<string, string> = new Map([
+    ['stmicroelectronics.stm32-vscode-extension', 'STM32 for VS Code'],
+    ['espressif.esp-idf-extension', 'ESP-IDF'],
+    ['NXPSemiconductors.mcuxpresso', 'MCUXpresso'],
+    ['nordic-semiconductor.nrf-connect', 'nRF Connect']
+]);
+
+/**
+ * Check if any extension ID from the given list is currently installed.
+ * Returns the friendly display name of the first match, or undefined if none.
+ */
+function getInstalledVendorHint(vendorIds: string[]): string | undefined {
+    for (const id of vendorIds) {
+        if (vscode.extensions.getExtension(id)) {
+            return vendorExtensionLabels.get(id) ?? id;
+        }
+    }
+    return undefined;
+}
+
+/** Maximum number of retries when CMake is not found during configure-on-open. */
+const cmakeNotFoundMaxRetries = 4;
+/** Delay sequence (in ms) between retries — exponential backoff. */
+const cmakeNotFoundRetryDelaysMs: readonly number[] = [2000, 4000, 8000, 16000];
+
 /**
  * The global extension manager. There is only one of these, even if multiple
  * backends.
@@ -702,12 +733,12 @@ export class ExtensionManager implements vscode.Disposable {
         await telemetry.deactivate();
     }
 
-    async configureExtensionInternal(trigger: ConfigureTrigger, project: CMakeProject): Promise<void> {
+    async configureExtensionInternal(trigger: ConfigureTrigger, project: CMakeProject): Promise<ConfigureResult> {
         if (trigger !== ConfigureTrigger.configureWithCache && !await this.ensureActiveConfigurePresetOrKit(project)) {
-            return;
+            return { exitCode: -1, resultType: ConfigureResultType.Other };
         }
 
-        await project.configureInternal(trigger, [], ConfigureType.Normal);
+        return project.configureInternal(trigger, [], ConfigureType.Normal);
     }
 
     async postWorkspaceOpen(project?: CMakeProject) {
@@ -738,7 +769,26 @@ export class ExtensionManager implements vscode.Disposable {
                 // We've opened a new workspace folder, and the user wants us to
                 // configure it now.
                 log.debug(localize('configuring.workspace.on.open', 'Configuring workspace on open {0}', project.folderPath));
-                await this.configureExtensionInternal(ConfigureTrigger.configureOnOpen, project);
+
+                // Check cmake availability first. If cmake is not present AND
+                // a vendor extension from the cmake.cmakeProviderExtensions setting is
+                // installed, poll for cmake to appear (the vendor may still be
+                // installing it). Otherwise, proceed to configure immediately —
+                // the standard "Bad CMake executable" error will surface if needed.
+                const cmake = await project.getCMakeExecutable();
+                if (cmake.isPresent) {
+                    await this.configureExtensionInternal(ConfigureTrigger.configureOnOpen, project);
+                } else {
+                    const vendorIds = project.workspaceContext.config.cmakeProviderExtensions;
+                    const vendorHint = getInstalledVendorHint(vendorIds);
+                    if (vendorHint) {
+                        await this.waitForCmakeAndConfigure(project, vendorHint);
+                    } else {
+                        // No vendor extension installed — cmake is genuinely missing.
+                        // Run configure to surface the error immediately.
+                        await this.configureExtensionInternal(ConfigureTrigger.configureOnOpen, project);
+                    }
+                }
             } else {
                 const configureButtonMessage = localize('configure.now.button', 'Configure Now');
                 let result: string | undefined;
@@ -759,6 +809,70 @@ export class ExtensionManager implements vscode.Disposable {
         }
     }
 
+    /**
+     * Wait for CMake to become available, then configure.
+     *
+     * When cmake is not found during the automatic configureOnOpen flow and a
+     * vendor extension from the `cmake.cmakeProviderExtensions` setting is installed,
+     * this method polls for cmake presence with exponential backoff. This handles
+     * the case where a vendor extension (e.g., STMicroelectronics, Espressif) is
+     * still downloading or installing cmake when CMake Tools activates.
+     *
+     * A window progress indicator is shown while retrying.
+     *
+     * Only the lightweight getCMakeExecutable() probe runs during the retry
+     * window — no configure pipeline, no error popups, no driver strand held.
+     * When cmake is finally found, a single configureExtensionInternal() call
+     * runs the full configure.
+     *
+     * @param vendorHint Display name of the detected vendor extension, used in
+     *                   the progress message.
+     */
+    private async waitForCmakeAndConfigure(project: CMakeProject, vendorHint: string): Promise<void> {
+        const progressTitle = localize('cmake.retry.vendor.title', 'Waiting for {0} to set up CMake...', vendorHint);
+
+        log.info(localize('cmake.not.found.retrying', 'CMake not found during configure-on-open. Waiting for {0} to finish setup...', vendorHint));
+
+        const found = await vscode.window.withProgress(
+            {
+                location: vscode.ProgressLocation.Window,
+                title: progressTitle
+            },
+            async (): Promise<boolean> => {
+                for (let attempt = 0; attempt < cmakeNotFoundMaxRetries; attempt++) {
+                    const delayMs = cmakeNotFoundRetryDelaysMs[
+                        Math.min(attempt, cmakeNotFoundRetryDelaysMs.length - 1)
+                    ];
+                    await new Promise<void>(resolve => setTimeout(resolve, delayMs));
+
+                    // Lightweight probe: just check if cmake is available now.
+                    // This does NOT enter the driverStrand, does NOT show popups,
+                    // and does NOT run the configure pipeline.
+                    const cmake = await project.getCMakeExecutable();
+                    if (cmake.isPresent) {
+                        log.info(localize('cmake.retry.success', 'CMake found after {0}s (attempt {1}/{2})',
+                            cmakeNotFoundRetryDelaysMs.slice(0, attempt + 1).reduce((a, b) => a + b, 0) / 1000,
+                            attempt + 1, cmakeNotFoundMaxRetries));
+                        return true;
+                    }
+
+                    log.debug(localize('cmake.retry.not.yet', 'CMake not yet available (attempt {0}/{1})',
+                        attempt + 1, cmakeNotFoundMaxRetries));
+                }
+                return false;
+            }
+        );
+
+        if (found) {
+            log.info(localize('cmake.retry.configuring', 'CMake is now available — configuring project'));
+        } else {
+            // All retries exhausted. Run configure anyway to surface the
+            // "Bad CMake executable" error popup so the user knows what's wrong.
+            log.warning(localize('cmake.retry.exhausted', 'CMake not found after {0} retries', cmakeNotFoundMaxRetries));
+        }
+        await this.configureExtensionInternal(ConfigureTrigger.configureOnOpen, project);
+    }
+
     private async onDidChangeActiveTextEditor(editor: vscode.TextEditor | undefined): Promise<void> {
         if (this.workspaceConfig.autoSelectActiveFolder && this.projectController.hasMultipleProjects && vscode.workspace.workspaceFolders) {
             let folder: vscode.WorkspaceFolder | undefined;