@cloudflare/sandbox 0.3.7 → 0.4.2

package/tests/file-stream.test.ts

@@ -0,0 +1,306 @@
+import type { FileMetadata } from '@repo/shared';
+import { describe, expect, it } from 'vitest';
+import { collectFile, streamFile } from '../src/file-stream';
+
+describe('File Streaming Utilities', () => {
+  /**
+   * Helper to create a mock SSE stream for testing
+   */
+  function createMockSSEStream(events: string[]): ReadableStream<Uint8Array> {
+    return new ReadableStream({
+      start(controller) {
+        for (const event of events) {
+          controller.enqueue(new TextEncoder().encode(event));
+        }
+        controller.close();
+      }
+    });
+  }
+
+  describe('streamFile', () => {
+    it('should stream text file chunks and return metadata', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"text/plain","size":11,"isBinary":false,"encoding":"utf-8"}\n\n',
+        'data: {"type":"chunk","data":"Hello"}\n\n',
+        'data: {"type":"chunk","data":" World"}\n\n',
+        'data: {"type":"complete","bytesRead":11}\n\n',
+      ]);
+
+      const chunks: string[] = [];
+      const generator = streamFile(stream);
+      let result = await generator.next();
+
+      // Collect chunks
+      while (!result.done) {
+        chunks.push(result.value as string);
+        result = await generator.next();
+      }
+
+      // Metadata is the return value
+      const metadata = result.value;
+
+      expect(chunks).toEqual(['Hello', ' World']);
+      expect(metadata).toEqual({
+        mimeType: 'text/plain',
+        size: 11,
+        isBinary: false,
+        encoding: 'utf-8',
+      });
+    });
+
+    it('should stream binary file with base64 decoding', async () => {
+      // Base64 encoded "test" = "dGVzdA=="
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"image/png","size":4,"isBinary":true,"encoding":"base64"}\n\n',
+        'data: {"type":"chunk","data":"dGVzdA=="}\n\n',
+        'data: {"type":"complete","bytesRead":4}\n\n',
+      ]);
+
+      const chunks: (string | Uint8Array)[] = [];
+      const generator = streamFile(stream);
+      let result = await generator.next();
+
+      // Collect chunks
+      while (!result.done) {
+        chunks.push(result.value);
+        result = await generator.next();
+      }
+
+      const metadata = result.value;
+
+      // For binary files, chunks should be Uint8Array
+      expect(chunks.length).toBeGreaterThan(0);
+      expect(chunks[0]).toBeInstanceOf(Uint8Array);
+
+      // Verify we can reconstruct the original data
+      const allBytes = new Uint8Array(
+        chunks.reduce((acc, chunk) => {
+          if (chunk instanceof Uint8Array) {
+            return acc + chunk.length;
+          }
+          return acc;
+        }, 0)
+      );
+
+      let offset = 0;
+      for (const chunk of chunks) {
+        if (chunk instanceof Uint8Array) {
+          allBytes.set(chunk, offset);
+          offset += chunk.length;
+        }
+      }
+
+      const decoded = new TextDecoder().decode(allBytes);
+      expect(decoded).toBe('test');
+
+      expect(metadata?.isBinary).toBe(true);
+      expect(metadata?.encoding).toBe('base64');
+      expect(metadata?.mimeType).toBe('image/png');
+    });
+
+    it('should handle empty files', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"text/plain","size":0,"isBinary":false,"encoding":"utf-8"}\n\n',
+        'data: {"type":"complete","bytesRead":0}\n\n',
+      ]);
+
+      const chunks: string[] = [];
+      const generator = streamFile(stream);
+      let result = await generator.next();
+
+      while (!result.done) {
+        chunks.push(result.value as string);
+        result = await generator.next();
+      }
+
+      const metadata = result.value;
+
+      expect(chunks).toEqual([]);
+      expect(metadata?.size).toBe(0);
+    });
+
+    it('should handle error events', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"text/plain","size":100,"isBinary":false,"encoding":"utf-8"}\n\n',
+        'data: {"type":"chunk","data":"Hello"}\n\n',
+        'data: {"type":"error","error":"Read error: Permission denied"}\n\n',
+      ]);
+
+      const generator = streamFile(stream);
+
+      try {
+        let result = await generator.next();
+        while (!result.done) {
+          result = await generator.next();
+        }
+        // Should have thrown
+        expect(true).toBe(false);
+      } catch (error) {
+        expect((error as Error).message).toContain('Read error: Permission denied');
+      }
+    });
+  });
+
+  describe('collectFile', () => {
+    it('should collect entire text file into string', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"text/plain","size":11,"isBinary":false,"encoding":"utf-8"}\n\n',
+        'data: {"type":"chunk","data":"Hello"}\n\n',
+        'data: {"type":"chunk","data":" World"}\n\n',
+        'data: {"type":"complete","bytesRead":11}\n\n',
+      ]);
+
+      const result = await collectFile(stream);
+
+      expect(result.content).toBe('Hello World');
+      expect(result.metadata).toEqual({
+        mimeType: 'text/plain',
+        size: 11,
+        isBinary: false,
+        encoding: 'utf-8',
+      });
+    });
+
+    it('should collect entire binary file into Uint8Array', async () => {
+      // Base64 encoded "test" = "dGVzdA=="
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"image/png","size":4,"isBinary":true,"encoding":"base64"}\n\n',
+        'data: {"type":"chunk","data":"dGVzdA=="}\n\n',
+        'data: {"type":"complete","bytesRead":4}\n\n',
+      ]);
+
+      const result = await collectFile(stream);
+
+      expect(result.content).toBeInstanceOf(Uint8Array);
+      expect(result.metadata.isBinary).toBe(true);
+
+      // Decode to verify content
+      const decoded = new TextDecoder().decode(result.content as Uint8Array);
+      expect(decoded).toBe('test');
+    });
+
+    it('should handle empty files', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"text/plain","size":0,"isBinary":false,"encoding":"utf-8"}\n\n',
+        'data: {"type":"complete","bytesRead":0}\n\n',
+      ]);
+
+      const result = await collectFile(stream);
+
+      expect(result.content).toBe('');
+      expect(result.metadata.size).toBe(0);
+    });
+
+    it('should propagate errors from stream', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"text/plain","size":100,"isBinary":false,"encoding":"utf-8"}\n\n',
+        'data: {"type":"chunk","data":"Hello"}\n\n',
+        'data: {"type":"error","error":"File not found"}\n\n',
+      ]);
+
+      await expect(collectFile(stream)).rejects.toThrow('File not found');
+    });
+
+    it('should handle large text files efficiently', async () => {
+      // Create a stream with many chunks
+      const chunkCount = 100;
+      const events = [
+        'data: {"type":"metadata","mimeType":"text/plain","size":500,"isBinary":false,"encoding":"utf-8"}\n\n',
+      ];
+
+      for (let i = 0; i < chunkCount; i++) {
+        events.push(`data: {"type":"chunk","data":"chunk${i}"}\n\n`);
+      }
+
+      events.push('data: {"type":"complete","bytesRead":500}\n\n');
+
+      const stream = createMockSSEStream(events);
+      const result = await collectFile(stream);
+
+      expect(typeof result.content).toBe('string');
+      expect(result.content).toContain('chunk0');
+      expect(result.content).toContain('chunk99');
+      expect(result.metadata.encoding).toBe('utf-8');
+    });
+
+    it('should handle large binary files efficiently', async () => {
+      // Create a stream with many base64 chunks
+      const chunkCount = 100;
+      const events = [
+        'data: {"type":"metadata","mimeType":"application/octet-stream","size":400,"isBinary":true,"encoding":"base64"}\n\n',
+      ];
+
+      for (let i = 0; i < chunkCount; i++) {
+        // Each "AAAA" base64 chunk decodes to 3 bytes (0x00, 0x00, 0x00)
+        events.push('data: {"type":"chunk","data":"AAAA"}\n\n');
+      }
+
+      events.push('data: {"type":"complete","bytesRead":400}\n\n');
+
+      const stream = createMockSSEStream(events);
+      const result = await collectFile(stream);
+
+      expect(result.content).toBeInstanceOf(Uint8Array);
+      expect((result.content as Uint8Array).length).toBeGreaterThan(0);
+      expect(result.metadata.isBinary).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle streams with no metadata event', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"chunk","data":"Hello"}\n\n',
+        'data: {"type":"complete","bytesRead":5}\n\n',
+      ]);
+
+      // Without metadata, we don't know if it's binary or text
+      // The implementation should throw
+      const generator = streamFile(stream);
+
+      try {
+        let result = await generator.next();
+        while (!result.done) {
+          result = await generator.next();
+        }
+        // Should have thrown
+        expect(true).toBe(false);
+      } catch (error) {
+        expect((error as Error).message).toContain('Received chunk before metadata');
+      }
+    });
+
+    it('should handle malformed JSON in SSE events', async () => {
+      const stream = createMockSSEStream([
+        'data: {"type":"metadata","mimeType":"text/plain","size":5,"isBinary":false,"encoding":"utf-8"}\n\n',
+        'data: {invalid json\n\n',
+        'data: {"type":"complete","bytesRead":5}\n\n',
+      ]);
+
+      // Malformed JSON is logged but doesn't break the stream
+      // It should complete successfully but with no chunks
+      const result = await collectFile(stream);
+      expect(result.content).toBe('');
+    });
+
+    it('should handle base64 padding correctly', async () => {
+      // Test various base64 strings with different padding
+      const testCases = [
+        { input: 'YQ==', expected: 'a' },      // 1 byte, 2 padding
+        { input: 'YWI=', expected: 'ab' },    // 2 bytes, 1 padding
+        { input: 'YWJj', expected: 'abc' },   // 3 bytes, no padding
+      ];
+
+      for (const testCase of testCases) {
+        const stream = createMockSSEStream([
+          `data: {"type":"metadata","mimeType":"application/octet-stream","size":${testCase.expected.length},"isBinary":true,"encoding":"base64"}\n\n`,
+          `data: {"type":"chunk","data":"${testCase.input}"}\n\n`,
+          `data: {"type":"complete","bytesRead":${testCase.expected.length}}\n\n`,
+        ]);
+
+        const result = await collectFile(stream);
+        const decoded = new TextDecoder().decode(result.content as Uint8Array);
+        expect(decoded).toBe(testCase.expected);
+      }
+    });
+  });
+});

package/tests/git-client.test.ts

@@ -0,0 +1,328 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { GitCheckoutResponse } from '../src/clients';
+import { GitClient } from '../src/clients/git-client';
+import {
+  GitAuthenticationError,
+  GitBranchNotFoundError,
+  GitCheckoutError,
+  GitCloneError,
+  GitError,
+  GitNetworkError,
+  GitRepositoryNotFoundError,
+  InvalidGitUrlError,
+  SandboxError
+} from '../src/errors';
+
+describe('GitClient', () => {
+  let client: GitClient;
+  let mockFetch: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockFetch = vi.fn();
+    global.fetch = mockFetch as unknown as typeof fetch;
+    
+    client = new GitClient({
+      baseUrl: 'http://test.com',
+      port: 3000,
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('repository cloning', () => {
+    it('should clone public repositories successfully', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'react\'...\nReceiving objects: 100% (1284/1284), done.',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'https://github.com/facebook/react.git',
+        branch: 'main',
+        targetDir: 'react',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('https://github.com/facebook/react.git', 'test-session');
+
+      expect(result.success).toBe(true);
+      expect(result.repoUrl).toBe('https://github.com/facebook/react.git');
+      expect(result.branch).toBe('main');
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should clone repositories to specific branches', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'project\'...\nSwitching to branch \'development\'',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'https://github.com/company/project.git',
+        branch: 'development',
+        targetDir: 'project',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout(
+        'https://github.com/company/project.git',
+        'test-session',
+        { branch: 'development' }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.branch).toBe('development');
+    });
+
+    it('should clone repositories to custom directories', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'workspace/my-app\'...\nDone.',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'https://github.com/user/my-app.git',
+        branch: 'main',
+        targetDir: 'workspace/my-app',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout(
+        'https://github.com/user/my-app.git',
+        'test-session',
+        { targetDir: 'workspace/my-app' }
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.targetDir).toBe('workspace/my-app');
+    });
+
+    it('should handle large repository clones with warnings', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'linux\'...\nReceiving objects: 100% (8125432/8125432), 2.34 GiB, done.',
+        stderr: 'warning: filtering not recognized by server',
+        exitCode: 0,
+        repoUrl: 'https://github.com/torvalds/linux.git',
+        branch: 'master',
+        targetDir: 'linux',
+        timestamp: '2023-01-01T00:05:30Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('https://github.com/torvalds/linux.git', 'test-session');
+
+      expect(result.success).toBe(true);
+      expect(result.stderr).toContain('warning:');
+    });
+
+    it('should handle SSH repository URLs', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: true,
+        stdout: 'Cloning into \'private-project\'...\nDone.',
+        stderr: '',
+        exitCode: 0,
+        repoUrl: 'git@github.com:company/private-project.git',
+        branch: 'main',
+        targetDir: 'private-project',
+        timestamp: '2023-01-01T00:00:00Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('git@github.com:company/private-project.git', 'test-session');
+
+      expect(result.success).toBe(true);
+      expect(result.repoUrl).toBe('git@github.com:company/private-project.git');
+    });
+
+    it('should handle concurrent repository operations', async () => {
+      mockFetch.mockImplementation((url: string, options: RequestInit) => {
+        const body = JSON.parse(options.body as string);
+        const repoName = body.repoUrl.split('/').pop().replace('.git', '');
+
+        return Promise.resolve(new Response(JSON.stringify({
+          success: true,
+          stdout: `Cloning into '${repoName}'...\nDone.`,
+          stderr: '',
+          exitCode: 0,
+          repoUrl: body.repoUrl,
+          branch: body.branch || 'main',
+          targetDir: body.targetDir || repoName,
+          timestamp: new Date().toISOString(),
+        })));
+      });
+
+      const operations = await Promise.all([
+        client.checkout('https://github.com/facebook/react.git', 'session-1'),
+        client.checkout('https://github.com/microsoft/vscode.git', 'session-2'),
+        client.checkout('https://github.com/nodejs/node.git', 'session-3', { branch: 'v18.x' }),
+      ]);
+
+      expect(operations).toHaveLength(3);
+      operations.forEach(result => {
+        expect(result.success).toBe(true);
+      });
+      expect(mockFetch).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe('repository error handling', () => {
+    it('should handle repository not found errors', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Repository not found', code: 'GIT_REPOSITORY_NOT_FOUND' }),
+        { status: 404 }
+      ));
+
+      await expect(client.checkout('https://github.com/user/nonexistent.git', 'test-session'))
+        .rejects.toThrow(GitRepositoryNotFoundError);
+    });
+
+    it('should handle authentication failures', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Authentication failed', code: 'GIT_AUTH_FAILED' }),
+        { status: 401 }
+      ));
+
+      await expect(client.checkout('https://github.com/company/private.git', 'test-session'))
+        .rejects.toThrow(GitAuthenticationError);
+    });
+
+    it('should handle branch not found errors', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Branch not found', code: 'GIT_BRANCH_NOT_FOUND' }),
+        { status: 404 }
+      ));
+
+      await expect(client.checkout(
+        'https://github.com/user/repo.git',
+        'test-session',
+        { branch: 'nonexistent-branch' }
+      )).rejects.toThrow(GitBranchNotFoundError);
+    });
+
+    it('should handle network errors', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Network error', code: 'GIT_NETWORK_ERROR' }),
+        { status: 503 }
+      ));
+
+      await expect(client.checkout('https://github.com/user/repo.git', 'test-session'))
+        .rejects.toThrow(GitNetworkError);
+    });
+
+    it('should handle clone failures', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Clone failed', code: 'GIT_CLONE_FAILED' }),
+        { status: 507 }
+      ));
+
+      await expect(client.checkout('https://github.com/large/repository.git', 'test-session'))
+        .rejects.toThrow(GitCloneError);
+    });
+
+    it('should handle checkout failures', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Checkout failed', code: 'GIT_CHECKOUT_FAILED' }),
+        { status: 409 }
+      ));
+
+      await expect(client.checkout(
+        'https://github.com/user/repo.git',
+        'test-session',
+        { branch: 'feature-branch' }
+      )).rejects.toThrow(GitCheckoutError);
+    });
+
+    it('should handle invalid Git URLs', async () => {
+      mockFetch.mockResolvedValue(new Response(
+        JSON.stringify({ error: 'Invalid Git URL', code: 'INVALID_GIT_URL' }),
+        { status: 400 }
+      ));
+
+      await expect(client.checkout('not-a-valid-url', 'test-session'))
+        .rejects.toThrow(InvalidGitUrlError);
+    });
+
+    it('should handle partial clone failures', async () => {
+      const mockResponse: GitCheckoutResponse = {
+        success: false,
+        stdout: 'Cloning into \'repo\'...\nReceiving objects:  45% (450/1000)',
+        stderr: 'error: RPC failed\nfatal: early EOF',
+        exitCode: 128,
+        repoUrl: 'https://github.com/problematic/repo.git',
+        branch: 'main',
+        targetDir: 'repo',
+        timestamp: '2023-01-01T00:01:30Z',
+      };
+
+      mockFetch.mockResolvedValue(new Response(JSON.stringify(mockResponse), { status: 200 }));
+
+      const result = await client.checkout('https://github.com/problematic/repo.git', 'test-session');
+
+      expect(result.success).toBe(false);
+      expect(result.exitCode).toBe(128);
+      expect(result.stderr).toContain('RPC failed');
+    });
+  });
+
+  describe('error handling edge cases', () => {
+    it('should handle network failures', async () => {
+      mockFetch.mockRejectedValue(new Error('Network connection failed'));
+
+      await expect(client.checkout('https://github.com/user/repo.git', 'test-session'))
+        .rejects.toThrow('Network connection failed');
+    });
+
+    it('should handle malformed server responses', async () => {
+      mockFetch.mockResolvedValue(new Response('invalid json {', { status: 200 }));
+
+      await expect(client.checkout('https://github.com/user/repo.git', 'test-session'))
+        .rejects.toThrow(SandboxError);
+    });
+
+    it('should map server errors to client errors', async () => {
+      const serverErrorScenarios = [
+        { status: 400, code: 'INVALID_GIT_URL', error: InvalidGitUrlError },
+        { status: 401, code: 'GIT_AUTH_FAILED', error: GitAuthenticationError },
+        { status: 404, code: 'GIT_REPOSITORY_NOT_FOUND', error: GitRepositoryNotFoundError },
+        { status: 404, code: 'GIT_BRANCH_NOT_FOUND', error: GitBranchNotFoundError },
+        { status: 500, code: 'GIT_OPERATION_FAILED', error: GitError },
+        { status: 503, code: 'GIT_NETWORK_ERROR', error: GitNetworkError },
+      ];
+
+      for (const scenario of serverErrorScenarios) {
+        mockFetch.mockResolvedValueOnce(new Response(
+          JSON.stringify({ error: 'Test error', code: scenario.code }),
+          { status: scenario.status }
+        ));
+
+        await expect(client.checkout('https://github.com/test/repo.git', 'test-session'))
+          .rejects.toThrow(scenario.error);
+      }
+    });
+  });
+
+  describe('constructor options', () => {
+    it('should initialize with minimal options', () => {
+      const minimalClient = new GitClient();
+      expect(minimalClient).toBeInstanceOf(GitClient);
+    });
+
+    it('should initialize with full options', () => {
+      const fullOptionsClient = new GitClient({
+        baseUrl: 'http://custom.com',
+        port: 8080,
+      });
+      expect(fullOptionsClient).toBeInstanceOf(GitClient);
+    });
+  });
+});