@cloudflare/sandbox 0.0.0-104f455 → 0.0.0-153e416

package/tests/request-handler.test.ts

@@ -0,0 +1,240 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { proxyToSandbox, type SandboxEnv } from '../src/request-handler';
+import type { Sandbox } from '../src/sandbox';
+
+// Mock getSandbox from sandbox.ts
+vi.mock('../src/sandbox', () => {
+  const mockFn = vi.fn();
+  return {
+    getSandbox: mockFn,
+    Sandbox: vi.fn(),
+  };
+});
+
+// Import the mock after vi.mock is set up
+import { getSandbox } from '../src/sandbox';
+
+describe('proxyToSandbox - WebSocket Support', () => {
+  let mockSandbox: Partial<Sandbox>;
+  let mockEnv: SandboxEnv;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Mock Sandbox with necessary methods
+    mockSandbox = {
+      validatePortToken: vi.fn().mockResolvedValue(true),
+      fetch: vi.fn().mockResolvedValue(new Response('WebSocket response')),
+      containerFetch: vi.fn().mockResolvedValue(new Response('HTTP response')),
+    };
+
+    mockEnv = {
+      Sandbox: {} as any,
+    };
+
+    vi.mocked(getSandbox).mockReturnValue(mockSandbox as Sandbox);
+  });
+
+  describe('WebSocket detection and routing', () => {
+    it('should detect WebSocket upgrade header (case-insensitive)', async () => {
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
+        headers: {
+          'Upgrade': 'websocket',
+          'Connection': 'Upgrade',
+        },
+      });
+
+      await proxyToSandbox(request, mockEnv);
+
+      // Should route through fetch() for WebSocket
+      expect(mockSandbox.fetch).toHaveBeenCalledTimes(1);
+      expect(mockSandbox.containerFetch).not.toHaveBeenCalled();
+    });
+
+    it('should set cf-container-target-port header for WebSocket', async () => {
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
+        headers: {
+          'Upgrade': 'websocket',
+        },
+      });
+
+      await proxyToSandbox(request, mockEnv);
+
+      expect(mockSandbox.fetch).toHaveBeenCalledTimes(1);
+      const fetchCall = vi.mocked(mockSandbox.fetch as any).mock.calls[0][0] as Request;
+      expect(fetchCall.headers.get('cf-container-target-port')).toBe('8080');
+    });
+
+    it('should preserve original headers for WebSocket', async () => {
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
+        headers: {
+          'Upgrade': 'websocket',
+          'Sec-WebSocket-Key': 'test-key-123',
+          'Sec-WebSocket-Version': '13',
+          'User-Agent': 'test-client',
+        },
+      });
+
+      await proxyToSandbox(request, mockEnv);
+
+      const fetchCall = vi.mocked(mockSandbox.fetch as any).mock.calls[0][0] as Request;
+      expect(fetchCall.headers.get('Upgrade')).toBe('websocket');
+      expect(fetchCall.headers.get('Sec-WebSocket-Key')).toBe('test-key-123');
+      expect(fetchCall.headers.get('Sec-WebSocket-Version')).toBe('13');
+      expect(fetchCall.headers.get('User-Agent')).toBe('test-client');
+    });
+  });
+
+  describe('HTTP routing (existing behavior)', () => {
+    it('should route HTTP requests through containerFetch', async () => {
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/api/data', {
+        method: 'GET',
+      });
+
+      await proxyToSandbox(request, mockEnv);
+
+      // Should route through containerFetch() for HTTP
+      expect(mockSandbox.containerFetch).toHaveBeenCalledTimes(1);
+      expect(mockSandbox.fetch).not.toHaveBeenCalled();
+    });
+
+    it('should route POST requests through containerFetch', async () => {
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/api/data', {
+        method: 'POST',
+        body: JSON.stringify({ data: 'test' }),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+
+      await proxyToSandbox(request, mockEnv);
+
+      expect(mockSandbox.containerFetch).toHaveBeenCalledTimes(1);
+      expect(mockSandbox.fetch).not.toHaveBeenCalled();
+    });
+
+    it('should not detect SSE as WebSocket', async () => {
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/events', {
+        headers: {
+          'Accept': 'text/event-stream',
+        },
+      });
+
+      await proxyToSandbox(request, mockEnv);
+
+      // SSE should use HTTP path, not WebSocket path
+      expect(mockSandbox.containerFetch).toHaveBeenCalledTimes(1);
+      expect(mockSandbox.fetch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Token validation', () => {
+    it('should validate token for both WebSocket and HTTP requests', async () => {
+      const wsRequest = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
+        headers: { 'Upgrade': 'websocket' },
+      });
+
+      await proxyToSandbox(wsRequest, mockEnv);
+      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(8080, 'token12345678901');
+
+      vi.clearAllMocks();
+
+      const httpRequest = new Request('https://8080-sandbox-token12345678901.example.com/api');
+      await proxyToSandbox(httpRequest, mockEnv);
+      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(8080, 'token12345678901');
+    });
+
+    it('should reject requests with invalid token', async () => {
+      vi.mocked(mockSandbox.validatePortToken as any).mockResolvedValue(false);
+
+      const request = new Request('https://8080-sandbox-invalidtoken1234.example.com/ws', {
+        headers: { 'Upgrade': 'websocket' },
+      });
+
+      const response = await proxyToSandbox(request, mockEnv);
+
+      expect(response?.status).toBe(404);
+      expect(mockSandbox.fetch).not.toHaveBeenCalled();
+
+      const body = await response?.json();
+      expect(body).toMatchObject({
+        error: 'Access denied: Invalid token or port not exposed',
+        code: 'INVALID_TOKEN',
+      });
+    });
+
+    it('should reject reserved port 3000', async () => {
+      // Port 3000 is reserved as control plane port and rejected by validatePort()
+      const request = new Request('https://3000-sandbox-anytoken12345678.example.com/status', {
+        method: 'GET',
+      });
+
+      const response = await proxyToSandbox(request, mockEnv);
+
+      // Port 3000 is reserved and should be rejected (extractSandboxRoute returns null)
+      expect(response).toBeNull();
+      expect(mockSandbox.validatePortToken).not.toHaveBeenCalled();
+      expect(mockSandbox.containerFetch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Port routing', () => {
+    it('should route to correct port from subdomain', async () => {
+      const request = new Request('https://9000-sandbox-token12345678901.example.com/api', {
+        method: 'GET',
+      });
+
+      await proxyToSandbox(request, mockEnv);
+
+      expect(mockSandbox.validatePortToken).toHaveBeenCalledWith(9000, 'token12345678901');
+    });
+  });
+
+  describe('Non-sandbox requests', () => {
+    it('should return null for non-sandbox URLs', async () => {
+      const request = new Request('https://example.com/some-path');
+
+      const response = await proxyToSandbox(request, mockEnv);
+
+      expect(response).toBeNull();
+      expect(mockSandbox.fetch).not.toHaveBeenCalled();
+      expect(mockSandbox.containerFetch).not.toHaveBeenCalled();
+    });
+
+    it('should return null for invalid subdomain patterns', async () => {
+      const request = new Request('https://invalid-pattern.example.com');
+
+      const response = await proxyToSandbox(request, mockEnv);
+
+      expect(response).toBeNull();
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle errors during WebSocket routing', async () => {
+      (mockSandbox.fetch as any).mockImplementation(() => Promise.reject(new Error('Connection failed')));
+
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/ws', {
+        headers: {
+          'Upgrade': 'websocket',
+        },
+      });
+
+      const response = await proxyToSandbox(request, mockEnv);
+
+      expect(response?.status).toBe(500);
+      const text = await response?.text();
+      expect(text).toBe('Proxy routing error');
+    });
+
+    it('should handle errors during HTTP routing', async () => {
+      (mockSandbox.containerFetch as any).mockImplementation(() => Promise.reject(new Error('Service error')));
+
+      const request = new Request('https://8080-sandbox-token12345678901.example.com/api');
+
+      const response = await proxyToSandbox(request, mockEnv);
+
+      expect(response?.status).toBe(500);
+    });
+  });
+});

package/tests/sandbox.test.ts

@@ -1,23 +1,36 @@
 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';
 
 // Mock dependencies before imports
 vi.mock('./interpreter', () => ({
   CodeInterpreter: vi.fn().mockImplementation(() => ({})),
 }));
 
-vi.mock('@cloudflare/containers', () => ({
-  Container: class Container {
+vi.mock('@cloudflare/containers', () => {
+  const MockContainer = class Container {
     ctx: any;
     env: any;
     constructor(ctx: any, env: any) {
       this.ctx = ctx;
       this.env = env;
     }
-  },
-  getContainer: vi.fn(),
-}));
+    async fetch(request: Request): Promise<Response> {
+      // Mock implementation - will be spied on in tests
+      return new Response('Mock Container fetch');
+    }
+    async containerFetch(request: Request, port: number): Promise<Response> {
+      // Mock implementation for HTTP path
+      return new Response('Mock Container HTTP fetch');
+    }
+  };
+
+  return {
+    Container: MockContainer,
+    getContainer: vi.fn(),
+  };
+});
 
 describe('Sandbox - Automatic Session Management', () => {
   let sandbox: Sandbox;
@@ -462,4 +475,80 @@ describe('Sandbox - Automatic Session Management', () => {
       expect(sandbox.client.ports.exposePort).toHaveBeenCalled();
     });
   });
+
+  describe('fetch() override - WebSocket detection', () => {
+    let superFetchSpy: any;
+
+    beforeEach(async () => {
+      await sandbox.setSandboxName('test-sandbox');
+
+      // Spy on Container.prototype.fetch to verify WebSocket routing
+      superFetchSpy = vi.spyOn(Container.prototype, 'fetch')
+        .mockResolvedValue(new Response('WebSocket response'));
+    });
+
+    afterEach(() => {
+      superFetchSpy?.mockRestore();
+    });
+
+    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',
+        },
+      });
+
+      const response = await sandbox.fetch(request);
+
+      // Should route through super.fetch() for WebSocket
+      expect(superFetchSpy).toHaveBeenCalledTimes(1);
+      expect(await response.text()).toBe('WebSocket response');
+    });
+
+    it('should route non-WebSocket requests through containerFetch', async () => {
+      // GET request
+      const getRequest = new Request('https://example.com/api/data');
+      await sandbox.fetch(getRequest);
+      expect(superFetchSpy).not.toHaveBeenCalled();
+
+      vi.clearAllMocks();
+
+      // POST request
+      const postRequest = new Request('https://example.com/api/data', {
+        method: 'POST',
+        body: JSON.stringify({ data: 'test' }),
+        headers: { 'Content-Type': 'application/json' },
+      });
+      await sandbox.fetch(postRequest);
+      expect(superFetchSpy).not.toHaveBeenCalled();
+
+      vi.clearAllMocks();
+
+      // SSE request (should not be detected as WebSocket)
+      const sseRequest = new Request('https://example.com/events', {
+        headers: { 'Accept': 'text/event-stream' },
+      });
+      await sandbox.fetch(sseRequest);
+      expect(superFetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('should preserve WebSocket request unchanged when calling super.fetch()', async () => {
+      const request = new Request('https://example.com/ws', {
+        headers: {
+          'Upgrade': 'websocket',
+          'Sec-WebSocket-Key': 'test-key-123',
+          'Sec-WebSocket-Version': '13',
+        },
+      });
+
+      await sandbox.fetch(request);
+
+      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('Sec-WebSocket-Version')).toBe('13');
+    });
+  });
 });

package/tests/utility-client.test.ts

@@ -1,7 +1,8 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type {
   CommandsResponse,
-  PingResponse
+  PingResponse,
+  VersionResponse
 } from '../src/clients';
 import { UtilityClient } from '../src/clients/utility-client';
 import {
@@ -25,6 +26,13 @@ const mockCommandsResponse = (commands: string[], overrides: Partial<CommandsRes
   ...overrides
 });
 
+const mockVersionResponse = (version: string = '0.4.5', overrides: Partial<VersionResponse> = {}): VersionResponse => ({
+  success: true,
+  version,
+  timestamp: '2023-01-01T00:00:00Z',
+  ...overrides
+});
+
 describe('UtilityClient', () => {
   let client: UtilityClient;
   let mockFetch: ReturnType<typeof vi.fn>;
@@ -249,6 +257,64 @@ describe('UtilityClient', () => {
     });
   });
 
+  describe('version checking', () => {
+    it('should get container version successfully', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockVersionResponse('0.4.5')),
+        { status: 200 }
+      ));
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('0.4.5');
+    });
+
+    it('should handle different version formats', async () => {
+      const versions = ['1.0.0', '2.5.3-beta', '0.0.1', '10.20.30'];
+
+      for (const version of versions) {
+        mockFetch.mockResolvedValueOnce(new Response(
+          JSON.stringify(mockVersionResponse(version)),
+          { status: 200 }
+        ));
+
+        const result = await client.getVersion();
+        expect(result).toBe(version);
+      }
+    });
+
+    it('should return "unknown" when version endpoint does not exist (backward compatibility)', async () => {
+      // Simulate 404 or other error for old containers
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Not Found' }),
+        { status: 404 }
+      ));
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('unknown');
+    });
+
+    it('should return "unknown" on network failure (backward compatibility)', async () => {
+      mockFetch.mockRejectedValue(new Error('Network connection failed'));
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('unknown');
+    });
+
+    it('should handle version response with unknown value', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify(mockVersionResponse('unknown')),
+        { status: 200 }
+      ));
+
+      const result = await client.getVersion();
+
+      expect(result).toBe('unknown');
+    });
+  });
+
   describe('constructor options', () => {
     it('should initialize with minimal options', () => {
       const minimalClient = new UtilityClient();

package/tests/version.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, test } from 'vitest';
+import packageJson from '../package.json';
+import { SDK_VERSION } from '../src/version';
+
+describe('Version Sync', () => {
+  test('SDK_VERSION matches package.json version', () => {
+    // Verify versions match
+    expect(SDK_VERSION).toBe(packageJson.version);
+  });
+
+  test('SDK_VERSION is a valid semver version', () => {
+    // Check if version matches semver pattern (major.minor.patch)
+    const semverPattern = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+    expect(SDK_VERSION).toMatch(semverPattern);
+  });
+});