Fix opaque "Process exited with code 1" in VS Code workspace view

ext/vscode/CHANGELOG.md

@@ -8,7 +8,7 @@
 
 ### Bugs Fixed
 
-### Other Changes
+- [[#9136]](https://github.com/Azure/azure-dev/pull/9136) Fixed the workspace resource view surfacing an opaque "Process exited with code 1" error (with a Report Issue prompt) when `azd show` fails for expected reasons such as not being logged in or having no environment. The underlying `azd` error is now included for diagnosis and these background failures no longer prompt users to file a bug.
 
 ## 0.10.0 (2025-09-22)
 

ext/vscode/src/test/suite/unit/execAsync.test.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { StreamSpawnOptions } from '@microsoft/vscode-processutils';
+import { expect } from 'chai';
+import { execAsync, SpawnStreamAsync } from '../../../utils/execAsync';
+
+// Builds a fake spawnStreamAsync that emits the given stdout/stderr into the accumulator pipes that
+// execAsync wires up, then either resolves or rejects to simulate the process exit. The pipes must be
+// ended so that AccumulatorStream.getString() (which awaits the stream 'close' event) resolves - this
+// mirrors how a real child process closes its stdio streams on exit.
+function fakeSpawn(stdout: string, stderr: string, rejectWith?: Error): SpawnStreamAsync {
+    return (_command: string, _args, options?: StreamSpawnOptions) => {
+        if (stdout) {
+            options?.stdOutPipe?.write(Buffer.from(stdout));
+        }
+        options?.stdOutPipe?.end();
+
+        if (stderr) {
+            options?.stdErrPipe?.write(Buffer.from(stderr));
+        }
+        options?.stdErrPipe?.end();
+
+        return rejectWith ? Promise.reject(rejectWith) : Promise.resolve();
+    };
+}
+
+suite('execAsync Tests', () => {
+    test('Returns stdout and stderr on success', async () => {
+        const { stdout, stderr } = await execAsync('cmd', [], undefined, fakeSpawn('out', 'err'));
+
+        expect(stdout).to.equal('out');
+        expect(stderr).to.equal('err');
+    });
+
+    test('Includes process stderr in the error message on non-zero exit', async () => {
+        const spawn = fakeSpawn(
+            '',
+            'ERROR: parsing project file: File is empty.',
+            new Error('Process exited with code 1')
+        );
+
+        try {
+            await execAsync('cmd', [], undefined, spawn);
+            expect.fail('Should have thrown an error');
+        } catch (error) {
+            expect(error).to.be.instanceOf(Error);
+            // Without this behavior, the message would only be the generic "Process exited with code 1",
+            // discarding the real reason emitted by the child process on stderr.
+            expect((error as Error).message, 'Error should retain the exit-code context').to.include(
+                'Process exited with code 1'
+            );
+            expect((error as Error).message, 'Error should surface the underlying stderr').to.include(
+                'parsing project file: File is empty.'
+            );
+        }
+    });
+
+    test('Rethrows the original error unchanged when stderr is empty', async () => {
+        const originalError = new Error('Process exited with code 1');
+        const spawn = fakeSpawn('', '', originalError);
+
+        try {
+            await execAsync('cmd', [], undefined, spawn);
+            expect.fail('Should have thrown an error');
+        } catch (error) {
+            expect(error).to.equal(originalError);
+            expect((error as Error).message).to.equal('Process exited with code 1');
+        }
+    });
+});

ext/vscode/src/utils/execAsync.ts

@@ -5,7 +5,10 @@
 
 import { AccumulatorStream, CommandLineArgs, NoShell, spawnStreamAsync, StreamSpawnOptions } from '@microsoft/vscode-processutils';
 
-export async function execAsync(command: string, args: CommandLineArgs, options?: Partial<StreamSpawnOptions>): Promise<{ stdout: string, stderr: string }> {
+// Alias for the spawn implementation so it can be overridden in tests without spawning a real process.
+export type SpawnStreamAsync = typeof spawnStreamAsync;
+
+export async function execAsync(command: string, args: CommandLineArgs, options?: Partial<StreamSpawnOptions>, spawnStreamAsyncFunction: SpawnStreamAsync = spawnStreamAsync): Promise<{ stdout: string, stderr: string }> {
     const stdoutFinal = new AccumulatorStream();
     const stderrFinal = new AccumulatorStream();
 
@@ -16,7 +19,20 @@ export async function execAsync(command: string, args: CommandLineArgs, options?
         stdErrPipe: stderrFinal,
     };
 
-    await spawnStreamAsync(command, args, spawnOptions);
+    try {
+        await spawnStreamAsyncFunction(command, args, spawnOptions);
+    } catch (error) {
+        // On a non-zero exit, spawnStreamAsync rejects with a generic message (e.g. "Process exited
+        // with code 1") from within a ChildProcess handler, before the caller ever reads stderr. Append
+        // the process's stderr to the error so callers can classify and report the real failure instead
+        // of an opaque exit code.
+        const stderr = (await stderrFinal.getString()).trim();
+        if (stderr && error instanceof Error) {
+            error.message = `${error.message}\n${stderr}`.trim();
+        }
+
+        throw error;
+    }
 
     return {
         stdout: await stdoutFinal.getString(),

ext/vscode/src/views/workspace/AzureDevCliApplication.ts

@@ -70,6 +70,12 @@ export class AzureDevCliApplication implements AzureDevCliModel {
         return callWithTelemetryAndErrorHandling(
             TelemetryId.WorkspaceViewApplicationResolve,
             async actionContext => {
+                // This runs automatically whenever the workspace tree resolves. A non-zero `azd show`
+                // exit here is almost always an expected/environmental state (not logged in, no
+                // environment yet, invalid azure.yaml) rather than an extension bug, so don't surface a
+                // modal error with a "Report Issue" button. The failure is still captured in telemetry,
+                // and azure.yaml problems are reported independently via the Problems panel.
+                actionContext.errorHandling.suppressDisplay = true;
                 return await this.showProvider.getShowResults(actionContext, this.context.configurationFile);
             }
         ) as Promise<AzDevShowResults>;