Add progress and cancellation support to the packages pane (#12553)

This PR adds progress and cancellation support to the package pane
actions.

The two areas of attention to support were:
- Dismissing any quick pick menus
- Clicking the Cancel button in the withProgress notification

There were four distinct actions to cancel:
- session.execution
- session.callMethod
- HTTP requests
- spawning processes in the terminal

### Release Notes

#### New Features

- Adds Progress/Cancellation support to packages pane actions.

#### Bug Fixes

- N/A

### QA Notes

I testing this by adding a 4 second sleep to `.ps.rpc.pkg_list` in
ark...

I also added a sleep to the commands used to perform the actual package
management. Something like this: `tryCatch({Sys.sleep(4); <the actual
command>}, interrupt = function(e) NULL)`

You could then use the install, update, or uninstall commands to kick
off the request. For update/uninstall it is when the quick pick is first
shown it'll refresh (and you can press ESC to cancel it), for install it
is when actually peforming a search. I did the same for the version
picker call.

When actually performing the package management functions, we use the
notification service's withProgress function, and there is a cancel
button that should also work. We usually end package management
functions with a call to refresh, so you could, using that 4 second
delay, mutate the package and cancel during the refresh stage, and see
nothing is being updated to verify that the cancellation took effect.
Then manually click refresh and see ~4 seconds later that it works.

With the above `tryCatch` change with a sleep you can also introduce
enough time to interrupt the package management call.

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: bricestacey

extensions/positron-python/src/client/positron/packages/condaPackageManager.ts

@@ -9,7 +9,7 @@ import { IProcessServiceFactory } from '../../common/process/types';
 import { ITerminalServiceFactory } from '../../common/terminal/types';
 import { IComponentAdapter, ICondaService } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
-import { IPackageManager, MessageEmitter, PackageKernel } from './types';
+import { IPackageManager, MessageEmitter, PackageSession } from './types';
 
 /** Package info returned by `conda search --json` */
 interface CondaPackageInfo {
@@ -64,11 +64,11 @@ export class CondaPackageManager implements IPackageManager {
         private readonly _pythonPath: string,
         _messageEmitter: MessageEmitter,
         private readonly _serviceContainer: IServiceContainer,
-        private readonly _kernel: PackageKernel,
+        private readonly _session: PackageSession,
     ) {}
 
-    async getPackages(): Promise<positron.LanguageRuntimePackage[]> {
-        return this._kernel.callMethod('getPackagesInstalled');
+    async getPackages(token?: vscode.CancellationToken): Promise<positron.LanguageRuntimePackage[]> {
+        return this._callMethod<positron.LanguageRuntimePackage[]>('getPackagesInstalled', token);
     }
 
     /**
@@ -83,54 +83,70 @@ export class CondaPackageManager implements IPackageManager {
         }
     }
 
-    async installPackages(packages: positron.PackageSpec[]): Promise<void> {
+    async installPackages(packages: positron.PackageSpec[], token?: vscode.CancellationToken): Promise<void> {
         if (packages.length === 0) {
             return;
         }
 
+        if (token?.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+
         await this._ensureConda();
 
         const packageSpecs = this._formatPackageSpecs(packages);
         const envPrefix = await this._getEnvironmentPrefix();
         const args = ['install', '--prefix', envPrefix, '-y', ...packageSpecs];
 
-        await this._executeCondaInTerminal(args);
+        await this._executeCondaInTerminal(args, token);
     }
 
-    async uninstallPackages(packages: string[]): Promise<void> {
+    async uninstallPackages(packages: string[], token?: vscode.CancellationToken): Promise<void> {
         if (packages.length === 0) {
             return;
         }
 
+        if (token?.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+
         await this._ensureConda();
 
         const envPrefix = await this._getEnvironmentPrefix();
         const args = ['remove', '--prefix', envPrefix, '-y', ...packages];
 
-        await this._executeCondaInTerminal(args);
+        await this._executeCondaInTerminal(args, token);
     }
 
-    async updatePackages(packages: positron.PackageSpec[]): Promise<void> {
+    async updatePackages(packages: positron.PackageSpec[], token?: vscode.CancellationToken): Promise<void> {
         // Use installPackages() because conda update doesn't support version specs.
         // conda install will update (or downgrade) to the specified version.
-        return this.installPackages(packages);
+        return this.installPackages(packages, token);
     }
 
-    async updateAllPackages(): Promise<void> {
+    async updateAllPackages(token?: vscode.CancellationToken): Promise<void> {
+        if (token?.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+
         await this._ensureConda();
 
         const envPrefix = await this._getEnvironmentPrefix();
         const args = ['update', '--prefix', envPrefix, '--all', '-y'];
 
-        await this._executeCondaInTerminal(args);
+        await this._executeCondaInTerminal(args, token);
     }
 
-    async searchPackages(query: string): Promise<positron.LanguageRuntimePackage[]> {
+    async searchPackages(query: string, token?: vscode.CancellationToken): Promise<positron.LanguageRuntimePackage[]> {
+        if (token?.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+
         await this._ensureConda();
 
         try {
             // Use wildcard pattern for partial matching
-            const result = await this._executeCondaWithOutput(['search', `*${query}*`, '--json']);
+            const result = await this._executeCondaWithOutput(['search', `*${query}*`, '--json'], token);
             const json = parseCondaSearchResult(result);
 
             // Return unique package names with the latest version (sorted by timestamp)
@@ -144,17 +160,24 @@ export class CondaPackageManager implements IPackageManager {
                     version: latest.version,
                 };
             });
-        } catch {
+        } catch (e) {
+            if (e instanceof vscode.CancellationError) {
+                throw e;
+            }
             // Return empty array if search fails (e.g., no matches)
             return [];
         }
     }
 
-    async searchPackageVersions(name: string): Promise<string[]> {
+    async searchPackageVersions(name: string, token?: vscode.CancellationToken): Promise<string[]> {
+        if (token?.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+
         await this._ensureConda();
 
         try {
-            const result = await this._executeCondaWithOutput(['search', name, '--json']);
+            const result = await this._executeCondaWithOutput(['search', name, '--json'], token);
             const json = parseCondaSearchResult(result);
 
             // Get all unique versions for this package
@@ -167,7 +190,10 @@ export class CondaPackageManager implements IPackageManager {
             const sorted = [...packageInfo].sort((a, b) => b.timestamp - a.timestamp);
             const versions = [...new Set(sorted.map((p) => p.version))];
             return versions;
-        } catch {
+        } catch (e) {
+            if (e instanceof vscode.CancellationError) {
+                throw e;
+            }
             return [];
         }
     }
@@ -224,31 +250,74 @@ export class CondaPackageManager implements IPackageManager {
 
     /**
      * Execute a conda command in the terminal (visible to user).
+     * @param args The conda arguments to execute
+     * @param token Optional cancellation token
      */
-    private async _executeCondaInTerminal(args: string[]): Promise<void> {
+    private async _executeCondaInTerminal(args: string[], token?: vscode.CancellationToken): Promise<void> {
         const condaFile = await this._getCondaFile();
         const terminalService = this._serviceContainer
             .get<ITerminalServiceFactory>(ITerminalServiceFactory)
             .getTerminalService({});
         // Ensure terminal is created and ready before sending command
         await terminalService.show();
-        const tokenSource = new vscode.CancellationTokenSource();
+
+        const disposable = token?.onCancellationRequested(async () => {
+            // Send Ctrl+C to interrupt the running command
+            await terminalService.sendText('\x03');
+        });
+
         try {
-            await terminalService.sendCommand(condaFile, args, tokenSource.token);
+            await terminalService.sendCommand(condaFile, args, token);
         } finally {
-            tokenSource.dispose();
+            disposable?.dispose();
         }
     }
 
     /**
      * Execute a conda command and capture stdout.
      */
-    private async _executeCondaWithOutput(args: string[]): Promise<string> {
+    private async _executeCondaWithOutput(args: string[], token?: vscode.CancellationToken): Promise<string> {
         const condaFile = await this._getCondaFile();
         const processServiceFactory = this._serviceContainer.get<IProcessServiceFactory>(IProcessServiceFactory);
         const processService = await processServiceFactory.create();
 
-        const result = await processService.exec(condaFile, args);
+        const result = await processService.exec(condaFile, args, { token });
         return result.stdout;
     }
+
+    /**
+     * Call a kernel method with cancellation support.
+     * If the token is cancelled, interrupts the kernel (if supported).
+     */
+    private async _callMethod<T>(method: string, token?: vscode.CancellationToken, ...args: unknown[]): Promise<T> {
+        if (token?.isCancellationRequested) {
+            throw new vscode.CancellationError();
+        }
+
+        const resultPromise = this._session.callMethod(method, ...args) as Promise<T>;
+
+        // If no token provided, just return the method result
+        if (!token) {
+            return resultPromise;
+        }
+
+        // Wrap callMethod promise with cancellation handling
+        return new Promise<T>((resolve, reject) => {
+            const cancelDisp = token.onCancellationRequested(async () => {
+                // Interrupt the session via the runtime service
+                await positron.runtime.interruptSession(this._session.metadata.sessionId);
+                reject(new vscode.CancellationError());
+            });
+
+            resultPromise
+                .then((result) => {
+                    cancelDisp.dispose();
+                    resolve(result);
+                })
+                .catch((err) => {
+                    cancelDisp.dispose();
+                    reject(err);
+                });
+        });
+    }
 }

extensions/positron-python/src/client/positron/packages/packageManagerFactory.ts

@@ -7,7 +7,7 @@ import { IServiceContainer } from '../../ioc/types';
 import { EnvironmentType } from '../../pythonEnvironments/info';
 import { CondaPackageManager } from './condaPackageManager';
 import { PipPackageManager } from './pipPackageManager';
-import { IPackageManager, MessageEmitter, PackageKernel } from './types';
+import { IPackageManager, MessageEmitter, PackageSession } from './types';
 import { UvPackageManager } from './uvPackageManager';
 
 /**
@@ -24,30 +24,30 @@ export class PackageManagerFactory {
      * @param pythonPath The path to the Python interpreter
      * @param messageEmitter The emitter for runtime messages
      * @param serviceContainer The service container for dependency injection
-     * @param kernel The kernel for RPC-based package listing
+     * @param session The session for RPC-based package operations
      * @returns The appropriate package manager for the environment
      */
     static create(
         runtimeSource: EnvironmentType | string | undefined,
         pythonPath: string,
         messageEmitter: MessageEmitter,
         serviceContainer: IServiceContainer,
-        kernel: PackageKernel,
+        session: PackageSession,
     ): IPackageManager {
         if (runtimeSource?.toLowerCase() === EnvironmentType.Uv.toLowerCase()) {
-            return new UvPackageManager(pythonPath, messageEmitter, serviceContainer, kernel);
+            return new UvPackageManager(pythonPath, messageEmitter, serviceContainer, session);
         }
 
         if (runtimeSource?.toLowerCase() === EnvironmentType.Conda.toLowerCase()) {
-            return new CondaPackageManager(pythonPath, messageEmitter, serviceContainer, kernel);
+            return new CondaPackageManager(pythonPath, messageEmitter, serviceContainer, session);
         }
 
         if (runtimeSource?.toLowerCase() === EnvironmentType.Venv.toLowerCase()) {
-            return new PipPackageManager(pythonPath, messageEmitter, serviceContainer, kernel);
+            return new PipPackageManager(pythonPath, messageEmitter, serviceContainer, session);
         }
 
         // Default to PipPackageManager for all other environment types
         // This includes Pyenv, Global, System, VirtualEnv, etc.
-        return new PipPackageManager(pythonPath, messageEmitter, serviceContainer, kernel);
+        return new PipPackageManager(pythonPath, messageEmitter, serviceContainer, session);
     }
 }