@cloudflare/sandbox 0.4.11 → 0.4.14

package/tests/sandbox.test.ts

@@ -1,14 +1,21 @@
+import { Container } from '@cloudflare/containers';
 import type { DurableObjectState } from '@cloudflare/workers-types';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { Sandbox } from '../src/sandbox';
-import { Container } from '@cloudflare/containers';
+import { connect, Sandbox } from '../src/sandbox';
 
 // Mock dependencies before imports
 vi.mock('./interpreter', () => ({
-  CodeInterpreter: vi.fn().mockImplementation(() => ({})),
+  CodeInterpreter: vi.fn().mockImplementation(() => ({}))
 }));
 
 vi.mock('@cloudflare/containers', () => {
+  const mockSwitchPort = vi.fn((request: Request, port: number) => {
+    // Create a new request with the port in the URL path
+    const url = new URL(request.url);
+    url.pathname = `/proxy/${port}${url.pathname}`;
+    return new Request(url, request);
+  });
+
   const MockContainer = class Container {
     ctx: any;
     env: any;
@@ -18,6 +25,17 @@ vi.mock('@cloudflare/containers', () => {
     }
     async fetch(request: Request): Promise<Response> {
       // Mock implementation - will be spied on in tests
+      const upgradeHeader = request.headers.get('Upgrade');
+      if (upgradeHeader?.toLowerCase() === 'websocket') {
+        return new Response('WebSocket Upgraded', {
+          status: 200,
+          headers: {
+            'X-WebSocket-Upgraded': 'true',
+            Upgrade: 'websocket',
+            Connection: 'Upgrade'
+          }
+        });
+      }
       return new Response('Mock Container fetch');
     }
     async containerFetch(request: Request, port: number): Promise<Response> {
@@ -29,12 +47,13 @@ vi.mock('@cloudflare/containers', () => {
   return {
     Container: MockContainer,
     getContainer: vi.fn(),
+    switchPort: mockSwitchPort
   };
 });
 
 describe('Sandbox - Automatic Session Management', () => {
   let sandbox: Sandbox;
-  let mockCtx: Partial<DurableObjectState>;
+  let mockCtx: Partial<DurableObjectState<{}>>;
   let mockEnv: any;
 
   beforeEach(async () => {
@@ -46,31 +65,39 @@ describe('Sandbox - Automatic Session Management', () => {
         get: vi.fn().mockResolvedValue(null),
         put: vi.fn().mockResolvedValue(undefined),
         delete: vi.fn().mockResolvedValue(undefined),
-        list: vi.fn().mockResolvedValue(new Map()),
+        list: vi.fn().mockResolvedValue(new Map())
       } as any,
-      blockConcurrencyWhile: vi.fn((fn: () => Promise<void>) => fn()),
+      blockConcurrencyWhile: vi
+        .fn()
+        .mockImplementation(
+          <T>(callback: () => Promise<T>): Promise<T> => callback()
+        ),
       id: {
         toString: () => 'test-sandbox-id',
         equals: vi.fn(),
-        name: 'test-sandbox',
-      } as any,
+        name: 'test-sandbox'
+      } as any
     };
 
     mockEnv = {};
 
     // Create Sandbox instance - SandboxClient is created internally
-    sandbox = new Sandbox(mockCtx as DurableObjectState, mockEnv);
+    const stub = new Sandbox(mockCtx, mockEnv);
 
     // Wait for blockConcurrencyWhile to complete
     await vi.waitFor(() => {
       expect(mockCtx.blockConcurrencyWhile).toHaveBeenCalled();
     });
 
+    sandbox = Object.assign(stub, {
+      wsConnect: connect(stub)
+    });
+
     // Now spy on the client methods that we need for testing
     vi.spyOn(sandbox.client.utils, 'createSession').mockResolvedValue({
       success: true,
       id: 'sandbox-default',
-      message: 'Created',
+      message: 'Created'
     } as any);
 
     vi.spyOn(sandbox.client.commands, 'execute').mockResolvedValue({
@@ -79,13 +106,13 @@ describe('Sandbox - Automatic Session Management', () => {
       stderr: '',
       exitCode: 0,
       command: '',
-      timestamp: new Date().toISOString(),
+      timestamp: new Date().toISOString()
     } as any);
 
     vi.spyOn(sandbox.client.files, 'writeFile').mockResolvedValue({
       success: true,
       path: '/test.txt',
-      timestamp: new Date().toISOString(),
+      timestamp: new Date().toISOString()
     } as any);
   });
 
@@ -101,7 +128,7 @@ describe('Sandbox - Automatic Session Management', () => {
         stderr: '',
         exitCode: 0,
         command: 'echo test',
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
       } as any);
 
       await sandbox.exec('echo test');
@@ -110,7 +137,7 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(sandbox.client.utils.createSession).toHaveBeenCalledWith({
         id: expect.stringMatching(/^sandbox-/),
         env: {},
-        cwd: '/workspace',
+        cwd: '/workspace'
       });
 
       expect(sandbox.client.commands.execute).toHaveBeenCalledWith(
@@ -126,9 +153,12 @@ describe('Sandbox - Automatic Session Management', () => {
 
       expect(sandbox.client.utils.createSession).toHaveBeenCalledTimes(1);
 
-      const firstSessionId = vi.mocked(sandbox.client.commands.execute).mock.calls[0][1];
-      const fileSessionId = vi.mocked(sandbox.client.files.writeFile).mock.calls[0][2];
-      const secondSessionId = vi.mocked(sandbox.client.commands.execute).mock.calls[1][1];
+      const firstSessionId = vi.mocked(sandbox.client.commands.execute).mock
+        .calls[0][1];
+      const fileSessionId = vi.mocked(sandbox.client.files.writeFile).mock
+        .calls[0][2];
+      const secondSessionId = vi.mocked(sandbox.client.commands.execute).mock
+        .calls[1][1];
 
       expect(firstSessionId).toBe(fileSessionId);
       expect(firstSessionId).toBe(secondSessionId);
@@ -140,19 +170,21 @@ describe('Sandbox - Automatic Session Management', () => {
         processId: 'proc-1',
         pid: 1234,
         command: 'sleep 10',
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
       } as any);
 
       vi.spyOn(sandbox.client.processes, 'listProcesses').mockResolvedValue({
         success: true,
-        processes: [{
-          id: 'proc-1',
-          pid: 1234,
-          command: 'sleep 10',
-          status: 'running',
-          startTime: new Date().toISOString(),
-        }],
-        timestamp: new Date().toISOString(),
+        processes: [
+          {
+            id: 'proc-1',
+            pid: 1234,
+            command: 'sleep 10',
+            status: 'running',
+            startTime: new Date().toISOString()
+          }
+        ],
+        timestamp: new Date().toISOString()
       } as any);
 
       const process = await sandbox.startProcess('sleep 10');
@@ -161,11 +193,14 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(sandbox.client.utils.createSession).toHaveBeenCalledTimes(1);
 
       // startProcess uses sessionId (to start process in that session)
-      const startSessionId = vi.mocked(sandbox.client.processes.startProcess).mock.calls[0][1];
+      const startSessionId = vi.mocked(sandbox.client.processes.startProcess)
+        .mock.calls[0][1];
       expect(startSessionId).toMatch(/^sandbox-/);
 
       // listProcesses is sandbox-scoped - no sessionId parameter
-      const listProcessesCall = vi.mocked(sandbox.client.processes.listProcesses).mock.calls[0];
+      const listProcessesCall = vi.mocked(
+        sandbox.client.processes.listProcesses
+      ).mock.calls[0];
       expect(listProcessesCall).toEqual([]);
 
       // Verify the started process appears in the list
@@ -181,10 +216,12 @@ describe('Sandbox - Automatic Session Management', () => {
         stderr: '',
         branch: 'main',
         targetDir: '/workspace/repo',
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
       } as any);
 
-      await sandbox.gitCheckout('https://github.com/test/repo.git', { branch: 'main' });
+      await sandbox.gitCheckout('https://github.com/test/repo.git', {
+        branch: 'main'
+      });
 
       expect(sandbox.client.utils.createSession).toHaveBeenCalledTimes(1);
       expect(sandbox.client.git.checkout).toHaveBeenCalledWith(
@@ -202,7 +239,7 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(sandbox.client.utils.createSession).toHaveBeenCalledWith({
         id: 'sandbox-my-sandbox',
         env: {},
-        cwd: '/workspace',
+        cwd: '/workspace'
       });
     });
   });
@@ -212,19 +249,19 @@ describe('Sandbox - Automatic Session Management', () => {
       vi.mocked(sandbox.client.utils.createSession).mockResolvedValueOnce({
         success: true,
         id: 'custom-session-123',
-        message: 'Created',
+        message: 'Created'
       } as any);
 
       const session = await sandbox.createSession({
         id: 'custom-session-123',
         env: { NODE_ENV: 'test' },
-        cwd: '/test',
+        cwd: '/test'
       });
 
       expect(sandbox.client.utils.createSession).toHaveBeenCalledWith({
         id: 'custom-session-123',
         env: { NODE_ENV: 'test' },
-        cwd: '/test',
+        cwd: '/test'
       });
 
       expect(session.id).toBe('custom-session-123');
@@ -238,7 +275,7 @@ describe('Sandbox - Automatic Session Management', () => {
       vi.mocked(sandbox.client.utils.createSession).mockResolvedValueOnce({
         success: true,
         id: 'isolated-session',
-        message: 'Created',
+        message: 'Created'
       } as any);
 
       const session = await sandbox.createSession({ id: 'isolated-session' });
@@ -253,8 +290,16 @@ describe('Sandbox - Automatic Session Management', () => {
 
     it('should isolate multiple explicit sessions', async () => {
       vi.mocked(sandbox.client.utils.createSession)
-        .mockResolvedValueOnce({ success: true, id: 'session-1', message: 'Created' } as any)
-        .mockResolvedValueOnce({ success: true, id: 'session-2', message: 'Created' } as any);
+        .mockResolvedValueOnce({
+          success: true,
+          id: 'session-1',
+          message: 'Created'
+        } as any)
+        .mockResolvedValueOnce({
+          success: true,
+          id: 'session-2',
+          message: 'Created'
+        } as any);
 
       const session1 = await sandbox.createSession({ id: 'session-1' });
       const session2 = await sandbox.createSession({ id: 'session-2' });
@@ -262,8 +307,10 @@ describe('Sandbox - Automatic Session Management', () => {
       await session1.exec('echo build');
       await session2.exec('echo test');
 
-      const session1Id = vi.mocked(sandbox.client.commands.execute).mock.calls[0][1];
-      const session2Id = vi.mocked(sandbox.client.commands.execute).mock.calls[1][1];
+      const session1Id = vi.mocked(sandbox.client.commands.execute).mock
+        .calls[0][1];
+      const session2Id = vi.mocked(sandbox.client.commands.execute).mock
+        .calls[1][1];
 
       expect(session1Id).toBe('session-1');
       expect(session2Id).toBe('session-2');
@@ -272,19 +319,32 @@ describe('Sandbox - Automatic Session Management', () => {
 
     it('should not interfere with default session', async () => {
       vi.mocked(sandbox.client.utils.createSession)
-        .mockResolvedValueOnce({ success: true, id: 'sandbox-default', message: 'Created' } as any)
-        .mockResolvedValueOnce({ success: true, id: 'explicit-session', message: 'Created' } as any);
+        .mockResolvedValueOnce({
+          success: true,
+          id: 'sandbox-default',
+          message: 'Created'
+        } as any)
+        .mockResolvedValueOnce({
+          success: true,
+          id: 'explicit-session',
+          message: 'Created'
+        } as any);
 
       await sandbox.exec('echo default');
 
-      const explicitSession = await sandbox.createSession({ id: 'explicit-session' });
+      const explicitSession = await sandbox.createSession({
+        id: 'explicit-session'
+      });
       await explicitSession.exec('echo explicit');
 
       await sandbox.exec('echo default-again');
 
-      const defaultSessionId1 = vi.mocked(sandbox.client.commands.execute).mock.calls[0][1];
-      const explicitSessionId = vi.mocked(sandbox.client.commands.execute).mock.calls[1][1];
-      const defaultSessionId2 = vi.mocked(sandbox.client.commands.execute).mock.calls[2][1];
+      const defaultSessionId1 = vi.mocked(sandbox.client.commands.execute).mock
+        .calls[0][1];
+      const explicitSessionId = vi.mocked(sandbox.client.commands.execute).mock
+        .calls[1][1];
+      const defaultSessionId2 = vi.mocked(sandbox.client.commands.execute).mock
+        .calls[2][1];
 
       expect(defaultSessionId1).toBe('sandbox-default');
       expect(explicitSessionId).toBe('explicit-session');
@@ -297,7 +357,7 @@ describe('Sandbox - Automatic Session Management', () => {
       vi.mocked(sandbox.client.utils.createSession).mockResolvedValueOnce({
         success: true,
         id: 'session-generated-123',
-        message: 'Created',
+        message: 'Created'
       } as any);
 
       await sandbox.createSession();
@@ -305,7 +365,7 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(sandbox.client.utils.createSession).toHaveBeenCalledWith({
         id: expect.stringMatching(/^session-/),
         env: undefined,
-        cwd: undefined,
+        cwd: undefined
       });
     });
   });
@@ -317,7 +377,7 @@ describe('Sandbox - Automatic Session Management', () => {
       vi.mocked(sandbox.client.utils.createSession).mockResolvedValueOnce({
         success: true,
         id: 'test-session',
-        message: 'Created',
+        message: 'Created'
       } as any);
 
       session = await sandbox.createSession({ id: 'test-session' });
@@ -325,7 +385,10 @@ describe('Sandbox - Automatic Session Management', () => {
 
     it('should execute command with session context', async () => {
       await session.exec('pwd');
-      expect(sandbox.client.commands.execute).toHaveBeenCalledWith('pwd', 'test-session');
+      expect(sandbox.client.commands.execute).toHaveBeenCalledWith(
+        'pwd',
+        'test-session'
+      );
     });
 
     it('should start process with session context', async () => {
@@ -336,8 +399,8 @@ describe('Sandbox - Automatic Session Management', () => {
           pid: 1234,
           command: 'sleep 10',
           status: 'running',
-          startTime: new Date().toISOString(),
-        },
+          startTime: new Date().toISOString()
+        }
       } as any);
 
       await session.startProcess('sleep 10');
@@ -353,7 +416,7 @@ describe('Sandbox - Automatic Session Management', () => {
       vi.spyOn(sandbox.client.files, 'writeFile').mockResolvedValue({
         success: true,
         path: '/test.txt',
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
       } as any);
 
       await session.writeFile('/test.txt', 'content');
@@ -373,7 +436,7 @@ describe('Sandbox - Automatic Session Management', () => {
         stderr: '',
         branch: 'main',
         targetDir: '/workspace/repo',
-        timestamp: new Date().toISOString(),
+        timestamp: new Date().toISOString()
       } as any);
 
       await session.gitCheckout('https://github.com/test/repo.git');
@@ -392,7 +455,9 @@ describe('Sandbox - Automatic Session Management', () => {
         new Error('Session creation failed')
       );
 
-      await expect(sandbox.exec('echo test')).rejects.toThrow('Session creation failed');
+      await expect(sandbox.exec('echo test')).rejects.toThrow(
+        'Session creation failed'
+      );
     });
 
     it('should initialize with empty environment when not set', async () => {
@@ -401,7 +466,7 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(sandbox.client.utils.createSession).toHaveBeenCalledWith({
         id: expect.any(String),
         env: {},
-        cwd: '/workspace',
+        cwd: '/workspace'
       });
     });
 
@@ -413,7 +478,7 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(sandbox.client.utils.createSession).toHaveBeenCalledWith({
         id: expect.any(String),
         env: { NODE_ENV: 'production', DEBUG: 'true' },
-        cwd: '/workspace',
+        cwd: '/workspace'
       });
     });
   });
@@ -425,7 +490,7 @@ describe('Sandbox - Automatic Session Management', () => {
         success: true,
         port: 8080,
         name: 'test-service',
-        exposedAt: new Date().toISOString(),
+        exposedAt: new Date().toISOString()
       } as any);
     });
 
@@ -459,7 +524,10 @@ describe('Sandbox - Automatic Session Management', () => {
       ];
 
       for (const { hostname } of testCases) {
-        const result = await sandbox.exposePort(8080, { name: 'test', hostname });
+        const result = await sandbox.exposePort(8080, {
+          name: 'test',
+          hostname
+        });
         expect(result.url).toContain(hostname);
         expect(result.port).toBe(8080);
       }
@@ -483,7 +551,8 @@ describe('Sandbox - Automatic Session Management', () => {
       await sandbox.setSandboxName('test-sandbox');
 
       // Spy on Container.prototype.fetch to verify WebSocket routing
-      superFetchSpy = vi.spyOn(Container.prototype, 'fetch')
+      superFetchSpy = vi
+        .spyOn(Container.prototype, 'fetch')
         .mockResolvedValue(new Response('WebSocket response'));
     });
 
@@ -494,9 +563,9 @@ describe('Sandbox - Automatic Session Management', () => {
     it('should detect WebSocket upgrade header and route to super.fetch', async () => {
       const request = new Request('https://example.com/ws', {
         headers: {
-          'Upgrade': 'websocket',
-          'Connection': 'Upgrade',
-        },
+          Upgrade: 'websocket',
+          Connection: 'Upgrade'
+        }
       });
 
       const response = await sandbox.fetch(request);
@@ -518,7 +587,7 @@ describe('Sandbox - Automatic Session Management', () => {
       const postRequest = new Request('https://example.com/api/data', {
         method: 'POST',
         body: JSON.stringify({ data: 'test' }),
-        headers: { 'Content-Type': 'application/json' },
+        headers: { 'Content-Type': 'application/json' }
       });
       await sandbox.fetch(postRequest);
       expect(superFetchSpy).not.toHaveBeenCalled();
@@ -527,7 +596,7 @@ describe('Sandbox - Automatic Session Management', () => {
 
       // SSE request (should not be detected as WebSocket)
       const sseRequest = new Request('https://example.com/events', {
-        headers: { 'Accept': 'text/event-stream' },
+        headers: { Accept: 'text/event-stream' }
       });
       await sandbox.fetch(sseRequest);
       expect(superFetchSpy).not.toHaveBeenCalled();
@@ -536,10 +605,11 @@ describe('Sandbox - Automatic Session Management', () => {
     it('should preserve WebSocket request unchanged when calling super.fetch()', async () => {
       const request = new Request('https://example.com/ws', {
         headers: {
-          'Upgrade': 'websocket',
+          Upgrade: 'websocket',
+          Connection: 'Upgrade',
           'Sec-WebSocket-Key': 'test-key-123',
-          'Sec-WebSocket-Version': '13',
-        },
+          'Sec-WebSocket-Version': '13'
+        }
       });
 
       await sandbox.fetch(request);
@@ -547,8 +617,90 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(superFetchSpy).toHaveBeenCalledTimes(1);
       const passedRequest = superFetchSpy.mock.calls[0][0] as Request;
       expect(passedRequest.headers.get('Upgrade')).toBe('websocket');
-      expect(passedRequest.headers.get('Sec-WebSocket-Key')).toBe('test-key-123');
+      expect(passedRequest.headers.get('Connection')).toBe('Upgrade');
+      expect(passedRequest.headers.get('Sec-WebSocket-Key')).toBe(
+        'test-key-123'
+      );
       expect(passedRequest.headers.get('Sec-WebSocket-Version')).toBe('13');
     });
   });
+
+  describe('wsConnect() method', () => {
+    it('should route WebSocket request through switchPort to sandbox.fetch', async () => {
+      const { switchPort } = await import('@cloudflare/containers');
+      const switchPortMock = vi.mocked(switchPort);
+
+      const request = new Request('http://localhost/ws/echo', {
+        headers: {
+          Upgrade: 'websocket',
+          Connection: 'Upgrade'
+        }
+      });
+
+      const fetchSpy = vi.spyOn(sandbox, 'fetch');
+      const response = await sandbox.wsConnect(request, 8080);
+
+      // Verify switchPort was called with correct port
+      expect(switchPortMock).toHaveBeenCalledWith(request, 8080);
+
+      // Verify fetch was called with the switched request
+      expect(fetchSpy).toHaveBeenCalledOnce();
+
+      // Verify response indicates WebSocket upgrade
+      expect(response.status).toBe(200);
+      expect(response.headers.get('X-WebSocket-Upgraded')).toBe('true');
+    });
+
+    it('should reject invalid ports with SecurityError', async () => {
+      const request = new Request('http://localhost/ws/test', {
+        headers: { Upgrade: 'websocket', Connection: 'Upgrade' }
+      });
+
+      // Invalid port values
+      await expect(sandbox.wsConnect(request, -1)).rejects.toThrow(
+        'Invalid or restricted port'
+      );
+      await expect(sandbox.wsConnect(request, 0)).rejects.toThrow(
+        'Invalid or restricted port'
+      );
+      await expect(sandbox.wsConnect(request, 70000)).rejects.toThrow(
+        'Invalid or restricted port'
+      );
+
+      // Privileged ports
+      await expect(sandbox.wsConnect(request, 80)).rejects.toThrow(
+        'Invalid or restricted port'
+      );
+      await expect(sandbox.wsConnect(request, 443)).rejects.toThrow(
+        'Invalid or restricted port'
+      );
+    });
+
+    it('should preserve request properties through routing', async () => {
+      const request = new Request(
+        'http://localhost/ws/test?token=abc&room=lobby',
+        {
+          headers: {
+            Upgrade: 'websocket',
+            Connection: 'Upgrade',
+            'X-Custom-Header': 'custom-value'
+          }
+        }
+      );
+
+      const fetchSpy = vi.spyOn(sandbox, 'fetch');
+      await sandbox.wsConnect(request, 8080);
+
+      const calledRequest = fetchSpy.mock.calls[0][0];
+
+      // Verify headers are preserved
+      expect(calledRequest.headers.get('Upgrade')).toBe('websocket');
+      expect(calledRequest.headers.get('X-Custom-Header')).toBe('custom-value');
+
+      // Verify query parameters are preserved
+      const url = new URL(calledRequest.url);
+      expect(url.searchParams.get('token')).toBe('abc');
+      expect(url.searchParams.get('room')).toBe('lobby');
+    });
+  });
 });

package/tests/sse-parser.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { asyncIterableToSSEStream, parseSSEStream, responseToAsyncIterable } from '../src/sse-parser';
+import {
+  asyncIterableToSSEStream,
+  parseSSEStream,
+  responseToAsyncIterable
+} from '../src/sse-parser';
 
 function createMockSSEStream(events: string[]): ReadableStream<Uint8Array> {
   return new ReadableStream({
@@ -25,7 +29,6 @@ describe('SSE Parser', () => {
   });
 
   describe('parseSSEStream', () => {
-
     it('should parse valid SSE events', async () => {
       const stream = createMockSSEStream([
         'data: {"type":"start","command":"echo test"}\n\n',
@@ -134,9 +137,7 @@ describe('SSE Parser', () => {
     });
 
     it('should handle remaining buffer data after stream ends', async () => {
-      const stream = createMockSSEStream([
-        'data: {"type":"complete"}'
-      ]);
+      const stream = createMockSSEStream(['data: {"type":"complete"}']);
 
       const events: any[] = [];
       for await (const event of parseSSEStream(stream)) {
@@ -153,7 +154,8 @@ describe('SSE Parser', () => {
       controller.abort();
 
       await expect(async () => {
-        for await (const event of parseSSEStream(stream, controller.signal)) {}
+        for await (const event of parseSSEStream(stream, controller.signal)) {
+        }
       }).rejects.toThrow('Operation was aborted');
     });
 
@@ -236,10 +238,10 @@ describe('SSE Parser', () => {
       const stream = asyncIterableToSSEStream(mockEvents());
       const reader = stream.getReader();
       const decoder = new TextDecoder();
-      
+
       const chunks: string[] = [];
       let done = false;
-      
+
       while (!done) {
         const { value, done: readerDone } = await reader.read();
         done = readerDone;
@@ -251,9 +253,9 @@ describe('SSE Parser', () => {
       const fullOutput = chunks.join('');
       expect(fullOutput).toBe(
         'data: {"type":"start","command":"test"}\n\n' +
-        'data: {"type":"stdout","data":"output"}\n\n' +
-        'data: {"type":"complete","exitCode":0}\n\n' +
-        'data: [DONE]\n\n'
+          'data: {"type":"stdout","data":"output"}\n\n' +
+          'data: {"type":"complete","exitCode":0}\n\n' +
+          'data: [DONE]\n\n'
       );
     });
 
@@ -262,10 +264,9 @@ describe('SSE Parser', () => {
         yield { name: 'test', value: 123 };
       }
 
-      const stream = asyncIterableToSSEStream(
-        mockEvents(),
-        { serialize: (event) => `custom:${event.name}=${event.value}` }
-      );
+      const stream = asyncIterableToSSEStream(mockEvents(), {
+        serialize: (event) => `custom:${event.name}=${event.value}`
+      });
 
       const reader = stream.getReader();
       const decoder = new TextDecoder();
@@ -287,4 +288,4 @@ describe('SSE Parser', () => {
       await expect(reader.read()).rejects.toThrow('Async iterable error');
     });
   });
-});
+});