fix: suppress headless pip refresh prompts

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

Copilot-Session: 3fd1a810-6840-4ac9-ac33-c8a9fda4bfc4

Author: edvilme

src/managers/builtin/pipPackageManager.ts

@@ -90,6 +90,7 @@ export class PipPackageManager implements PackageManager, Disposable {
                         (changes) => {
                             this._onDidChangePackages.fire({ environment, manager: this, changes });
                         },
+                        () => this.fetchPackages(environment, !manageOptions.runHeadless),
                     );
                 } catch (e) {
                     if (e instanceof CancellationError) {
@@ -132,18 +133,22 @@ export class PipPackageManager implements PackageManager, Disposable {
 
     async getPackages(environment: PythonEnvironment, options?: GetPackagesOptions): Promise<Package[] | undefined> {
         if (options?.skipCache || !this.packages.has(environment.envId.id)) {
-            const data = await refreshPipPackages(environment, this.log);
-            if (data === undefined) {
-                return this.packages.get(environment.envId.id);
-            }
-
-            const packages = data.map((pkg) => this.api.createPackageItem(pkg, environment, this));
-            this.packages.set(environment.envId.id, packages);
-            return packages;
+            return this.fetchPackages(environment);
         }
         return this.packages.get(environment.envId.id);
     }
 
+    private async fetchPackages(environment: PythonEnvironment, showErrors = true): Promise<Package[]> {
+        const data = await refreshPipPackages(environment, this.log, { showErrors });
+        if (data === undefined) {
+            return this.packages.get(environment.envId.id) ?? [];
+        }
+
+        const packages = data.map((pkg) => this.api.createPackageItem(pkg, environment, this));
+        this.packages.set(environment.envId.id, packages);
+        return packages;
+    }
+
     async getVersion(environment: PythonEnvironment): Promise<Pep440Version | undefined> {
         try {
             const useUv = await shouldUseUv(this.log, environment.environmentPath.fsPath);

src/managers/builtin/utils.ts

@@ -218,7 +218,7 @@ async function execPipList(environment: PythonEnvironment, log?: LogOutputChanne
 export async function refreshPipPackages(
     environment: PythonEnvironment,
     log?: LogOutputChannel,
-    options?: { showProgress: boolean },
+    options?: { showProgress?: boolean; showErrors?: boolean },
 ): Promise<PipPackage[] | undefined> {
     let data: string;
     try {
@@ -238,7 +238,9 @@ export async function refreshPipPackages(
         return parsePipListJson(data, log);
     } catch (e) {
         log?.error('Error refreshing packages', e);
-        showErrorMessageWithLogs(SysManagerStrings.packageRefreshError, log);
+        if (options?.showErrors !== false) {
+            showErrorMessageWithLogs(SysManagerStrings.packageRefreshError, log);
+        }
         return undefined;
     }
 }

src/managers/common/packageChanges.ts

@@ -9,6 +9,8 @@ import { normalizePackageName } from '../builtin/utils';
  */
 export type PackageChangesCallback = (changes: { kind: PackageChangeKind; pkg: Package }[]) => void;
 
+type PackageFetcher = () => Promise<Package[] | undefined>;
+
 /**
  * Computes the list of package changes between a before and after snapshot.
  * @param before - The previous list of packages.
@@ -41,15 +43,22 @@ export function getPackageChanges(before: Package[], after: Package[]): { kind:
  * This function calls {@link PackageManager.getPackages} with `skipCache` to fetch
  * the latest snapshot. The caller should pass the previously cached packages
  * so changes can be computed against the pre-refresh state.
+ *
+ * @param packageManager The package manager whose packages changed.
+ * @param environment The environment whose packages should be refreshed.
+ * @param before The package snapshot from before the operation.
+ * @param onChanges Callback invoked when package changes are detected.
+ * @param fetchPackages Optional internal fetcher for operation-specific refresh behavior.
  */
 export async function updatePackagesAndNotify(
     packageManager: PackageManager,
     environment: PythonEnvironment,
     before: Package[] | undefined,
     onChanges: PackageChangesCallback,
+    fetchPackages?: PackageFetcher,
 ): Promise<Package[] | undefined> {
     const [after, afterDirectDependenciesNames] = await Promise.all([
-        packageManager.getPackages(environment, { skipCache: true }).then((pkgs) => pkgs ?? []),
+        (fetchPackages?.() ?? packageManager.getPackages(environment, { skipCache: true })).then((pkgs) => pkgs ?? []),
         // Handle transitive dependencies (best-effort, don't break package refresh on failure)
         packageManager.getDirectPackageNames?.(environment).catch(() => undefined),
     ]);

src/test/managers/builtin/pipPackageRefresh.unit.test.ts

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import { LogOutputChannel, Uri } from 'vscode';
+import { PythonEnvironment } from '../../../api';
+import * as errorUtils from '../../../common/errors/utils';
+import * as helpers from '../../../managers/builtin/helpers';
+import { refreshPipPackages } from '../../../managers/builtin/utils';
+
+suite('Pip package refresh', () => {
+    let environment: PythonEnvironment;
+    let log: LogOutputChannel;
+    let showErrorMessageWithLogsStub: sinon.SinonStub;
+
+    setup(() => {
+        environment = {
+            environmentPath: Uri.file('.'),
+            execInfo: {
+                run: {
+                    executable: 'python',
+                },
+            },
+        } as PythonEnvironment;
+        log = {
+            error: sinon.stub(),
+            info: sinon.stub(),
+        } as unknown as LogOutputChannel;
+
+        sinon.stub(helpers, 'shouldUseUv').resolves(false);
+        sinon.stub(helpers, 'runPython').rejects(new Error('pip list failed'));
+        showErrorMessageWithLogsStub = sinon.stub(errorUtils, 'showErrorMessageWithLogs').resolves();
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('shows an error when an interactive refresh fails', async () => {
+        const result = await refreshPipPackages(environment, log);
+
+        assert.strictEqual(result, undefined);
+        assert.ok(showErrorMessageWithLogsStub.calledOnce);
+    });
+
+    test('does not show an error when a headless refresh fails', async () => {
+        const result = await refreshPipPackages(environment, log, { showErrors: false });
+
+        assert.strictEqual(result, undefined);
+        assert.ok(showErrorMessageWithLogsStub.notCalled);
+    });
+});

src/test/managers/common/packageChanges.unit.test.ts

@@ -127,6 +127,24 @@ suite('packageChanges', () => {
             assert.strictEqual(changes[0].kind, PackageChangeKind.add);
         });
 
+        test('uses an operation-specific package fetcher when provided', async () => {
+            const fetched = [{ name: 'requests', version: '2.31.0' } as Package];
+            const fetchPackages = sinon.stub().resolves(fetched);
+            const onChanges = sinon.stub();
+
+            const result = await updatePackagesAndNotify(
+                packageManager,
+                environment,
+                undefined,
+                onChanges,
+                fetchPackages,
+            );
+
+            assert.deepStrictEqual(result, fetched);
+            assert.ok(fetchPackages.calledOnce);
+            assert.ok(getPackagesStub.notCalled);
+        });
+
         test('does not fire callback when nothing changed', async () => {
             const pkgs = [{ name: 'requests', version: '2.31.0' } as Package];
             getPackagesStub.resolves(pkgs);