[BUG] Roo Code CANNOT get the correct return code from commands running in vscode terminal

[nicky-zs]

Problem (one or two sentences)

Roo Code run a command in VSCode Terminal. The command returned with code 1, but Roo Code always believe the return code is 0.

Context (who is affected and when)

Almost always. The command is executed in VSCode Terminal (I always use VSCode Terminal because the runtime envioronment is prepared by VSCode, for example, python interpreter is decided by VSCode).

Reproduction steps

1. Roo Code triggers a command execution in VSCode terminal
2. if the command fails with a non-zero return code, Roo Code thinks it succeed with return code 0

Expected result

Roo Code knows the failure of the execution

Actual result

Roo Code mistakenly believes ​the execution is succeed

Variations tried (optional)

No response

App Version

Version: 3.45.0 (35d282b)

API Provider (optional)

None

Model Used (optional)

No response

Roo Code Task Links (optional)

No response

Relevant logs or errors (optional)

I've analyzed this issue and found the root cause. Here's my proposed implementation plan:

Root Cause Analysis

The bug is in src/integrations/terminal/ExecaTerminalProcess.ts. After iterating over the subprocess output stream, the code always emits exitCode: 0 (line 132):

this.emit("shell_execution_complete", { exitCode: 0 })

The problem is that iterating over the subprocess stream does not throw an error when the command exits with a non-zero code. The stream iteration completes successfully regardless of the exit code. The subprocess needs to be awaited separately to obtain the actual exit code.

Currently, non-zero exit codes are only captured when execa throws an ExecaError during execution (caught in the catch block), but this does not happen for commands that run to completion with a non-zero exit code.

Proposed Fix

Modify ExecaTerminalProcess.ts to await the subprocess after stream iteration to get the actual exit code:

1. After the stream iteration completes (around line 102), await the subprocess to get its result
2. Extract the actual exit code from the subprocess result
3. Emit the correct exit code instead of hardcoding 0

The fix would change the code from:

// After stream iteration...
this.emit("shell_execution_complete", { exitCode: 0 })

To:

// After stream iteration...
try {
    const result = await this.subprocess
    this.emit("shell_execution_complete", { exitCode: result?.exitCode ?? 0 })
} catch (error) {
    // Handle case where subprocess already threw
    if (error instanceof ExecaError) {
        this.emit("shell_execution_complete", { exitCode: error.exitCode ?? 1, signalName: error.signal })
    } else {
        this.emit("shell_execution_complete", { exitCode: 1 })
    }
}

This approach:

• Awaits the subprocess to get the actual exit code
• Handles edge cases where the subprocess may have already thrown
• Maintains backward compatibility for successful commands

Testing

I will add/update tests in src/integrations/terminal/__tests__/ExecaTerminalProcess.spec.ts to verify:

• Commands with exit code 0 report correct exit code
• Commands with non-zero exit codes (e.g., exit 1, false) report the correct exit code
• Error scenarios continue to work correctly

Please mention @roomote in a comment saying that you approve this plan, and I'll proceed with the implementation.

[nicky-zs]

@roomote approve

Thanks for the approval @nicky-zs! I've seen your comment and will now implement the fix. I'll open a PR to share progress shortly.

Opened a PR with my attempt at addressing this: #11045

The fix awaits the subprocess after stream iteration to get the actual exit code, instead of always emitting exitCode: 0. Tests have been added for non-zero exit codes.

Feedback welcome!