@cloudflare/sandbox 0.0.0-aa00a75 → 0.0.0-aeba44f

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');
     });
   });
-});
+});

package/tests/utility-client.test.ts

@@ -1,15 +1,16 @@
 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 {
-  SandboxError
-} from '../src/errors';
+import { SandboxError } from '../src/errors';
 
 // Mock data factory for creating test responses
-const mockPingResponse = (overrides: Partial<PingResponse> = {}): PingResponse => ({
+const mockPingResponse = (
+  overrides: Partial<PingResponse> = {}
+): PingResponse => ({
   success: true,
   message: 'pong',
   uptime: 12345,
@@ -17,7 +18,10 @@ const mockPingResponse = (overrides: Partial<PingResponse> = {}): PingResponse =
   ...overrides
 });
 
-const mockCommandsResponse = (commands: string[], overrides: Partial<CommandsResponse> = {}): CommandsResponse => ({
+const mockCommandsResponse = (
+  commands: string[],
+  overrides: Partial<CommandsResponse> = {}
+): CommandsResponse => ({
   success: true,
   availableCommands: commands,
   count: commands.length,
@@ -25,6 +29,16 @@ 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>;
@@ -37,7 +51,7 @@ describe('UtilityClient', () => {
 
     client = new UtilityClient({
       baseUrl: 'http://test.com',
-      port: 3000,
+      port: 3000
     });
   });
 
@@ -47,10 +61,9 @@ describe('UtilityClient', () => {
 
   describe('health checking', () => {
     it('should check sandbox health successfully', async () => {
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockPingResponse()),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockPingResponse()), { status: 200 })
+      );
 
       const result = await client.ping();
 
@@ -61,10 +74,11 @@ describe('UtilityClient', () => {
       const messages = ['pong', 'alive', 'ok'];
 
       for (const message of messages) {
-        mockFetch.mockResolvedValueOnce(new Response(
-          JSON.stringify(mockPingResponse({ message })),
-          { status: 200 }
-        ));
+        mockFetch.mockResolvedValueOnce(
+          new Response(JSON.stringify(mockPingResponse({ message })), {
+            status: 200
+          })
+        );
 
         const result = await client.ping();
         expect(result).toBe(message);
@@ -79,11 +93,11 @@ describe('UtilityClient', () => {
       const healthChecks = await Promise.all([
         client.ping(),
         client.ping(),
-        client.ping(),
+        client.ping()
       ]);
 
       expect(healthChecks).toHaveLength(3);
-      healthChecks.forEach(result => {
+      healthChecks.forEach((result) => {
         expect(result).toBe('pong');
       });
 
@@ -96,10 +110,9 @@ describe('UtilityClient', () => {
         code: 'HEALTH_CHECK_FAILED'
       };
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 503 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 503 })
+      );
 
       await expect(client.ping()).rejects.toThrow();
     });
@@ -115,10 +128,11 @@ describe('UtilityClient', () => {
     it('should discover available system commands', async () => {
       const systemCommands = ['ls', 'cat', 'echo', 'grep', 'find'];
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse(systemCommands)),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse(systemCommands)), {
+          status: 200
+        })
+      );
 
       const result = await client.getCommands();
 
@@ -131,10 +145,11 @@ describe('UtilityClient', () => {
     it('should handle minimal command environments', async () => {
       const minimalCommands = ['sh', 'echo', 'cat'];
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse(minimalCommands)),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse(minimalCommands)), {
+          status: 200
+        })
+      );
 
       const result = await client.getCommands();
 
@@ -145,10 +160,11 @@ describe('UtilityClient', () => {
     it('should handle large command environments', async () => {
       const richCommands = Array.from({ length: 150 }, (_, i) => `cmd_${i}`);
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse(richCommands)),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse(richCommands)), {
+          status: 200
+        })
+      );
 
       const result = await client.getCommands();
 
@@ -157,10 +173,9 @@ describe('UtilityClient', () => {
     });
 
     it('should handle empty command environments', async () => {
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(mockCommandsResponse([])),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(mockCommandsResponse([])), { status: 200 })
+      );
 
       const result = await client.getCommands();
 
@@ -174,10 +189,9 @@ describe('UtilityClient', () => {
         code: 'PERMISSION_DENIED'
       };
 
-      mockFetch.mockResolvedValue(new Response(
-        JSON.stringify(errorResponse),
-        { status: 403 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response(JSON.stringify(errorResponse), { status: 403 })
+      );
 
       await expect(client.getCommands()).rejects.toThrow();
     });
@@ -185,10 +199,9 @@ describe('UtilityClient', () => {
 
   describe('error handling and resilience', () => {
     it('should handle malformed server responses gracefully', async () => {
-      mockFetch.mockResolvedValue(new Response(
-        'invalid json {',
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValue(
+        new Response('invalid json {', { status: 200 })
+      );
 
       await expect(client.ping()).rejects.toThrow(SandboxError);
     });
@@ -202,10 +215,9 @@ describe('UtilityClient', () => {
 
     it('should handle partial service failures', async () => {
       // First call (ping) succeeds
-      mockFetch.mockResolvedValueOnce(new Response(
-        JSON.stringify(mockPingResponse()),
-        { status: 200 }
-      ));
+      mockFetch.mockResolvedValueOnce(
+        new Response(JSON.stringify(mockPingResponse()), { status: 200 })
+      );
 
       // Second call (getCommands) fails
       const errorResponse = {
@@ -213,10 +225,9 @@ describe('UtilityClient', () => {
         code: 'SERVICE_UNAVAILABLE'
       };
 
-      mockFetch.mockResolvedValueOnce(new Response(
-        JSON.stringify(errorResponse),
-        { status: 503 }
-      ));
+      mockFetch.mockResolvedValueOnce(
+        new Response(JSON.stringify(errorResponse), { status: 503 })
+      );
 
       const pingResult = await client.ping();
       expect(pingResult).toBe('pong');
@@ -231,7 +242,9 @@ describe('UtilityClient', () => {
         if (callCount % 2 === 0) {
           return Promise.reject(new Error('Intermittent failure'));
         } else {
-          return Promise.resolve(new Response(JSON.stringify(mockPingResponse())));
+          return Promise.resolve(
+            new Response(JSON.stringify(mockPingResponse()))
+          );
         }
       });
 
@@ -239,7 +252,7 @@ describe('UtilityClient', () => {
         client.ping(), // Should succeed (call 1)
         client.ping(), // Should fail (call 2)
         client.ping(), // Should succeed (call 3)
-        client.ping(), // Should fail (call 4)
+        client.ping() // Should fail (call 4)
       ]);
 
       expect(results[0].status).toBe('fulfilled');
@@ -249,6 +262,66 @@ 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();
@@ -258,7 +331,7 @@ describe('UtilityClient', () => {
     it('should initialize with full options', () => {
       const fullOptionsClient = new UtilityClient({
         baseUrl: 'http://custom.com',
-        port: 8080,
+        port: 8080
       });
       expect(fullOptionsClient).toBeInstanceOf(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);
+  });
+});

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: 'src/index.ts',
+  outDir: 'dist',
+  dts: {
+    sourcemap: true,
+    resolve: ['@repo/shared']
+  },
+  sourcemap: true,
+  format: 'esm'
+});

package/vitest.config.ts

@@ -18,14 +18,14 @@ export default defineWorkersConfig({
     poolOptions: {
       workers: {
         wrangler: {
-          configPath: './tests/wrangler.jsonc',
+          configPath: './tests/wrangler.jsonc'
         },
         singleWorker: true,
-        isolatedStorage: false,
-      },
-    },
+        isolatedStorage: false
+      }
+    }
   },
   esbuild: {
-    target: 'esnext',
-  },
+    target: 'esnext'
+  }
 });

package/dist/chunk-BCJ7SF3Q.js

@@ -1,117 +0,0 @@
-import {
-  validateLanguage
-} from "./chunk-Z532A7QC.js";
-
-// src/interpreter.ts
-import {
-  Execution,
-  ResultImpl
-} from "@repo/shared";
-var CodeInterpreter = class {
-  interpreterClient;
-  contexts = /* @__PURE__ */ new Map();
-  constructor(sandbox) {
-    this.interpreterClient = sandbox.client.interpreter;
-  }
-  /**
-   * Create a new code execution context
-   */
-  async createCodeContext(options = {}) {
-    validateLanguage(options.language);
-    const context = await this.interpreterClient.createCodeContext(options);
-    this.contexts.set(context.id, context);
-    return context;
-  }
-  /**
-   * Run code with optional context
-   */
-  async runCode(code, options = {}) {
-    let context = options.context;
-    if (!context) {
-      const language = options.language || "python";
-      context = await this.getOrCreateDefaultContext(language);
-    }
-    const execution = new Execution(code, context);
-    await this.interpreterClient.runCodeStream(context.id, code, options.language, {
-      onStdout: (output) => {
-        execution.logs.stdout.push(output.text);
-        if (options.onStdout) return options.onStdout(output);
-      },
-      onStderr: (output) => {
-        execution.logs.stderr.push(output.text);
-        if (options.onStderr) return options.onStderr(output);
-      },
-      onResult: async (result) => {
-        execution.results.push(new ResultImpl(result));
-        if (options.onResult) return options.onResult(result);
-      },
-      onError: (error) => {
-        execution.error = error;
-        if (options.onError) return options.onError(error);
-      }
-    });
-    return execution;
-  }
-  /**
-   * Run code and return a streaming response
-   */
-  async runCodeStream(code, options = {}) {
-    let context = options.context;
-    if (!context) {
-      const language = options.language || "python";
-      context = await this.getOrCreateDefaultContext(language);
-    }
-    const response = await this.interpreterClient.doFetch("/api/execute/code", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "text/event-stream"
-      },
-      body: JSON.stringify({
-        context_id: context.id,
-        code,
-        language: options.language
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({ error: "Unknown error" }));
-      throw new Error(
-        errorData.error || `Failed to execute code: ${response.status}`
-      );
-    }
-    if (!response.body) {
-      throw new Error("No response body for streaming execution");
-    }
-    return response.body;
-  }
-  /**
-   * List all code contexts
-   */
-  async listCodeContexts() {
-    const contexts = await this.interpreterClient.listCodeContexts();
-    for (const context of contexts) {
-      this.contexts.set(context.id, context);
-    }
-    return contexts;
-  }
-  /**
-   * Delete a code context
-   */
-  async deleteCodeContext(contextId) {
-    await this.interpreterClient.deleteCodeContext(contextId);
-    this.contexts.delete(contextId);
-  }
-  async getOrCreateDefaultContext(language) {
-    for (const context of this.contexts.values()) {
-      if (context.language === language) {
-        return context;
-      }
-    }
-    return this.createCodeContext({ language });
-  }
-};
-
-export {
-  CodeInterpreter
-};
-//# sourceMappingURL=chunk-BCJ7SF3Q.js.map

package/dist/chunk-BCJ7SF3Q.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/interpreter.ts"],"sourcesContent":["import {\n  type CodeContext,\n  type CreateContextOptions,\n  Execution,\n  type ExecutionError,\n  type OutputMessage,\n  type Result,\n  ResultImpl,\n  type RunCodeOptions,\n} from \"@repo/shared\";\nimport type { InterpreterClient } from \"./clients/interpreter-client.js\";\nimport type { Sandbox } from \"./sandbox.js\";\nimport { validateLanguage } from \"./security.js\";\n\nexport class CodeInterpreter {\n  private interpreterClient: InterpreterClient;\n  private contexts = new Map<string, CodeContext>();\n\n  constructor(sandbox: Sandbox) {\n    // In init-testing architecture, client is a SandboxClient with an interpreter property\n    this.interpreterClient = (sandbox.client as any).interpreter as InterpreterClient;\n  }\n\n  /**\n   * Create a new code execution context\n   */\n  async createCodeContext(\n    options: CreateContextOptions = {}\n  ): Promise<CodeContext> {\n    // Validate language before sending to container\n    validateLanguage(options.language);\n\n    const context = await this.interpreterClient.createCodeContext(options);\n    this.contexts.set(context.id, context);\n    return context;\n  }\n\n  /**\n   * Run code with optional context\n   */\n  async runCode(\n    code: string,\n    options: RunCodeOptions = {}\n  ): Promise<Execution> {\n    // Get or create context\n    let context = options.context;\n    if (!context) {\n      // Try to find or create a default context for the language\n      const language = options.language || \"python\";\n      context = await this.getOrCreateDefaultContext(language);\n    }\n\n    // Create execution object to collect results\n    const execution = new Execution(code, context);\n\n    // Stream execution\n    await this.interpreterClient.runCodeStream(context.id, code, options.language, {\n      onStdout: (output: OutputMessage) => {\n        execution.logs.stdout.push(output.text);\n        if (options.onStdout) return options.onStdout(output);\n      },\n      onStderr: (output: OutputMessage) => {\n        execution.logs.stderr.push(output.text);\n        if (options.onStderr) return options.onStderr(output);\n      },\n      onResult: async (result: Result) => {\n        execution.results.push(new ResultImpl(result) as any);\n        if (options.onResult) return options.onResult(result);\n      },\n      onError: (error: ExecutionError) => {\n        execution.error = error;\n        if (options.onError) return options.onError(error);\n      },\n    });\n\n    return execution;\n  }\n\n  /**\n   * Run code and return a streaming response\n   */\n  async runCodeStream(\n    code: string,\n    options: RunCodeOptions = {}\n  ): Promise<ReadableStream> {\n    // Get or create context\n    let context = options.context;\n    if (!context) {\n      const language = options.language || \"python\";\n      context = await this.getOrCreateDefaultContext(language);\n    }\n\n    // Create streaming response\n    // Note: doFetch is protected but we need direct access for raw stream response\n    const response = await (this.interpreterClient as any).doFetch(\"/api/execute/code\", {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Accept: \"text/event-stream\",\n      },\n      body: JSON.stringify({\n        context_id: context.id,\n        code,\n        language: options.language,\n      }),\n    });\n\n    if (!response.ok) {\n      const errorData = (await response\n        .json()\n        .catch(() => ({ error: \"Unknown error\" }))) as { error?: string };\n      throw new Error(\n        errorData.error || `Failed to execute code: ${response.status}`\n      );\n    }\n\n    if (!response.body) {\n      throw new Error(\"No response body for streaming execution\");\n    }\n\n    return response.body;\n  }\n\n  /**\n   * List all code contexts\n   */\n  async listCodeContexts(): Promise<CodeContext[]> {\n    const contexts = await this.interpreterClient.listCodeContexts();\n\n    // Update local cache\n    for (const context of contexts) {\n      this.contexts.set(context.id, context);\n    }\n\n    return contexts;\n  }\n\n  /**\n   * Delete a code context\n   */\n  async deleteCodeContext(contextId: string): Promise<void> {\n    await this.interpreterClient.deleteCodeContext(contextId);\n    this.contexts.delete(contextId);\n  }\n\n  private async getOrCreateDefaultContext(\n    language: \"python\" | \"javascript\" | \"typescript\"\n  ): Promise<CodeContext> {\n    // Check if we have a cached context for this language\n    for (const context of this.contexts.values()) {\n      if (context.language === language) {\n        return context;\n      }\n    }\n\n    // Create new default context\n    return this.createCodeContext({ language });\n  }\n}\n"],"mappings":"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","names":[]}