fix: only show install prompt after manager timeout, not during startup

Previously, checkExtension would show the 'install extension' prompt
inside a setImmediate callback — just one tick after startup. If the
extension host hadn't fully initialized yet, getExtension() could return
undefined even for installed extensions, causing a false prompt.

Now the install prompt is only shown after the full 30-second timeout
expires AND getExtension() still returns undefined. This gives the
extension host ample time to initialize. Additionally, if the extension
IS installed but the manager never registered (activation failure), we
log a warning instead of prompting to install.

Changes:
- Move install prompt logic from checkExtension into
  promptInstallExtensionIfMissing, called only after timeout
- checkExtension now only attempts activation (no install prompts)
- Add guard: if extension is installed but manager never registered,
  log a warning instead of prompting to install
- Add 5 regression tests for the race condition scenarios
- Add _resetManagerReadyForTesting() helper for test isolation

Fixes #1465

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: edvilme

src/features/common/managerReady.ts

@@ -1,5 +1,5 @@
 import { Disposable, l10n, Uri } from 'vscode';
-import { allExtensions, getExtension } from '../../common/extension.apis';
+import { getExtension } from '../../common/extension.apis';
 import { WorkbenchStrings } from '../../common/localize';
 import { traceError, traceInfo, traceWarn } from '../../common/logging';
 import { EventNames } from '../../common/telemetry/constants';
@@ -31,6 +31,10 @@ function getExtensionId(managerId: string): string | undefined {
  * Wraps a deferred with a timeout so a missing/dead manager cannot block the API forever.
  * On timeout the deferred is resolved (not rejected) so callers proceed with degraded results
  * instead of hanging.
+ *
+ * Also attempts to activate the manager's extension early (via setImmediate) so it has the
+ * best chance of registering before the timeout. If the timeout does fire, prompts the user
+ * to install the extension only if it's genuinely missing.
  */
 export function withManagerTimeout(
     deferred: Deferred<void>,
@@ -40,6 +44,10 @@ export function withManagerTimeout(
     if (deferred.completed) {
         return deferred.promise;
     }
+
+    // Attempt to activate the extension early so the manager registers sooner
+    tryActivateExtension(managerId);
+
     return new Promise<void>((resolve) => {
         const timer = setTimeout(() => {
             if (!deferred.completed) {
@@ -53,6 +61,7 @@ export function withManagerTimeout(
                     managerKind: kind,
                 });
                 deferred.resolve();
+                promptInstallExtensionIfMissing(managerId);
             }
         }, MANAGER_READY_TIMEOUT_MS);
 
@@ -69,10 +78,81 @@ export function withManagerTimeout(
     });
 }
 
+/**
+ * Attempts to activate the extension for a manager if it's installed but not yet active.
+ * This is a best-effort nudge — if it fails, the timeout will handle it.
+ */
+function tryActivateExtension(managerId: string): void {
+    const extId = getExtensionId(managerId);
+    if (!extId) {
+        return;
+    }
+    setImmediate(async () => {
+        const ext = getExtension(extId);
+        if (ext && !ext.isActive) {
+            traceInfo(`Extension for manager ${managerId} is not active: Activating...`);
+            try {
+                await ext.activate();
+                traceInfo(`Extension for manager ${managerId} is now active.`);
+            } catch (err) {
+                traceError(`Failed to activate extension ${extId}, required for: ${managerId}`, err);
+            }
+        }
+    });
+}
+
+/**
+ * Shows an install prompt only if the extension for the given manager ID
+ * is genuinely not available. Called after the timeout expires, giving the
+ * extension host ample time to initialize.
+ */
+async function promptInstallExtensionIfMissing(managerId: string): Promise<void> {
+    const extId = getExtensionId(managerId);
+    if (!extId) {
+        showErrorMessage(l10n.t(`Extension for {0} is not installed or enabled for this workspace.`, managerId));
+        return;
+    }
+
+    const ext = getExtension(extId);
+    if (ext) {
+        // Extension is installed but the manager never registered — don't prompt to install.
+        // This can happen if the extension activated but failed to register its manager.
+        traceWarn(
+            `Extension ${extId} is installed but manager "${managerId}" never registered. ` +
+                `The extension may have failed during activation or manager registration.`,
+        );
+        return;
+    }
+
+    traceError(`Extension for manager ${managerId} is not installed. Looked up extId="${extId}" via getExtension().`);
+    const result = await showErrorMessage(
+        l10n.t(`Do you want to install extension {0} to enable {1} support.`, extId, managerId),
+        WorkbenchStrings.installExtension,
+    );
+    if (result === WorkbenchStrings.installExtension) {
+        traceInfo(`Installing extension: ${extId}`);
+        try {
+            await installExtension(extId);
+            traceInfo(`Extension ${extId} installed.`);
+        } catch (err) {
+            traceError(`Failed to install extension: ${extId}`, err);
+        }
+
+        try {
+            const installedExt = getExtension(extId);
+            if (installedExt && !installedExt.isActive) {
+                traceInfo(`Extension for manager ${managerId} is not active: Activating...`);
+                await installedExt.activate();
+            }
+        } catch (err) {
+            traceError(`Failed to activate extension ${extId}, required for: ${managerId}`, err);
+        }
+    }
+}
+
 class ManagerReadyImpl implements ManagerReady {
     private readonly envManagers: Map<string, Deferred<void>> = new Map();
     private readonly pkgManagers: Map<string, Deferred<void>> = new Map();
-    private readonly checked: Set<string> = new Set();
     private readonly disposables: Disposable[] = [];
 
     constructor(
@@ -101,58 +181,6 @@ class ManagerReadyImpl implements ManagerReady {
         );
     }
 
-    private checkExtension(managerId: string) {
-        const installed = allExtensions().some((ext) => managerId.startsWith(`${ext.id}:`));
-        if (this.checked.has(managerId)) {
-            return;
-        }
-        this.checked.add(managerId);
-        const extId = getExtensionId(managerId);
-        if (extId) {
-            setImmediate(async () => {
-                if (installed) {
-                    const ext = getExtension(extId);
-                    if (ext && !ext.isActive) {
-                        traceInfo(`Extension for manager ${managerId} is not active: Activating...`);
-                        try {
-                            await ext.activate();
-                            traceInfo(`Extension for manager ${managerId} is now active.`);
-                        } catch (err) {
-                            traceError(`Failed to activate extension ${extId}, required for: ${managerId}`, err);
-                        }
-                    }
-                } else {
-                    traceError(`Extension for manager ${managerId} is not installed.`);
-                    const result = await showErrorMessage(
-                        l10n.t(`Do you want to install extension {0} to enable {1} support.`, extId, managerId),
-                        WorkbenchStrings.installExtension,
-                    );
-                    if (result === WorkbenchStrings.installExtension) {
-                        traceInfo(`Installing extension: ${extId}`);
-                        try {
-                            await installExtension(extId);
-                            traceInfo(`Extension ${extId} installed.`);
-                        } catch (err) {
-                            traceError(`Failed to install  extension: ${extId}`, err);
-                        }
-
-                        try {
-                            const ext = getExtension(extId);
-                            if (ext && !ext.isActive) {
-                                traceInfo(`Extension for manager ${managerId} is not active: Activating...`);
-                                await ext.activate();
-                            }
-                        } catch (err) {
-                            traceError(`Failed to activate extension ${extId}, required for: ${managerId}`, err);
-                        }
-                    }
-                }
-            });
-        } else {
-            showErrorMessage(l10n.t(`Extension for {0} is not installed or enabled for this workspace.`, managerId));
-        }
-    }
-
     public dispose(): void {
         this.disposables.forEach((d) => d.dispose());
         this.envManagers.clear();
@@ -188,7 +216,6 @@ class ManagerReadyImpl implements ManagerReady {
     }
 
     public async waitForEnvManagerId(managerIds: string[]): Promise<void> {
-        managerIds.forEach((managerId) => this.checkExtension(managerId));
         await Promise.all(managerIds.map((managerId) => this._waitForEnvManager(managerId)));
     }
 
@@ -237,7 +264,6 @@ class ManagerReadyImpl implements ManagerReady {
         await this.waitForPkgManagerId(Array.from(ids));
     }
     public async waitForPkgManagerId(managerIds: string[]): Promise<void> {
-        managerIds.forEach((managerId) => this.checkExtension(managerId));
         await Promise.all(managerIds.map((managerId) => this._waitForPkgManager(managerId)));
     }
 }
@@ -251,6 +277,14 @@ export function createManagerReady(em: EnvironmentManagers, pm: PythonProjectMan
     }
 }
 
+/**
+ * Reset the module-level singleton so `createManagerReady` can be called again.
+ * Only for use in tests.
+ */
+export function _resetManagerReadyForTesting(): void {
+    _deferred = createDeferred<ManagerReady>();
+}
+
 export async function waitForEnvManager(uris?: Uri[]): Promise<void> {
     const mr = await _deferred.promise;
     return mr.waitForEnvManager(uris);