Warn when VS Code uses an outdated Aspire CLI

extension/package.nls.json

@@ -86,6 +86,8 @@
   "aspire-vscode.strings.aspireCliPathEnvironmentDescription": "Forwards aspire.aspireCliExecutablePath as AspireCliPath so MSBuild bundle resolution and integrated terminals use the configured Aspire CLI.",
   "aspire-vscode.strings.configuredCliPathRejected": "The configured Aspire CLI path could not be used, so a different Aspire CLI is running instead: {0}. Check that aspire.aspireCliExecutablePath points to the aspire executable itself and that it runs.",
   "aspire-vscode.strings.configuredCliPathRejectedOpenSetting": "Open Setting",
+  "aspire-vscode.strings.outdatedAspireCliWarning": "Aspire CLI {0} at {1} has a newer version available for its current channel: {2}.",
+  "aspire-vscode.strings.updateAspireCliAction": "Update Aspire CLI",
   "aspire-vscode.strings.installCliPlaceholder": "Select how to install the Aspire CLI",
   "aspire-vscode.strings.installCliViewAllOptions": "View all installation options",
   "aspire-vscode.strings.installCliViewAllOptionsDescription": "Open the installation guide (includes the install script)",

extension/src/activation/registerCliCommands.ts

@@ -28,9 +28,19 @@ import { getCliPathTargetForUri } from '../utils/cliPathVariables';
 interface CommandInvocation {
   readonly target: CliPathResolutionTarget;
   readonly appHost?: AppHostCommandTarget;
+  readonly cliPath?: string;
 }
 
 type CommandSource = 'command_palette' | 'tree';
+const cliCheckExcludedCommands = new Set([
+  'aspire-vscode.settings',
+  'aspire-vscode.configureLaunchJson',
+  'aspire-vscode.updateSelf',
+]);
+const cliCheckDeferredCommands = new Set([
+  'aspire-vscode.deploy',
+  'aspire-vscode.publish',
+]);
 
 export function registerCliCommands(
   terminalProvider: AspireTerminalProvider,
@@ -48,7 +58,12 @@ export function registerCliCommands(
   const cliPublishCommandRegistration = vscode.commands.registerCommand('aspire-vscode.publish', () => tryExecuteCommand('aspire-vscode.publish', terminalProvider, () => publishCommand(editorCommandProvider)));
   const cliDoCommandRegistration = vscode.commands.registerCommand('aspire-vscode.do', () => tryExecuteCommand('aspire-vscode.do', terminalProvider, (_tp, invocation, cliPath) => doCommand(configInfoProvider, editorCommandProvider, invocation.appHost?.appHostPath, invocation.target, cliPath), () => selectAppHostCommandInvocation(editorCommandProvider, true)));
   const cliUpdateCommandRegistration = vscode.commands.registerCommand('aspire-vscode.update', () => tryExecuteCommand('aspire-vscode.update', terminalProvider, (tp, invocation, cliPath) => updateCommand(tp, editorCommandProvider, invocation.appHost ?? {}, invocation.target, cliPath), () => selectAppHostCommandInvocation(editorCommandProvider)));
-  const cliUpdateSelfCommandRegistration = vscode.commands.registerCommand('aspire-vscode.updateSelf', () => tryExecuteCommand('aspire-vscode.updateSelf', terminalProvider, updateSelfCommand));
+  const cliUpdateSelfCommandRegistration = vscode.commands.registerCommand('aspire-vscode.updateSelf', (target: CliPathResolutionTarget = windowCliPathTarget, cliPath?: string) =>
+    tryExecuteCommand(
+      'aspire-vscode.updateSelf',
+      terminalProvider,
+      (tp, invocation, resolvedCliPath) => updateSelfCommand(tp, invocation.target, resolvedCliPath || undefined),
+      async () => ({ target, cliPath })));
   const openTerminalCommandRegistration = vscode.commands.registerCommand('aspire-vscode.openTerminal', () => tryExecuteCommand('aspire-vscode.openTerminal', terminalProvider, (tp, invocation, cliPath) => openTerminalCommand(tp, invocation.target, cliPath), selectCommandInvocation));
   const configureLaunchJsonCommandRegistration = vscode.commands.registerCommand('aspire-vscode.configureLaunchJson', () => tryExecuteCommand('aspire-vscode.configureLaunchJson', terminalProvider, configureLaunchJsonCommand));
   const settingsCommandRegistration = vscode.commands.registerCommand('aspire-vscode.settings', () => tryExecuteCommand('aspire-vscode.settings', terminalProvider, settingsCommand));
@@ -142,9 +157,8 @@ async function tryExecuteCommand(
   try {
     await withCommandTelemetry(commandName, async () => {
       const invocation = await prepareInvocation();
-      let cliPath = '';
-      const cliCheckExcludedCommands: string[] = ["aspire-vscode.settings", "aspire-vscode.configureLaunchJson", "aspire-vscode.updateSelf"];
-      if (!cliCheckExcludedCommands.includes(commandName)) {
+      let cliPath = invocation.cliPath ?? '';
+      if (!cliCheckExcludedCommands.has(commandName)) {
         if (isE2eBridgeEnabled() && process.env.ASPIRE_EXTENSION_E2E_FORCE_CLI_UNAVAILABLE === 'true') {
           vscode.window.showErrorMessage(
             cliNotAvailable,
@@ -154,16 +168,17 @@ async function tryExecuteCommand(
           throw new vscode.CancellationError();
         }
 
-        const result = await checkCliAvailableOrRedirect('command_gate', invocation.target);
-        if (!result.available) {
-          // The command body never ran — the user was redirected to install the
-          // CLI. Throwing a cancellation makes withCommandTelemetry record this
-          // as `canceled` rather than a false `success`, and the catch below
-          // suppresses the error toast (the redirect already informed the user).
-          throw new vscode.CancellationError();
+        if (!cliCheckDeferredCommands.has(commandName)) {
+          const result = await checkCliAvailableOrRedirect('command_gate', invocation.target);
+          if (!result.available) {
+            // The command body never ran — the user was redirected to install the
+            // CLI. Throwing a cancellation makes withCommandTelemetry record this
+            // as `canceled` rather than a false `success`, and the catch below
+            // suppresses the error toast (the redirect already informed the user).
+            throw new vscode.CancellationError();
+          }
+          cliPath = result.cliPath;
         }
-        cliPath = result.cliPath;
-
       }
 
       await command(terminalProvider, invocation, cliPath);

extension/src/commands/update.ts

@@ -13,6 +13,11 @@ export async function updateCommand(
     await terminalProvider.sendAspireCommandToAspireTerminal('update', true, appHost.args, { target, cliPath });
 }
 
-export async function updateSelfCommand(terminalProvider: AspireTerminalProvider) {
-    await terminalProvider.sendAspireCommandToAspireTerminal('update --self', true, undefined, { target: windowCliPathTarget });
+export async function updateSelfCommand(
+    terminalProvider: AspireTerminalProvider,
+    target: CliPathResolutionTarget = windowCliPathTarget,
+    cliPath?: string,
+) {
+    const resolvedCliPath = cliPath ?? await terminalProvider.getAspireCliExecutablePath(target);
+    await terminalProvider.sendAspireCommandToAspireTerminal('update --self', true, undefined, { target, cliPath: resolvedCliPath });
 }

extension/src/data/AppHostDataRepository.ts

@@ -18,6 +18,7 @@ import { isMatchingAppHostInstance, isMatchingAppHostPath, isPathInWorkspace } f
 import { AppHostPsPoller } from './appHostPsPoller';
 import { filterResourceCommandStatusOutput } from './resourceCommandStatusOutput';
 import { getCliPathTargetForUri } from '../utils/cliPathVariables';
+import { reportCliResolvedForOperation } from '../utils/cliOperationResolution';
 
 export * from './appHostCliContracts';
 export { shortenPath, shortenPaths };
@@ -1013,6 +1014,7 @@ export class AppHostDataRepository {
             if (this._disposed || this._describeStreams.get(appHostPath) !== stream || startVersion !== stream.version) {
                 return;
             }
+            reportCliResolvedForOperation(target, cliPath);
 
             // The capability is a property of the CLI this AppHost resolves to, not of the window: a
             // multi-root workspace can point each folder at a different aspire.cliPath, so a single

extension/src/data/appHostCliRunner.ts

@@ -8,6 +8,7 @@ import { isNoLogoUnsupportedOutput, noLogoOption, removeRootNoLogoOption } from
 import { AspireCliFailedError, AspireCliNotInstalledError } from './appHostCliContracts';
 import { normalizeResourceCommandStatusLine } from './resourceCommandStatusOutput';
 import { CliPathResolutionTarget, windowCliPathTarget } from '../utils/cliPathVariables';
+import { reportCliResolvedForOperation } from '../utils/cliOperationResolution';
 
 export const oneShotOutputBufferLimit = 64 * 1024;
 
@@ -78,14 +79,16 @@ export class AppHostCliRunner implements vscode.Disposable {
     }
 
     async runCliCommand(command: string, args: string[], options: RunCliCommandOptions = {}): Promise<{ stdout: string; stderr: string }> {
+        const target = options.target ?? windowCliPathTarget;
         const cliPath = options.cliPath
-            ?? await this._terminalProvider.getAspireCliExecutablePath(options.target ?? windowCliPathTarget).catch(error => {
+            ?? await this._terminalProvider.getAspireCliExecutablePath(target).catch(error => {
                 throw new AspireCliNotInstalledError(String(error));
             });
 
         if (options.cancellationToken?.isCancellationRequested) {
             throw new vscode.CancellationError();
         }
+        reportCliResolvedForOperation(target, cliPath);
         const invocationArgs = this.normalizeNoLogoArgs(cliPath, args);
 
         return new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {

extension/src/data/appHostPsPoller.ts

@@ -6,6 +6,7 @@ import { extensionLogOutputChannel } from '../utils/logging';
 import { errorFetchingAppHosts } from '../loc/strings';
 import { AppHostCliRunner, LimitedOutputBuffer, oneShotOutputBufferLimit } from './appHostCliRunner';
 import { windowCliPathTarget } from '../utils/cliPathVariables';
+import { reportCliResolvedForOperation } from '../utils/cliOperationResolution';
 
 export interface PsOutput {
     readonly stdout: string;
@@ -160,6 +161,7 @@ export class AppHostPsPoller implements vscode.Disposable {
         if (!this._isCurrentPsFetch(fetchVersion)) {
             return;
         }
+        reportCliResolvedForOperation(windowCliPathTarget, cliPath);
 
         let psProcess: ChildProcessWithoutNullStreams | undefined;
         let psProcessCompletedSynchronously = false;
@@ -345,6 +347,7 @@ export class AppHostPsPoller implements vscode.Disposable {
         if (!isCurrentPsCommand()) {
             return;
         }
+        reportCliResolvedForOperation(windowCliPathTarget, cliPath);
         const invocationArgs = this._cliRunner.normalizeNoLogoArgs(cliPath, args);
 
         let stdout = '';

extension/src/extension.ts

@@ -38,6 +38,9 @@ import { registerCliCommands } from './activation/registerCliCommands';
 import { registerTreeViewCommands } from './activation/registerTreeViewCommands';
 import { registerCodeLensCommands } from './activation/registerCodeLensCommands';
 import { initializeHotReloadAdvisory } from './debugger/hotReload';
+import { OutdatedCliNotifier } from './utils/outdatedCliNotifier';
+import { onDidResolveCliForOperation } from './utils/cliOperationResolution';
+import { FileSystemOutdatedCliSuppressionStore } from './utils/outdatedCliSuppressionStore';
 
 let aspireExtensionContext = new AspireExtensionContext();
 
@@ -101,6 +104,17 @@ export async function activate(context: vscode.ExtensionContext) {
   terminalProvider.closeAllOpenAspireTerminals();
 
   const configInfoProvider = new ConfigInfoProvider(terminalProvider);
+  const outdatedCliNotifier = new OutdatedCliNotifier(
+    configInfoProvider,
+    undefined,
+    Date.now,
+    new FileSystemOutdatedCliSuppressionStore(context.globalStorageUri.fsPath));
+  context.subscriptions.push(outdatedCliNotifier);
+  context.subscriptions.push(onDidResolveCliForOperation(({ target, cliPath }) => {
+    void outdatedCliNotifier.notifyIfOutdated(target, cliPath).catch(error => {
+      extensionLogOutputChannel.warn(`Unable to check Aspire CLI version: ${String(error)}`);
+    });
+  }));
   const appHostDiscoveryService = new AppHostDiscoveryService(terminalProvider, configInfoProvider);
   context.subscriptions.push(appHostDiscoveryService);
 

extension/src/loc/strings.ts

@@ -185,6 +185,8 @@ export const failedToGetConfigInfo = (exitCode: number) => vscode.l10n.t('Failed
 export const failedToParseConfigInfo = (error: any) => vscode.l10n.t('Failed to parse Aspire config info: {0}. Try updating the Aspire CLI with: aspire update', error);
 export const errorGettingConfigInfo = (error: any) => vscode.l10n.t('Error getting Aspire config info: {0}. Try updating the Aspire CLI with: aspire update', error);
 export const configInfoTimedOut = (seconds: number) => vscode.l10n.t('Aspire config info timed out after {0} seconds.', seconds);
+export const outdatedAspireCliWarning = (version: string, cliPath: string, recommendedVersion: string) => vscode.l10n.t('Aspire CLI {0} at {1} has a newer version available for its current channel: {2}.', version, cliPath, recommendedVersion);
+export const updateAspireCliAction = vscode.l10n.t({ message: 'Update Aspire CLI', comment: 'Button label that updates the installed Aspire CLI.' });
 export const invalidLaunchConfiguration = (projectPath: string) => vscode.l10n.t('Invalid launch configuration for {0}.', projectPath);
 export const browserDisplayName = (url: string) => vscode.l10n.t('Browser: {0}', url);
 export const browserLabel = vscode.l10n.t('Browser');

extension/src/services/AppHostStopper.ts

@@ -2,6 +2,7 @@ import * as vscode from 'vscode';
 import { spawnCliProcess, terminateCliProcess } from '../utils/process/cliProcess';
 import { AspireTerminalProvider } from '../utils/AspireTerminalProvider';
 import { getCliPathTargetForUri } from '../utils/cliPathVariables';
+import { reportCliResolvedForOperation } from '../utils/cliOperationResolution';
 
 const maxRetainedStderrLength = 16 * 1024;
 
@@ -11,10 +12,12 @@ export async function stopExternalAppHost(
     cancellationToken: vscode.CancellationToken,
 ): Promise<void> {
 
-    const cliPath = await terminalProvider.getAspireCliExecutablePath(getCliPathTargetForUri(vscode.Uri.file(appHostPath)));
+    const target = getCliPathTargetForUri(vscode.Uri.file(appHostPath));
+    const cliPath = await terminalProvider.getAspireCliExecutablePath(target);
     if (cancellationToken.isCancellationRequested) {
         throw new vscode.CancellationError();
     }
+    reportCliResolvedForOperation(target, cliPath);
 
     await new Promise<void>((resolve, reject) => {
         let settled = false;

extension/src/test/appHostCliRunner.test.ts

@@ -7,6 +7,7 @@ import { AspireCliFailedError } from '../data/appHostCliContracts';
 import { AspireTerminalProvider } from '../utils/AspireTerminalProvider';
 import { workspaceFolderCliPathTarget } from '../utils/cliPathVariables';
 import * as cliModule from '../utils/process/cliProcess';
+import { onDidResolveCliForOperation } from '../utils/cliOperationResolution';
 
 class TestChildProcess extends EventEmitter {
     killed = false;
@@ -150,14 +151,19 @@ suite('data/appHostCliRunner tests', () => {
             });
 
             const runner = new AppHostCliRunner(terminalProvider);
+            const resolutions: string[] = [];
+            const subscription = onDidResolveCliForOperation(resolution => resolutions.push(resolution.cliPath));
             try {
                 await runner.runCliCommand('list pipeline steps', ['do', '--list-steps'], {
                     cliPath: '/repo/tools/aspire',
                 });
 
                 assert.strictEqual(getCliPathStub.called, false);
                 assert.strictEqual(spawnStub.firstCall.args[1], '/repo/tools/aspire');
-            } finally {
+                assert.deepStrictEqual(resolutions, ['/repo/tools/aspire']);
+            }
+            finally {
+                subscription.dispose();
                 runner.dispose();
             }
         });

extension/src/test/appHostDataRepository.test.ts

@@ -15,6 +15,7 @@ import * as configInfoProvider from '../utils/configInfoProvider';
 import { describeIncludeDisabledCommandsCapability, lsJsonStreamCapability } from '../types/configInfo';
 import { errorFetchingAppHosts } from '../loc/strings';
 import { windowCliPathTarget, workspaceFolderCliPathTarget } from '../utils/cliPathVariables';
+import { onDidResolveCliForOperation } from '../utils/cliOperationResolution';
 
 import { removeDirectorySafely } from './testHelpers';
 class TestChildProcess extends EventEmitter {
@@ -2745,6 +2746,31 @@ suite('AppHostDataRepository', () => {
         }
     });
 
+    test('describe reports the exact CLI path for each active workspace folder', async () => {
+        const resolutions: Array<{ folder: string; cliPath: string }> = [];
+        const resolutionSubscription = onDidResolveCliForOperation(resolution => {
+            if (resolution.target.kind === 'workspaceFolder') {
+                resolutions.push({
+                    folder: resolution.target.workspaceFolder.name,
+                    cliPath: resolution.cliPath,
+                });
+            }
+        });
+
+        const context = await startTwoFolderDescribeStreams();
+
+        try {
+            assert.deepStrictEqual(resolutions.sort((left, right) => left.folder.localeCompare(right.folder)), [
+                { folder: 'peer', cliPath: '/cli/peer/aspire' },
+                { folder: 'selected', cliPath: '/cli/selected/aspire' },
+            ]);
+        }
+        finally {
+            resolutionSubscription.dispose();
+            context.dispose();
+        }
+    });
+
     test('working peer CLI does not clear the selected AppHost compatibility error', async () => {
         const context = await startTwoFolderDescribeStreams();
 

extension/src/test/appHostStopper.test.ts

@@ -7,6 +7,7 @@ import * as vscode from 'vscode';
 import { stopExternalAppHost } from '../services/AppHostStopper';
 import type { AspireTerminalProvider } from '../utils/AspireTerminalProvider';
 import { windowCliPathTarget, workspaceFolderCliPathTarget } from '../utils/cliPathVariables';
+import { onDidResolveCliForOperation } from '../utils/cliOperationResolution';
 
 suite('AppHostStopper', () => {
     test('waits for aspire stop to exit successfully', async () => {
@@ -53,6 +54,8 @@ suite('AppHostStopper', () => {
             createEnvironment: () => ({}),
             sendAspireCommandToAspireTerminal: async () => { },
         } as unknown as AspireTerminalProvider;
+        const resolutions: Array<{ target: unknown; cliPath: string }> = [];
+        const subscription = onDidResolveCliForOperation(resolution => resolutions.push(resolution));
 
         try {
             const stopping = stopExternalAppHost(
@@ -62,12 +65,17 @@ suite('AppHostStopper', () => {
             await new Promise(resolve => setImmediate(resolve));
 
             assert.ok(getAspireCliExecutablePathStub.calledOnceWith(workspaceFolderCliPathTarget(folder)));
+            assert.deepStrictEqual(resolutions, [{
+                target: workspaceFolderCliPathTarget(folder),
+                cliPath: '/repo/bin/aspire',
+            }]);
 
             childState.exitCode = 0;
             child.emit('close', 0);
             await stopping;
         }
         finally {
+            subscription.dispose();
             getWorkspaceFolderStub.restore();
             (nodeChildProcess.spawn as sinon.SinonStub).restore();
         }