Adopt package manager command classes (#1686)

## Summary

Adopts the package manager command classes introduced in #1621 across
Pip/UV, Conda, and Poetry while preserving existing behavior and error
contracts.

## Changes

- Replaces existing command construction and execution paths with the
new command classes.
- Uses JSON unconditionally for machine-readable commands when the
installed tool supports it, including all required flags.
- Uses a dedicated text parser for Pip 21.2-25.0; Pip 25.1+ always uses
`pip index versions --json`.
- Preserves operation-specific timeout behavior: install/uninstall
mutations are unbounded, while list/direct-list operations retain
30-second timeouts.
- Propagates malformed version output as an operational failure rather
than treating it as a successful empty result.
- Keeps destructive environment removal confirmation bypass explicit
through `runHeadless`.

## Relationship

- Targets `main` directly and includes the changes merged in #1717.
- Replaces #1678, whose base branch could not be changed after GitHub
registered it as part of a stack.
- Deterministic command argument and parser tests are intentionally
included here so the adopted implementations are covered in the same PR.
The superseded network-dependent roundtrip test was removed in favor of
the controlled package-manager integration fixtures.

## Testing

- `npm run lint`
- `npm run compile-tests`
- `npm run unittest` (1,855 passing, 6 pending)
- Focused package-manager command, selection, timeout, parsing, and
removal-confirmation tests

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
Copilot-Session: 3f16397e-0917-4efb-8d75-566c71ebf9ba
Copilot-Session: 6b2fe9b5-38ea-442f-b07a-b6c71134d480
Copilot-Session: edcaaa35-9a42-4351-98fa-55bcf8f1968e
Copilot-Session: 5aba47cf-0b43-48b9-bc22-75e625da70e8

Author: 3 people

.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)
@@ -611,3 +612,4 @@ envConfig.inspect
 - **No retries for masking flakiness**: Mocha `retries` should not be used to mask test flakiness. If a test is flaky, fix the root cause. Retries hide real issues and slow down CI (1)
 - **pet binary is required for environment manager registration**: The smoke/E2E/integration tests require the `pet` binary from `microsoft/python-environment-tools` to be built and placed in `python-env-tools/bin/`. Without it, `waitForApiReady()` will timeout because managers never register. CI must build pet from source using `cargo build --release --package pet` (2)
 - **Check exact project registration with `getPythonProjects()`**: `getPythonProject(uri)` can return a containing parent project, so it cannot prove that a nested project was registered or unregistered (1)
+- **Use controlled fixture providers for package lifecycle integration tests**: Discovering an existing Conda environment does not guarantee API quick-create can succeed. Use `createEnvironmentFixture()` so creation prerequisites and cleanup are deterministic (1)

src/common/inlineScript/cacheKey.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 import { createHash } from 'crypto';
-import { normalizePackageName } from '../../managers/builtin/utils';
+import { normalizePackageName } from '../../managers/common/packageUtils';
 import { normalizePath } from '../utils/pathUtils';
 
 /** Length, in hex chars, of the cache key returned by {@link computeCacheKey}. 16 = 64 bits of SHA-256; fixed-length and filesystem-safe. */

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,9 +2,24 @@ import type { Pep440Version } from '@renovatebot/pep440';
 import { AvailableVersionsCommand, type AvailableVersionsExecuteArgs } from '../../base/commands/index';
 import { runPython, runUV } from '../helpers';
 
+function parseVersionsJson(output: string, tool: 'pip' | 'uv'): string[] {
+    const parsed: unknown = JSON.parse(output);
+    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 {
@@ -16,6 +31,7 @@ export class PipAvailableVersionsCommand extends AvailableVersionsCommand {
             'versions',
             executeArgs.packageName,
             '--json',
+            '--disable-pip-version-check',
             '--python-version',
             executeArgs.pythonVersion,
         ];
@@ -30,20 +46,41 @@ export class PipAvailableVersionsCommand extends AvailableVersionsCommand {
             executeArgs.cancellationToken,
             this.timeout,
         );
-        const match = output.match(/{[\s\S]*}/);
-        if (!match) {
-            return [];
-        }
+        return this.parseVersions(parseVersionsJson(output, 'pip'), executeArgs.includePrerelease);
+    }
+}
+
+/**
+ * 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);
     }
 }
 
@@ -75,19 +112,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/factory.ts

@@ -3,11 +3,24 @@ import { shouldUseUv } from '../helpers';
 
 type CommandConstructor<T> = new (options: CommandConstructorOptions) => T;
 
+export type PipOrUvCommand<P, U> = { kind: 'pip'; command: P } | { kind: 'uv'; command: U };
+
+export async function createPipOrUvCommandWithKind<P, U>(
+    options: CommandConstructorOptions,
+    environmentPath: string,
+    PipCommand: CommandConstructor<P>,
+    UvCommand: CommandConstructor<U>,
+): Promise<PipOrUvCommand<P, U>> {
+    return (await shouldUseUv(options.log, environmentPath))
+        ? { kind: 'uv', command: new UvCommand(options) }
+        : { kind: 'pip', command: new PipCommand(options) };
+}
+
 export async function createPipOrUvCommand<T, P extends T, U extends T>(
     options: CommandConstructorOptions,
     environmentPath: string,
     PipCommand: CommandConstructor<P>,
     UvCommand: CommandConstructor<U>,
 ): Promise<T> {
-    return (await shouldUseUv(options.log, environmentPath)) ? new UvCommand(options) : new PipCommand(options);
+    return (await createPipOrUvCommandWithKind(options, environmentPath, PipCommand, UvCommand)).command;
 }

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

@@ -1,15 +1,15 @@
 import { ListDirectNamesCommand, type BaseExecuteArgs } from '../../base/commands/index';
+import { normalizePackageName } from '../../common/packageUtils';
 import { runPython, runUV } from '../helpers';
-import { normalizePackageName } from '../utils';
 
 /**
  * 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>> {