Add new command to kick off (refresh) interpreter discovery (#7762)

Addresses #4269

This PR adds a new command
`workbench.action.language.runtime.discoverAllRuntimes` to kick off
runtime discovery. I just have it accessible from the command palette
(no keybindings, no UI), which is a good option for now, I think. I put
this in with other commands in `languageRuntimeActions.ts`, although I
do want to highlight that all the other commands in there apply to a
_single_ interpreter, not to all of them as a whole.

This command can only add new interpreters. If the user _removes_ an
interpreter while Positron is running, this new command does not get rid
of it because the runtime is still registered; discovery can only add
runtimes. We could totally clear all the registered runtimes but that
seems pretty destructive, and removing runtimes hasn't been a big
concern so far. Thoughts?

### Release Notes

#### New Features

- Adds new command "Interpreter: Discover All Interpreters" to kick off
interpreter discovery, for example if you have just made a new Python
environment that Positron doesn't know about yet

#### Bug Fixes

- N/A


### QA Notes

I think the easiest way to see if this is doing what we expect is to
watch the output channel for either the R or Python Language Pack and
execute the command. You'll see all the logging for interpreter
discovery go by each time you do so. Alternatively, you could:

- Look at all your interpreter options in Positron
- Add a new one via the regular terminal (for example, a new rig
version)
- Look at all your interpreter choices and see that your new one is not
there yet
- Execute the command
- Look at all your interpreter choices and see that now the new one is
there

---------

Signed-off-by: Julia Silge <[email protected]>

Author: juliasilge

extensions/positron-python/src/client/positron/discoverer.ts

@@ -48,6 +48,7 @@ export async function* pythonRuntimeDiscoverer(
         traceInfo(`pythonRuntimeDiscoverer: recommended interpreter: ${recommendedInterpreter?.path}`);
 
         // Discover Python interpreters
+        await interpreterService.triggerRefresh().ignoreErrors();
         let interpreters = interpreterService.getInterpreters();
 
         traceInfo(`pythonRuntimeDiscoverer: discovered ${interpreters.length} Python interpreters`);

src/vs/workbench/contrib/languageRuntime/browser/languageRuntimeActions.ts

@@ -44,8 +44,8 @@ export const LANGUAGE_RUNTIME_RESTART_ACTIVE_SESSION_ID = 'workbench.action.lang
 export const LANGUAGE_RUNTIME_RENAME_SESSION_ID = 'workbench.action.language.runtime.renameSession';
 export const LANGUAGE_RUNTIME_RENAME_ACTIVE_SESSION_ID = 'workbench.action.language.runtime.renameActiveSession';
 export const LANGUAGE_RUNTIME_DUPLICATE_ACTIVE_SESSION_ID = 'workbench.action.language.runtime.duplicateActiveSession';
-
 export const LANGUAGE_RUNTIME_SELECT_RUNTIME_ID = 'workbench.action.languageRuntime.selectRuntime';
+export const LANGUAGE_RUNTIME_DISCOVER_RUNTIMES_ID = 'workbench.action.language.runtime.discoverAllRuntimes';
 
 /**
  * Helper function that askses the user to select a language from the list of registered language
@@ -967,6 +967,29 @@ export function registerLanguageRuntimeActions() {
 		}
 	});
 
+	registerAction2(class extends Action2 {
+		/**
+		 * Constructor.
+		 */
+		constructor() {
+			super({
+				id: LANGUAGE_RUNTIME_DISCOVER_RUNTIMES_ID,
+				title: nls.localize2('workbench.action.language.runtime.discoverAllRuntimes', "Discover All Interpreters"),
+				f1: true,
+				category
+			});
+		}
+
+		async run(accessor: ServicesAccessor) {
+			// Access service.
+			const runtimeStartupService = accessor.get(IRuntimeStartupService);
+
+			// Kick off discovery.
+			runtimeStartupService.rediscoverAllRuntimes();
+		}
+	});
+
+
 	/**
 	 * Arguments passed to the Execute Code actions.
 	 */

src/vs/workbench/services/positronHistory/test/common/executionHistoryService.test.ts

@@ -319,6 +319,10 @@ class TestRuntimeStartupService implements IRuntimeStartupService {
 		// No-op in test implementation
 	}
 
+	public async rediscoverAllRuntimes() {
+		// No-op in test implementation
+	}
+
 	registerRuntimeManager(_manager: IRuntimeManager): IDisposable {
 		return Disposable.None;
 	}

src/vs/workbench/services/runtimeStartup/common/runtimeStartup.ts

@@ -637,6 +637,52 @@ export class RuntimeStartupService extends Disposable implements IRuntimeStartup
 		};
 	}
 
+	/**
+	 * Kicks off a refresh of runtime discovery, after initial discovery.
+	 */
+	public async rediscoverAllRuntimes(): Promise<void> {
+
+		// If we haven't completed discovery once already, don't do anything.
+		if (this._startupPhase !== RuntimeStartupPhase.Complete) {
+			this._logService.warn('[Runtime startup] Runtime discovery refresh called before initial discovery is complete.');
+			return;
+		}
+
+		// Set up event to notify when runtimes are added.
+		const oldRuntimes = this._languageRuntimeService.registeredRuntimes;
+		this._register(
+			this._languageRuntimeService.onDidChangeRuntimeStartupPhase(
+				(phase) => {
+					if (phase === RuntimeStartupPhase.Complete) {
+						const newRuntimes = this._languageRuntimeService.registeredRuntimes;
+						const addedRuntimes = newRuntimes.filter(newRuntime => {
+							return !oldRuntimes.some(oldRuntime => {
+								return oldRuntime.runtimeId === newRuntime.runtimeId;
+							});
+						});
+
+						// If any runtimes were added, show a notification.
+						if (addedRuntimes.length > 0) {
+							this._notificationService.info(nls.localize('positron.runtimeStartupService.runtimesAddedMessage',
+								"Found {0} new interpreter{1}: {2}.",
+								addedRuntimes.length,
+								addedRuntimes.length > 1 ? 's' : '',
+								addedRuntimes.map(runtime => { return runtime.runtimeName; }).join(', ')));
+						}
+					}
+				}
+			)
+		);
+
+		this._logService.debug('[Runtime startup] Refreshing runtime discovery.');
+		this._discoveryCompleteByExtHostId.forEach((_, extHostId, m) => {
+			m.set(extHostId, false);
+		});
+
+		this.discoverAllRuntimes();
+
+	}
+
 	/**
 	 * Runs as an event handler when the active runtime changes.
 	 *
@@ -693,7 +739,7 @@ export class RuntimeStartupService extends Disposable implements IRuntimeStartup
 	}
 
 	/**
-	 * Activates all of the extensions that provides language runtimes, then
+	 * Activates all of the extensions that provide language runtimes, then
 	 * enters the discovery phase, in which each extension is asked to supply
 	 * its language runtime metadata.
 	 */
@@ -739,7 +785,7 @@ export class RuntimeStartupService extends Disposable implements IRuntimeStartup
 		// language runtime providers.
 		this.setStartupPhase(RuntimeStartupPhase.Discovering);
 
-		// Ask each extension to provide its language runtime metadata.
+		// Ask each extension host to provide its language runtime metadata.
 		for (const manager of this._runtimeManagers) {
 			manager.discoverAllRuntimes(disabledLanguages);
 		}

src/vs/workbench/services/runtimeStartup/common/runtimeStartupService.ts

@@ -124,6 +124,11 @@ export interface IRuntimeStartupService {
 	 */
 	completeDiscovery(id: number): void;
 
+	/**
+	 * Kick off a user-driven refresh of runtime discovery, after the initial discovery.
+	 */
+	rediscoverAllRuntimes(): Promise<void>;
+
 	/**
 	 * Get the sessions that were (or will be) restored into this window.
 	 */

src/vs/workbench/services/runtimeStartup/test/common/testRuntimeStartupService.ts

@@ -110,6 +110,13 @@ export class TestRuntimeStartupService implements IRuntimeStartupService {
 		// No-op in test implementation
 	}
 
+	/**
+	 * {@inheritDoc}
+	 */
+	public async rediscoverAllRuntimes() {
+		// No-op in test implementation
+	}
+
 	/**
 	 * {@inheritDoc}
 	 */