fix(sandbox): handle orphaned stream promise + preserve error detail

Two regressions from the previous timeout fix:
- When the timeout won the race, the abandoned getSessionCommandLogs promise
  would reject on deleteSession with no handler (unhandledRejection). Attach a
  .catch that records the error and yields an 'error' outcome, so a late
  rejection is always handled.
- The streaming catch dropped the thrown error, so failures before any chunks
  (env write, executeSessionCommand, missing cmdId) surfaced as empty output.
  Fall back to getErrorMessage(error) when nothing streamed.

Adds conformance tests for the stream-reject and start-throw paths.

Author: TheodoreSpeaks

apps/sim/lib/execution/remote-sandbox/conformance.test.ts

@@ -426,4 +426,30 @@ describe('provider selection', () => {
     // The session is deleted to terminate the still-running command.
     expect(mockDeleteSession).toHaveBeenCalled()
   })
+
+  it('surfaces the thrown error when the stream rejects', async () => {
+    useProvider('daytona')
+    // A failure with no chunks streamed must still carry the error detail, not an
+    // empty/opaque message.
+    mockGetSessionCommandLogs.mockRejectedValue(new Error('session died'))
+
+    const result = await withPiSandbox((runner) =>
+      runner.run('git clone ...', { timeoutMs: 1000, onStdout: () => {} })
+    )
+
+    expect(result.exitCode).toBe(1)
+    expect(result.stderr).toContain('session died')
+  })
+
+  it('surfaces the error when starting the streamed command throws', async () => {
+    useProvider('daytona')
+    mockExecuteSessionCommand.mockRejectedValue(new Error('start failed'))
+
+    const result = await withPiSandbox((runner) =>
+      runner.run('git clone ...', { timeoutMs: 1000, onStdout: () => {} })
+    )
+
+    expect(result.exitCode).toBe(1)
+    expect(result.stderr).toContain('start failed')
+  })
 })

apps/sim/lib/execution/remote-sandbox/daytona.ts

@@ -156,6 +156,11 @@ class DaytonaSandboxHandle implements SandboxHandle {
       // and format failures from stderr, so returning empty strings here would
       // both break marker extraction and blank out error messages even though
       // the callbacks fired correctly.
+      // The `.catch` keeps its own reference to the stream's outcome AND ensures a
+      // late rejection is always handled — when the timeout wins the race, this
+      // promise is abandoned and deleteSession (finally) tears the session down,
+      // which rejects it; without the handler that would be an unhandledRejection.
+      let streamError: unknown
       const streamed = this.sandbox.process
         .getSessionCommandLogs(
           sessionId,
@@ -170,6 +175,10 @@ class DaytonaSandboxHandle implements SandboxHandle {
           }
         )
         .then(() => 'done' as const)
+        .catch((error: unknown) => {
+          streamError = error
+          return 'error' as const
+        })
 
       // `runAsync: true` returns immediately, so the timeout must be enforced here
       // — otherwise a hung command streams forever, unlike E2B's commands.run
@@ -179,23 +188,27 @@ class DaytonaSandboxHandle implements SandboxHandle {
       const timedOut = new Promise<'timeout'>((resolve) => {
         timer = setTimeout(() => resolve('timeout'), options.timeoutMs)
       })
+      let outcome: 'done' | 'error' | 'timeout'
       try {
-        const outcome = await Promise.race([streamed, timedOut])
-        if (outcome === 'timeout') {
-          return {
-            stdout,
-            stderr: stderr || `Command timed out after ${options.timeoutMs}ms`,
-            exitCode: 124,
-          }
-        }
+        outcome = await Promise.race([streamed, timedOut])
       } finally {
         if (timer) clearTimeout(timer)
       }
+      if (outcome === 'timeout') {
+        return {
+          stdout,
+          stderr: stderr || `Command timed out after ${options.timeoutMs}ms`,
+          exitCode: 124,
+        }
+      }
+      if (outcome === 'error') {
+        return { stdout, stderr: stderr || getErrorMessage(streamError), exitCode: 1 }
+      }
 
       const finished = await this.sandbox.process.getSessionCommand(sessionId, commandId)
       return { stdout, stderr, exitCode: finished.exitCode ?? 0 }
     } catch (error) {
-      return { stdout, stderr, exitCode: 1 }
+      return { stdout, stderr: stderr || getErrorMessage(error), exitCode: 1 }
     } finally {
       try {
         await this.sandbox.process.deleteSession(sessionId)