Fix getProcess() throwing error in RPC transport

packages/sandbox/src/sandbox.ts

@@ -65,6 +65,7 @@ import {
   InvalidBackupConfigError,
   PortNotExposedError,
   ProcessExitedBeforeReadyError,
+  ProcessNotFoundError,
   ProcessReadyTimeoutError,
   SandboxError,
   SessionAlreadyExistsError
@@ -3363,8 +3364,13 @@ export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
 
   async getProcess(id: string, sessionId?: string): Promise<Process | null> {
     const session = sessionId ?? (await this.ensureDefaultSession());
-    const response = await this.client.processes.getProcess(id);
-    if (!response.process) {
+    const response = await this.client.processes
+      .getProcess(id)
+      .catch((e: unknown) => {
+        if (e instanceof ProcessNotFoundError) return null;
+        throw e;
+      });
+    if (!response?.process) {
       return null;
     }
 

packages/sandbox/tests/sandbox.test.ts

@@ -1,6 +1,6 @@
 import { Container } from '@cloudflare/containers';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { PortNotExposedError } from '../src/errors';
+import { PortNotExposedError, ProcessNotFoundError } from '../src/errors';
 import { connect, Sandbox } from '../src/sandbox';
 
 // Mock dependencies before imports
@@ -2566,7 +2566,7 @@
 
       // All three callers are awaiting the same underlying work; the parent
       // container destroy must only be invoked once.
       expect(superDestroy.calls()).toBe(1);
 
       superDestroy.resolve();
       await expect(Promise.all([first, second, third])).resolves.toEqual([
@@ -2576,7 +2576,7 @@
       ]);
     });
 
     it('propagates the same rejection to all coalesced callers', async () => {
       const superDestroy = stubSuperDestroy();
       const first = sandbox.destroy();
       const second = sandbox.destroy();
@@ -2590,7 +2590,7 @@
     it('runs a fresh teardown for a later destroy() after the previous one settles', async () => {
       const first = stubSuperDestroy();
       const firstCall = sandbox.destroy();
       expect(first.calls()).toBe(1);
       first.resolve();
       await firstCall;
 
@@ -2719,3 +2719,80 @@
     });
   });
 });
+
+// ---------------------------------------------------------------------------
+// Sandbox.getProcess() — behaviour across HTTP and RPC transports
+// ---------------------------------------------------------------------------
+
+describe('Sandbox.getProcess()', () => {
+  async function makeSandbox(transport: 'http' | 'rpc') {
+    const ctx = {
+      storage: {
+        get: vi.fn().mockResolvedValue(null),
+        put: vi.fn().mockResolvedValue(undefined),
+        delete: vi.fn().mockResolvedValue(undefined),
+        list: vi.fn().mockResolvedValue(new Map())
+      } as any,
+      blockConcurrencyWhile: vi
+        .fn()
+        .mockImplementation(<T>(cb: () => Promise<T>) => cb()),
+      waitUntil: vi.fn(),
+      id: { toString: () => 'test-id', equals: vi.fn(), name: 'test' } as any
+    };
+    const env = transport === 'rpc' ? { SANDBOX_TRANSPORT: 'rpc' } : {};
+    const sb = new Sandbox(ctx as any, env);
+    await vi.waitFor(() =>
+      expect(ctx.blockConcurrencyWhile).toHaveBeenCalled()
+    );
+    // For RPC transport, sb.client is a ContainerControlClient whose sub-stubs
+    // are capnweb Proxies that reject vi.spyOn. Replace the whole client with a
+    // plain mock object after construction — the individual tests fill in the
+    // methods they need.
+    if (transport === 'rpc') {
+      (sb as any).client = {
+        getTransportMode: () => 'rpc',
+        utils: {
+          createSession: vi
+            .fn()
+            .mockResolvedValue({
+              success: true,
+              id: 'default',
+              message: 'ok'
+            } as any)
+        },
+        processes: {}
+      };
+    } else {
+      vi.spyOn(sb.client.utils, 'createSession').mockResolvedValue({
+        success: true,
+        id: 'default',
+        message: 'ok'
+      } as any);
+    }
+    return sb;
+  }
+
+  it('HTTP: response with no process field returns null', async () => {
+    const sb = await makeSandbox('http');
+    vi.spyOn(sb.client.processes, 'getProcess').mockResolvedValue({
+      success: true,
+      process: undefined,
+      timestamp: ''
+    } as any);
+    expect(await sb.getProcess('x')).toBeNull();
+  });
+
+  it('RPC: thrown ProcessNotFoundError returns null', async () => {
+    const sb = await makeSandbox('rpc');
+    (sb.client.processes as any).getProcess = vi.fn().mockRejectedValue(
+      new ProcessNotFoundError({
+        code: 'PROCESS_NOT_FOUND',
+        message: 'Process x not found',
+        context: { processId: 'x' },
+        httpStatus: 404,
+        timestamp: ''
+      } as any)
+    );
+    expect(await sb.getProcess('x')).toBeNull();
+  });
+});