Preserve Conda cache on parse failures

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

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

Author: edvilme

src/managers/conda/commands/list.ts

@@ -39,13 +39,10 @@ export class CondaListCommand extends ListCommand {
         try {
             parsed = JSON.parse(output);
         } catch (error) {
-            this.log?.error('Failed to parse conda list output', error);
             throw new CondaListOutputError('Failed to parse conda list output', error);
         }
         if (!Array.isArray(parsed)) {
-            const error = new CondaListOutputError('Invalid conda list output: expected a JSON array');
-            this.log?.error(error.message);
-            throw error;
+            throw new CondaListOutputError('Invalid conda list output: expected a JSON array');
         }
 
         const packages: PackageInfo[] = [];

src/managers/conda/condaPackageManager.ts

@@ -101,9 +101,15 @@ export class CondaPackageManager implements PackageManager, Disposable {
                     });
                 }
 
-                await updatePackagesAndNotify(this, environment, this.packages.get(environment.envId.id), (changes) => {
-                    this._onDidChangePackages.fire({ environment, manager: this, changes });
-                });
+                await updatePackagesAndNotify(
+                    this,
+                    environment,
+                    this.packages.get(environment.envId.id),
+                    (changes) => {
+                        this._onDidChangePackages.fire({ environment, manager: this, changes });
+                    },
+                    () => this.fetchPackages(environment),
+                );
             } catch (e) {
                 if (e instanceof CancellationError) {
                     throw e;
@@ -147,34 +153,40 @@ export class CondaPackageManager implements PackageManager, Disposable {
                     (changes) => {
                         this._onDidChangePackages.fire({ environment, manager: this, changes });
                     },
+                    () => this.fetchPackages(environment),
                 );
-                this.packages.set(environment.envId.id, packages ?? []);
+                if (packages !== undefined) {
+                    this.packages.set(environment.envId.id, packages);
+                }
             },
         );
     }
 
     async getPackages(environment: PythonEnvironment, options?: GetPackagesOptions): Promise<Package[] | undefined> {
         if (options?.skipCache || !this.packages.has(environment.envId.id)) {
-            const listCmd = new CondaListCommand({
-                pythonExecutable: 'conda',
-                condaEnvironmentPath: environment.environmentPath.fsPath,
-                log: this.log,
-            });
-            let data;
-            try {
-                data = await listCmd.execute();
-            } catch (error) {
-                if (error instanceof CondaListOutputError) {
-                    this.log.error('Error parsing installed Conda packages', error);
-                    return [];
-                }
-                throw error;
-            }
-            const packages = (data ?? []).map((pkg) => this.api.createPackageItem(pkg, environment, this));
+            return (await this.fetchPackages(environment)) ?? [];
+        }
+        return this.packages.get(environment.envId.id);
+    }
+
+    private async fetchPackages(environment: PythonEnvironment): Promise<Package[] | undefined> {
+        const listCmd = new CondaListCommand({
+            pythonExecutable: 'conda',
+            condaEnvironmentPath: environment.environmentPath.fsPath,
+            log: this.log,
+        });
+        try {
+            const data = await listCmd.execute();
+            const packages = data.map((pkg) => this.api.createPackageItem(pkg, environment, this));
             this.packages.set(environment.envId.id, packages);
             return packages;
+        } catch (error) {
+            if (error instanceof CondaListOutputError) {
+                this.log.error('Error parsing installed Conda packages', error);
+                return undefined;
+            }
+            throw error;
         }
-        return this.packages.get(environment.envId.id);
     }
 
     formatInstallSpec(packageName: string, version: string): string {

src/test/managers/conda/commands.unit.test.ts

@@ -126,7 +126,7 @@ suite('Conda commands', () => {
         });
 
         await assert.rejects(() => command.execute(), CondaListOutputError);
-        assert.ok((mockLog.error as sinon.SinonStub).calledOnce);
+        assert.ok((mockLog.error as sinon.SinonStub).notCalled);
     });
 
     test('CondaListCommand rejects non-array JSON', async () => {
@@ -138,7 +138,7 @@ suite('Conda commands', () => {
         });
 
         await assert.rejects(() => command.execute(), /expected a JSON array/);
-        assert.ok((mockLog.error as sinon.SinonStub).calledOnce);
+        assert.ok((mockLog.error as sinon.SinonStub).notCalled);
     });
 
     test('CondaVersionCommand parses the version', async () => {

src/test/managers/conda/condaPackageManager.unit.test.ts

@@ -41,6 +41,25 @@ suite('CondaPackageManager', () => {
         assert.ok(showErrorMessageWithLogs.notCalled);
     });
 
+    test('does not fail a successful mutation when follow-up list output is malformed', async () => {
+        const environment = {
+            envId: { id: 'test-environment', managerId: 'test-manager' },
+            environmentPath: Uri.file('.'),
+        } as PythonEnvironment;
+        const logError = sinon.stub();
+        const manager = new CondaPackageManager(
+            { createPackageItem: sinon.stub() } as unknown as PythonEnvironmentApi,
+            { error: logError } as unknown as LogOutputChannel,
+        );
+        sinon.stub(CondaInstallCommand.prototype, 'execute').resolves();
+        const parseError = new CondaListOutputError('Failed to parse conda list output');
+        sinon.stub(CondaListCommand.prototype, 'execute').rejects(parseError);
+
+        await manager.manage(environment, { install: ['requests'], runHeadless: true });
+
+        assert.ok(logError.calledOnceWithExactly('Error parsing installed Conda packages', parseError));
+    });
+
     test('propagates package version lookup failures', async () => {
         const environment = {
             envId: { id: 'test-environment', managerId: 'test-manager' },
@@ -105,4 +124,35 @@ suite('CondaPackageManager', () => {
 
         await assert.rejects(manager.getPackages(environment), (error: unknown) => error === processError);
     });
+
+    test('does not report removals or replace the cache when refresh output is malformed', async () => {
+        const environment = {
+            envId: { id: 'test-environment', managerId: 'test-manager' },
+            environmentPath: Uri.file('.'),
+        } as PythonEnvironment;
+        const cachedPackage = {
+            name: 'requests',
+            displayName: 'requests',
+            version: '2.32.0',
+            description: '2.32.0',
+        };
+        const api = {
+            createPackageItem: sinon.stub().callsFake((pkg) => pkg),
+        } as unknown as PythonEnvironmentApi;
+        const manager = new CondaPackageManager(api, { error: sinon.stub() } as unknown as LogOutputChannel);
+        const execute = sinon.stub(CondaListCommand.prototype, 'execute');
+        execute.onFirstCall().resolves([cachedPackage]);
+        execute.onSecondCall().rejects(new CondaListOutputError('Failed to parse conda list output'));
+        sinon.stub(windowApis, 'withProgress').callsFake(async (_options, task) => task({} as never, {} as never));
+        const onDidChangePackages = sinon.stub();
+        manager.onDidChangePackages(onDidChangePackages);
+
+        await manager.getPackages(environment);
+        await manager.refresh(environment);
+        const packages = await manager.getPackages(environment);
+
+        assert.deepStrictEqual(packages?.map((pkg) => pkg.name), ['requests']);
+        assert.ok(onDidChangePackages.notCalled);
+        assert.strictEqual(execute.callCount, 2);
+    });
 });