Address package manager review feedback

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

Copilot-Session: 5aba47cf-0b43-48b9-bc22-75e625da70e8

Author: edvilme

.github/instructions/testing-workflow.instructions.md

@@ -603,6 +603,7 @@ envConfig.inspect
 - Create shared mock helpers (e.g., `createMockLogOutputChannel()`) instead of duplicating mock setup across multiple test files (1)
 - Use `sinon.useFakeTimers()` with `clock.tickAsync()` instead of `await new Promise(resolve => setTimeout(resolve, ms))` for debounce/timeout handling - eliminates flakiness and speeds up tests significantly (1)
 - Always compile tests (`npm run compile-tests`) before running them after adding new test cases - test counts will be wrong if running against stale compiled output (1)
+- **Delete stale compiled test output after removing a test source file**: `compile-tests` does not remove the corresponding file under `out/`, so local unit or integration runs may execute a deleted test until that artifact is cleaned (1)
 - Never create "documentation tests" that just `assert.ok(true)` — if mocking limitations prevent testing, either test a different layer that IS mockable, or skip the test entirely with a clear explanation (1)
 - When stubbing vscode APIs in tests via wrapper modules (e.g., `workspaceApis`), the production code must also use those wrappers — sinon cannot stub properties directly on the vscode namespace like `workspace.workspaceFolders`, so both production and test code must reference the same stubbable wrapper functions (4)
 - **Before writing tests**, check if the function under test calls VS Code APIs directly (e.g., `commands.executeCommand`, `window.createTreeView`, `workspace.getConfiguration`). If so, FIRST update the production code to use wrapper functions from `src/common/*.apis.ts` (create the wrapper if it doesn't exist), THEN write tests that stub those wrappers. This prevents CI failures where sinon cannot stub the vscode namespace (4)

src/managers/base/commands/packageManagerCommand.ts

@@ -28,7 +28,7 @@ export abstract class PackageManagerCommand {
     protected pythonExecutable: string;
     protected cwd?: string;
     protected log?: LogOutputChannel;
-    protected timeout: number = 300000;
+    protected timeout: number | undefined;
     protected config?: WorkspaceConfiguration;
 
     constructor(options: CommandConstructorOptions) {

src/managers/builtin/commands/availableVersions.ts

@@ -2,26 +2,47 @@ import type { Pep440Version } from '@renovatebot/pep440';
 import { AvailableVersionsCommand, type AvailableVersionsExecuteArgs } from '../../base/commands/index';
 import { runPython, runUV } from '../helpers';
 
-export interface PipAvailableVersionsExecuteArgs extends AvailableVersionsExecuteArgs {
-    useJson?: boolean;
+function parseVersionsJson(output: string, tool: 'pip' | 'uv'): string[] {
+    const match = output.match(/{[\s\S]*}/);
+    if (!match) {
+        throw new Error(`Unable to find package version JSON in ${tool} output.`);
+    }
+
+    const parsed: unknown = JSON.parse(match[0]);
+    if (
+        typeof parsed !== 'object' ||
+        parsed === null ||
+        !('versions' in parsed) ||
+        !Array.isArray(parsed.versions) ||
+        !parsed.versions.every((version) => typeof version === 'string')
+    ) {
+        throw new Error(`Unexpected package version JSON from ${tool}.`);
+    }
+
+    return parsed.versions;
 }
 
 /**
  * Pip available versions command.
- * Parsed command: `python -m pip index versions <package> [--json] --python-version <version>`
+ * Parsed command: `python -m pip index versions <package> --json --disable-pip-version-check --python-version <version>`
  * Official documentation: https://pip.pypa.io/en/stable/cli/pip_index/
  */
 export class PipAvailableVersionsCommand extends AvailableVersionsCommand {
-    protected buildCommand(executeArgs: PipAvailableVersionsExecuteArgs): string[] {
-        const args = ['-m', 'pip', 'index', 'versions', executeArgs.packageName];
-        if (executeArgs.useJson !== false) {
-            args.push('--json');
-        }
-        args.push('--python-version', executeArgs.pythonVersion);
-        return args;
+    protected buildCommand(executeArgs: AvailableVersionsExecuteArgs): string[] {
+        return [
+            '-m',
+            'pip',
+            'index',
+            'versions',
+            executeArgs.packageName,
+            '--json',
+            '--disable-pip-version-check',
+            '--python-version',
+            executeArgs.pythonVersion,
+        ];
     }
 
-    async execute(executeArgs: PipAvailableVersionsExecuteArgs): Promise<Pep440Version[]> {
+    async execute(executeArgs: AvailableVersionsExecuteArgs): Promise<Pep440Version[]> {
         const output = await runPython(
             this.pythonExecutable,
             this.buildCommand(executeArgs),
@@ -30,25 +51,41 @@ export class PipAvailableVersionsCommand extends AvailableVersionsCommand {
             executeArgs.cancellationToken,
             this.timeout,
         );
-        if (executeArgs.useJson === false) {
-            const match = output.match(/^Available versions:\s*(.+)$/im);
-            return this.parseVersions(match?.[1].split(',') ?? [], executeArgs.includePrerelease);
-        }
+        return this.parseVersions(parseVersionsJson(output, 'pip'), executeArgs.includePrerelease);
+    }
+}
 
-        const match = output.match(/{[\s\S]*}/);
-        if (!match) {
-            return [];
-        }
+/**
+ * Pip available versions command for Pip 21.2 through 25.0, before JSON output was supported.
+ */
+export class PipAvailableVersionsTextCommand extends AvailableVersionsCommand {
+    protected buildCommand(executeArgs: AvailableVersionsExecuteArgs): string[] {
+        return [
+            '-m',
+            'pip',
+            'index',
+            'versions',
+            executeArgs.packageName,
+            '--disable-pip-version-check',
+            '--python-version',
+            executeArgs.pythonVersion,
+        ];
+    }
 
-        try {
-            const parsed = JSON.parse(match[0]) as { versions?: string[] };
-            return this.parseVersions(
-                Array.isArray(parsed.versions) ? parsed.versions : [],
-                executeArgs.includePrerelease,
-            );
-        } catch {
-            return [];
+    async execute(executeArgs: AvailableVersionsExecuteArgs): Promise<Pep440Version[]> {
+        const output = await runPython(
+            this.pythonExecutable,
+            this.buildCommand(executeArgs),
+            undefined,
+            this.log,
+            executeArgs.cancellationToken,
+            this.timeout,
+        );
+        const match = output.match(/^Available versions:\s*(.+)$/im);
+        if (!match) {
+            throw new Error('Unable to parse available package versions from pip output.');
         }
+        return this.parseVersions(match[1].split(','), executeArgs.includePrerelease);
     }
 }
 
@@ -80,19 +117,6 @@ export class UvAvailableVersionsCommand extends AvailableVersionsCommand {
             executeArgs.cancellationToken,
             this.timeout,
         );
-        const match = output.match(/{[\s\S]*}/);
-        if (!match) {
-            return [];
-        }
-
-        try {
-            const parsed = JSON.parse(match[0]) as { versions?: string[] };
-            return this.parseVersions(
-                Array.isArray(parsed.versions) ? parsed.versions : [],
-                executeArgs.includePrerelease,
-            );
-        } catch {
-            return [];
-        }
+        return this.parseVersions(parseVersionsJson(output, 'uv'), executeArgs.includePrerelease);
     }
 }

src/managers/builtin/commands/index.ts

@@ -1,4 +1,8 @@
-export { PipAvailableVersionsCommand, UvAvailableVersionsCommand } from './availableVersions';
+export {
+    PipAvailableVersionsCommand,
+    PipAvailableVersionsTextCommand,
+    UvAvailableVersionsCommand,
+} from './availableVersions';
 export { PipInstallCommand, UvInstallCommand } from './install';
 export { PipListCommand, UvListCommand } from './list';
 export { PipListDirectNamesCommand, UvListDirectNamesCommand } from './listDirectNames';

src/managers/builtin/commands/listDirectNames.ts

@@ -4,12 +4,12 @@ import { runPython, runUV } from '../helpers';
 
 /**
  * Pip list direct names command.
- * Parsed command: `python -m pip list --format=json --not-required`
+ * Parsed command: `python -m pip list --format=json --not-required --disable-pip-version-check`
  * Official documentation: https://pip.pypa.io/en/stable/cli/pip_list/
  */
 export class PipListDirectNamesCommand extends ListDirectNamesCommand {
     protected buildCommand(): string[] {
-        return ['-m', 'pip', 'list', '--format=json', '--not-required'];
+        return ['-m', 'pip', 'list', '--format=json', '--not-required', '--disable-pip-version-check'];
     }
 
     async execute(executeArgs?: BaseExecuteArgs): Promise<Set<string>> {

src/managers/builtin/pipPackageManager.ts

@@ -11,7 +11,6 @@ import {
     MarkdownString,
     ProgressLocation,
     ThemeIcon,
-    window,
 } from 'vscode';
 import {
     DidChangePackagesEventArgs,
@@ -24,13 +23,14 @@ import {
     PythonEnvironment,
     PythonEnvironmentApi,
 } from '../../api';
-import { withProgress } from '../../common/window.apis';
+import { showErrorMessage, withProgress } from '../../common/window.apis';
 import { CommandConstructorOptions } from '../base/commands/index';
 import { updatePackagesAndNotify } from '../common/packageChanges';
 import { parsePackageSpecs } from '../common/packageUtils';
 import { createPipOrUvCommand } from './commands/factory';
 import {
     PipAvailableVersionsCommand,
+    PipAvailableVersionsTextCommand,
     PipInstallCommand,
     PipListCommand,
     PipListDirectNamesCommand,
@@ -145,7 +145,7 @@ export class PipPackageManager implements PackageManager, Disposable {
                 this.log.error('Error managing packages', e);
                 if (!options.runHeadless) {
                     setImmediate(async () => {
-                        const result = await window.showErrorMessage('Error managing packages', 'View Output');
+                        const result = await showErrorMessage('Error managing packages', 'View Output');
                         if (result === 'View Output') {
                             this.log.show();
                         }
@@ -175,7 +175,7 @@ export class PipPackageManager implements PackageManager, Disposable {
     }
 
     async refresh(environment: PythonEnvironment): Promise<void> {
-        await window.withProgress(
+        await withProgress(
             {
                 location: ProgressLocation.Window,
                 title: 'Refreshing packages',
@@ -226,7 +226,7 @@ export class PipPackageManager implements PackageManager, Disposable {
             this.log.error('Error refreshing packages', error);
             if (showErrors) {
                 setImmediate(async () => {
-                    const result = await window.showErrorMessage('Error refreshing packages', 'View Output');
+                    const result = await showErrorMessage('Error refreshing packages', 'View Output');
                     if (result === 'View Output') {
                         this.log.show();
                     }
@@ -263,11 +263,11 @@ export class PipPackageManager implements PackageManager, Disposable {
             throw new Error(`Python executable is unavailable for environment: ${environment.envId.id}`);
         }
 
-            // Normalize versions like '3.13.1.final.0' (Python's sys.version_info format) to '3.13.1'
-            // before parsing, since pep440 only accepts valid PEP 440 version strings.
-            const versionMatch = (environment.version ?? '').match(/^(\d+(?:\.\d+)*)/);
-            const normalizedVersion = versionMatch?.[1] ?? '';
-            const baseVersion = parse(normalizedVersion)?.base_version;
+        // Normalize versions like '3.13.1.final.0' (Python's sys.version_info format) to '3.13.1'
+        // before parsing, since pep440 only accepts valid PEP 440 version strings.
+        const versionMatch = (environment.version ?? '').match(/^(\d+(?:\.\d+)*)/);
+        const normalizedVersion = versionMatch?.[1] ?? '';
+        const baseVersion = parse(normalizedVersion)?.base_version;
         if (!baseVersion) {
             throw new Error(`Python version is unavailable for environment: ${environment.envId.id}`);
         }
@@ -280,7 +280,7 @@ export class PipPackageManager implements PackageManager, Disposable {
                 UvAvailableVersionsCommand,
             );
 
-            // For pip < 21.2.0, check version first
+        // For pip < 21.2.0, check version first.
         if (availableVersionsCmd instanceof PipAvailableVersionsCommand) {
             const pipVersion = await this.getVersion(environment);
             if (!pipVersion) {
@@ -291,12 +291,17 @@ export class PipPackageManager implements PackageManager, Disposable {
                     `Package version lookup requires pip 21.2 or newer; the environment has pip ${pipVersion.public}.`,
                 );
             }
-            const versions = await availableVersionsCmd.execute({
-                packageName,
-                pythonVersion: baseVersion,
-                useJson: compare(pipVersion.public, '25.1') >= 0,
-            });
-            return versions.sort((a, b) => compare(b.public, a.public));
+            if (compare(pipVersion.public, '25.1') >= 0) {
+                const versions = await availableVersionsCmd.execute({
+                    packageName,
+                    pythonVersion: baseVersion,
+                });
+                return versions.sort((a, b) => compare(b.public, a.public));
+            }
+
+            const textCommand = new PipAvailableVersionsTextCommand({ pythonExecutable, log: this.log });
+            const textVersions = await textCommand.execute({ packageName, pythonVersion: baseVersion });
+            return textVersions.sort((a, b) => compare(b.public, a.public));
         }
 
         const versions = await availableVersionsCmd.execute({

src/managers/builtin/venvUtils.ts

@@ -25,7 +25,6 @@ import { getWorkspacePersistentState } from '../../common/persistentState';
 import { EventNames } from '../../common/telemetry/constants';
 import { sendTelemetryEvent } from '../../common/telemetry/sender';
 import { normalizePath } from '../../common/utils/pathUtils';
-import { isTestExecution } from '../../common/utils/testing';
 import { getVenvPythonPath } from '../../common/utils/virtualEnvironment';
 import {
     showErrorMessage,
@@ -581,7 +580,6 @@ export async function removeVenv(
 
     const confirmed =
         options?.runHeadless === true ||
-        isTestExecution() ||
         (
             await showWarningMessage(
                 l10n.t('Are you sure you want to remove {0}?', displayPath),

src/managers/conda/commands/availableVersions.ts

@@ -19,17 +19,30 @@ export class CondaAvailableVersionsCommand extends AvailableVersionsCommand {
             executeArgs.cancellationToken,
         );
 
-        try {
-            const parsed = JSON.parse(output);
-            if (parsed && typeof parsed === 'object' && Array.isArray(parsed[executeArgs.packageName])) {
-                const versions = (parsed[executeArgs.packageName] as Array<{ version?: string }>)
-                    .map((entry) => entry.version?.trim() ?? '')
-                    .filter((version) => !!version);
-                return this.parseVersions(versions, executeArgs.includePrerelease);
-            }
-            return [];
-        } catch {
-            return [];
+        const parsed: unknown = JSON.parse(output);
+        if (
+            typeof parsed !== 'object' ||
+            parsed === null ||
+            !(executeArgs.packageName in parsed)
+        ) {
+            throw new Error(`Conda returned unexpected package version data for: ${executeArgs.packageName}`);
+        }
+
+        const entries = (parsed as Record<string, unknown>)[executeArgs.packageName];
+        if (!Array.isArray(entries)) {
+            throw new Error(`Conda returned unexpected package version data for: ${executeArgs.packageName}`);
         }
+        const versions = entries.map((entry) => {
+            if (
+                typeof entry !== 'object' ||
+                entry === null ||
+                !('version' in entry) ||
+                typeof entry.version !== 'string'
+            ) {
+                throw new Error(`Conda returned an invalid package version entry for: ${executeArgs.packageName}`);
+            }
+            return entry.version.trim();
+        });
+        return this.parseVersions(versions, executeArgs.includePrerelease);
     }
 }