@cloudflare/sandbox 0.4.3 → 0.4.5

package/dist/{sandbox-D9K2ypln.d.ts → sandbox-B1TT7PZP.d.ts}

@@ -1,5 +1,5 @@
 import * as _repo_shared from '@repo/shared';
-import { Logger, MkdirResult, WriteFileResult, ReadFileResult, DeleteFileResult, RenameFileResult, MoveFileResult, ListFilesOptions, ListFilesResult, GitCheckoutResult, CreateContextOptions, CodeContext, OutputMessage, Result, ExecutionError, PortExposeResult, PortCloseResult, PortListResult, ProcessStartResult, ProcessListResult, ProcessInfoResult, ProcessKillResult, ProcessCleanupResult, ProcessLogsResult, ISandbox, ExecOptions, ExecResult, ProcessOptions, Process, StreamOptions, SessionOptions, ExecutionSession, RunCodeOptions, ExecutionResult } from '@repo/shared';
+import { Logger, MkdirResult, WriteFileResult, ReadFileResult, DeleteFileResult, RenameFileResult, MoveFileResult, ListFilesOptions, ListFilesResult, GitCheckoutResult, CreateContextOptions, CodeContext, OutputMessage, Result, ExecutionError, PortExposeResult, PortCloseResult, PortListResult, ProcessStartResult, ProcessListResult, ProcessInfoResult, ProcessKillResult, ProcessCleanupResult, ProcessLogsResult, ISandbox, ExecOptions, ExecResult, ProcessOptions, Process, StreamOptions, SessionOptions, ExecutionSession, RunCodeOptions, ExecutionResult, SandboxOptions } from '@repo/shared';
 import { DurableObject } from 'cloudflare:workers';
 import { Container } from '@cloudflare/containers';
 
@@ -435,12 +435,10 @@ declare class SandboxClient {
     constructor(options: HttpClientOptions);
 }
 
-declare function getSandbox(ns: DurableObjectNamespace<Sandbox>, id: string, options?: {
-    baseUrl: string;
-}): DurableObjectStub<Sandbox<unknown>>;
+declare function getSandbox(ns: DurableObjectNamespace<Sandbox>, id: string, options?: SandboxOptions): DurableObjectStub<Sandbox<unknown>>;
 declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
     defaultPort: number;
-    sleepAfter: string;
+    sleepAfter: string | number;
     client: SandboxClient;
     private codeInterpreter;
     private sandboxName;
@@ -452,6 +450,7 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
     constructor(ctx: DurableObject['ctx'], env: Env);
     setSandboxName(name: string): Promise<void>;
     setBaseUrl(baseUrl: string): Promise<void>;
+    setSleepAfter(sleepAfter: string | number): Promise<void>;
     setEnvVars(envVars: Record<string, string>): Promise<void>;
     /**
      * Cleanup and destroy the sandbox container
@@ -465,6 +464,10 @@ declare class Sandbox<Env = unknown> extends Container<Env> implements ISandbox
     /**
      * Ensure default session exists - lazy initialization
      * This is called automatically by all public methods that need a session
+     *
+     * The session is persisted to Durable Object storage to survive hot reloads
+     * during development. If a session already exists in the container after reload,
+     * we reuse it instead of trying to create a new one.
      */
     private ensureDefaultSession;
     exec(command: string, options?: ExecOptions): Promise<ExecResult>;

package/dist/sandbox.d.ts

@@ -1,4 +1,4 @@
 import '@repo/shared';
 import 'cloudflare:workers';
 import '@cloudflare/containers';
-export { b as Sandbox, g as getSandbox } from './sandbox-D9K2ypln.js';
+export { b as Sandbox, g as getSandbox } from './sandbox-B1TT7PZP.js';

package/dist/sandbox.js

@@ -1,7 +1,7 @@
 import {
   Sandbox,
   getSandbox
-} from "./chunk-EXQOIRZI.js";
+} from "./chunk-WK36EMRB.js";
 import "./chunk-JXZMAU2C.js";
 import "./chunk-Z532A7QC.js";
 import "./chunk-EKSWCBCA.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/sandbox",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "repository": {
     "type": "git",
     "url": "https://github.com/cloudflare/sandbox-sdk"

package/src/sandbox.ts

@@ -13,6 +13,7 @@ import type {
   ProcessOptions,
   ProcessStatus,
   RunCodeOptions,
+  SandboxOptions,
   SessionOptions,
   StreamOptions
 } from "@repo/shared";
@@ -29,24 +30,30 @@ import {
 } from "./security";
 import { parseSSEStream } from "./sse-parser";
 
-export function getSandbox(ns: DurableObjectNamespace<Sandbox>, id: string, options?: {
-  baseUrl: string
-}) {
+export function getSandbox(
+  ns: DurableObjectNamespace<Sandbox>,
+  id: string,
+  options?: SandboxOptions
+) {
   const stub = getContainer(ns, id);
 
   // Store the name on first access
   stub.setSandboxName?.(id);
 
-  if(options?.baseUrl) {
+  if (options?.baseUrl) {
     stub.setBaseUrl(options.baseUrl);
   }
 
+  if (options?.sleepAfter !== undefined) {
+    stub.setSleepAfter(options.sleepAfter);
+  }
+
   return stub;
 }
 
 export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
   defaultPort = 3000; // Default port for the container's Bun server
-  sleepAfter = "3m"; // Sleep the sandbox if no requests are made in this timeframe
+  sleepAfter: string | number = "10m"; // Sleep the sandbox if no requests are made in this timeframe
 
   client: SandboxClient;
   private codeInterpreter: CodeInterpreter;
@@ -84,9 +91,10 @@ export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
     // The CodeInterpreter extracts client.interpreter from the sandbox
     this.codeInterpreter = new CodeInterpreter(this);
 
-    // Load the sandbox name and port tokens from storage on initialization
+    // Load the sandbox name, port tokens, and default session from storage on initialization
     this.ctx.blockConcurrencyWhile(async () => {
       this.sandboxName = await this.ctx.storage.get<string>('sandboxName') || null;
+      this.defaultSession = await this.ctx.storage.get<string>('defaultSession') || null;
       const storedTokens = await this.ctx.storage.get<Record<string, string>>('portTokens') || {};
 
       // Convert stored tokens back to Map
@@ -117,6 +125,11 @@ export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
     }
   }
 
+  // RPC method to set the sleep timeout
+  async setSleepAfter(sleepAfter: string | number): Promise<void> {
+    this.sleepAfter = sleepAfter;
+  }
+
   // RPC method to set environment variables
   async setEnvVars(envVars: Record<string, string>): Promise<void> {
     // Update local state for new sessions
@@ -199,20 +212,39 @@ export class Sandbox<Env = unknown> extends Container<Env> implements ISandbox {
   /**
    * Ensure default session exists - lazy initialization
    * This is called automatically by all public methods that need a session
+   *
+   * The session is persisted to Durable Object storage to survive hot reloads
+   * during development. If a session already exists in the container after reload,
+   * we reuse it instead of trying to create a new one.
    */
   private async ensureDefaultSession(): Promise<string> {
     if (!this.defaultSession) {
       const sessionId = `sandbox-${this.sandboxName || 'default'}`;
 
-      // Create session in container
-      await this.client.utils.createSession({
-        id: sessionId,
-        env: this.envVars || {},
-        cwd: '/workspace',
-      });
-
-      this.defaultSession = sessionId;
-      this.logger.debug('Default session initialized', { sessionId });
+      try {
+        // Try to create session in container
+        await this.client.utils.createSession({
+          id: sessionId,
+          env: this.envVars || {},
+          cwd: '/workspace',
+        });
+
+        this.defaultSession = sessionId;
+        // Persist to storage so it survives hot reloads
+        await this.ctx.storage.put('defaultSession', sessionId);
+        this.logger.debug('Default session initialized', { sessionId });
+      } catch (error: any) {
+        // If session already exists (e.g., after hot reload), reuse it
+        if (error?.message?.includes('already exists') || error?.message?.includes('Session')) {
+          this.logger.debug('Reusing existing session after reload', { sessionId });
+          this.defaultSession = sessionId;
+          // Persist to storage in case it wasn't saved before
+          await this.ctx.storage.put('defaultSession', sessionId);
+        } else {
+          // Re-throw other errors
+          throw error;
+        }
+      }
     }
     return this.defaultSession;
   }

package/tests/get-sandbox.test.ts

@@ -0,0 +1,110 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getSandbox } from '../src/sandbox';
+
+// Mock the Container module
+vi.mock('@cloudflare/containers', () => ({
+  Container: class Container {
+    ctx: any;
+    env: any;
+    sleepAfter: string | number = '10m';
+    constructor(ctx: any, env: any) {
+      this.ctx = ctx;
+      this.env = env;
+    }
+  },
+  getContainer: vi.fn(),
+}));
+
+describe('getSandbox', () => {
+  let mockStub: any;
+  let mockGetContainer: any;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+
+    // Create a fresh mock stub for each test
+    mockStub = {
+      sleepAfter: '10m',
+      setSandboxName: vi.fn(),
+      setBaseUrl: vi.fn(),
+      setSleepAfter: vi.fn((value: string | number) => {
+        mockStub.sleepAfter = value;
+      }),
+    };
+
+    // Mock getContainer to return our stub
+    const containers = await import('@cloudflare/containers');
+    mockGetContainer = vi.mocked(containers.getContainer);
+    mockGetContainer.mockReturnValue(mockStub);
+  });
+
+  it('should create a sandbox instance with default sleepAfter', () => {
+    const mockNamespace = {} as any;
+    const sandbox = getSandbox(mockNamespace, 'test-sandbox');
+
+    expect(sandbox).toBeDefined();
+    expect(sandbox.setSandboxName).toHaveBeenCalledWith('test-sandbox');
+  });
+
+  it('should apply sleepAfter option when provided as string', () => {
+    const mockNamespace = {} as any;
+    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
+      sleepAfter: '5m',
+    });
+
+    expect(sandbox.sleepAfter).toBe('5m');
+  });
+
+  it('should apply sleepAfter option when provided as number', () => {
+    const mockNamespace = {} as any;
+    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
+      sleepAfter: 300, // 5 minutes in seconds
+    });
+
+    expect(sandbox.sleepAfter).toBe(300);
+  });
+
+  it('should apply baseUrl option when provided', () => {
+    const mockNamespace = {} as any;
+    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
+      baseUrl: 'https://example.com',
+    });
+
+    expect(sandbox.setBaseUrl).toHaveBeenCalledWith('https://example.com');
+  });
+
+  it('should apply both sleepAfter and baseUrl options together', () => {
+    const mockNamespace = {} as any;
+    const sandbox = getSandbox(mockNamespace, 'test-sandbox', {
+      sleepAfter: '10m',
+      baseUrl: 'https://example.com',
+    });
+
+    expect(sandbox.sleepAfter).toBe('10m');
+    expect(sandbox.setBaseUrl).toHaveBeenCalledWith('https://example.com');
+  });
+
+  it('should not apply sleepAfter when not provided', () => {
+    const mockNamespace = {} as any;
+    const sandbox = getSandbox(mockNamespace, 'test-sandbox');
+
+    // Should remain default value from Container
+    expect(sandbox.sleepAfter).toBe('10m');
+  });
+
+  it('should accept various time string formats for sleepAfter', () => {
+    const mockNamespace = {} as any;
+    const testCases = ['30s', '1m', '10m', '1h', '2h'];
+
+    for (const timeString of testCases) {
+      // Reset the mock stub for each iteration
+      mockStub.sleepAfter = '3m';
+
+      const sandbox = getSandbox(mockNamespace, `test-sandbox-${timeString}`, {
+        sleepAfter: timeString,
+      });
+
+      expect(sandbox.sleepAfter).toBe(timeString);
+    }
+  });
+});