resume

Method signature

async resume(): Promise<void>

Parameters

This method takes no parameters.

Return value

Type	Description
`Promise<void>`	The method completes successfully when the sandbox is resumed

Behavior

The resume() method performs the following actions:

Agent Type Validation: Verifies that the current agent is of type “codex”
Initialization Check: Ensures the CodexAgent instance is properly initialized
Sandbox Resumption: Calls the underlying resumeSandbox() method to resume the paused sandbox

Examples

Basic Usage

const vibeKit = new VibeKit({
  agent: {
    type: "codex",
    // ... other config
  }
});

// Generate some code first to create a sandbox
await vibeKit.generateCode("console.log('Hello World')", "code");

// Pause the sandbox
await vibeKit.pause();
console.log("Sandbox paused");

// Resume the sandbox
await vibeKit.resume();
console.log("Sandbox resumed - ready for more operations");

// Continue generating code
await vibeKit.generateCode("console.log('Back online!')", "code");

With Error Handling

try {
  await vibeKit.resume();
  console.log("Sandbox resumed successfully");
} catch (error) {
  if (error.message.includes("only supported for the Codex agent")) {
    console.error("Resume operation requires Codex agent");
  } else if (error.message.includes("not initialized")) {
    console.error("CodexAgent not properly initialized");
  } else {
    console.error("Failed to resume sandbox:", error.message);
  }
}

State Management Pattern

class SandboxStateManager {
  private vibeKit: VibeKit;
  private state: 'active' | 'paused' | 'killed' = 'active';

  constructor(config: VibeKitConfig) {
    this.vibeKit = new VibeKit(config);
  }

  async pause() {
    if (this.state === 'active') {
      await this.vibeKit.pause();
      this.state = 'paused';
      console.log("Sandbox paused");
    }
  }

  async resume() {
    if (this.state === 'paused') {
      await this.vibeKit.resume();
      this.state = 'active';
      console.log("Sandbox resumed");
    }
  }

  async generateCode(prompt: string) {
    // Auto-resume if paused
    if (this.state === 'paused') {
      await this.resume();
    }
    
    if (this.state === 'killed') {
      throw new Error("Cannot generate code: sandbox has been killed");
    }
    
    return await this.vibeKit.generateCode(prompt, "code");
  }

  getState() {
    return this.state;
  }
}

Auto-Resume on Activity

class SmartSandbox {
  private vibeKit: VibeKit;
  private isPaused: boolean = false;

  constructor(config: VibeKitConfig) {
    this.vibeKit = new VibeKit(config);
  }

  async ensureActive() {
    if (this.isPaused) {
      await this.vibeKit.resume();
      this.isPaused = false;
      console.log("Sandbox auto-resumed");
    }
  }

  async generateCode(prompt: string) {
    // Auto-resume before generating code
    await this.ensureActive();
    return await this.vibeKit.generateCode(prompt, "code");
  }

  async pauseManually() {
    if (!this.isPaused) {
      await this.vibeKit.pause();
      this.isPaused = true;
      console.log("Sandbox paused manually");
    }
  }
}

Scheduled Resume

class ScheduledSandbox {
  private vibeKit: VibeKit;
  private resumeTimer: NodeJS.Timeout | null = null;

  constructor(config: VibeKitConfig) {
    this.vibeKit = new VibeKit(config);
  }

  async pauseWithScheduledResume(resumeInMinutes: number) {
    // Pause sandbox
    await this.vibeKit.pause();
    console.log(`Sandbox paused. Will resume in ${resumeInMinutes} minutes.`);

    // Schedule resume
    this.resumeTimer = setTimeout(async () => {
      try {
        await this.vibeKit.resume();
        console.log("Sandbox automatically resumed");
      } catch (error) {
        console.error("Failed to auto-resume sandbox:", error);
      }
    }, resumeInMinutes * 60 * 1000);
  }

  async resumeNow() {
    // Clear scheduled resume
    if (this.resumeTimer) {
      clearTimeout(this.resumeTimer);
      this.resumeTimer = null;
    }

    // Resume immediately
    await this.vibeKit.resume();
    console.log("Sandbox resumed immediately");
  }

  async cleanup() {
    if (this.resumeTimer) {
      clearTimeout(this.resumeTimer);
    }
    await this.vibeKit.kill();
  }
}

Error handling

The method throws errors in the following cases:

Agent Type Error

// When using non-Codex agent
throw new Error("Sandbox management is only supported for the Codex agent");

Initialization Error

// When CodexAgent is not initialized
throw new Error("CodexAgent not initialized");

Example Error Handling

try {
  await vibeKit.resume();
} catch (error) {
  switch (true) {
    case error.message.includes("only supported for the Codex agent"):
      // Handle agent type mismatch
      console.error("This operation requires a Codex agent");
      break;
    
    case error.message.includes("not initialized"):
      // Handle initialization error
      console.error("Agent not properly initialized");
      break;
    
    default:
      // Handle other sandbox-related errors
      console.error("Sandbox resume failed:", error.message);
  }
}

Use Cases

Morning Startup Routine

Resume sandboxes at the start of the workday:

class DailySandboxManager {
  private vibeKit: VibeKit;

  constructor(config: VibeKitConfig) {
    this.vibeKit = new VibeKit(config);
  }

  async morningStartup() {
    console.log("Starting daily sandbox routine...");
    
    try {
      await this.vibeKit.resume();
      console.log("✅ Sandbox resumed for the day");
      
      // Run any initialization code
      await this.vibeKit.generateCode("echo 'Good morning! Sandbox is ready.'", "code");
      
    } catch (error) {
      console.error("❌ Failed to start sandbox:", error);
      throw error;
    }
  }

  async eveningShutdown() {
    console.log("Ending daily sandbox routine...");
    await this.vibeKit.pause();
    console.log("✅ Sandbox paused for the night");
  }
}

On-Demand Resumption

Resume only when needed to save resources:

class OnDemandSandbox {
  private vibeKit: VibeKit;
  private isActive: boolean = false;

  constructor(config: VibeKitConfig) {
    this.vibeKit = new VibeKit(config);
  }

  async processRequest(prompt: string) {
    if (!this.isActive) {
      console.log("Resuming sandbox for request...");
      await this.vibeKit.resume();
      this.isActive = true;
    }

    const response = await this.vibeKit.generateCode(prompt, "code");
    
    // Auto-pause after 30 seconds of inactivity
    setTimeout(async () => {
      if (this.isActive) {
        await this.vibeKit.pause();
        this.isActive = false;
        console.log("Sandbox auto-paused after inactivity");
      }
    }, 30000);

    return response;
  }
}

Recovery from Breaks

Resume after planned breaks or maintenance:

class MaintenanceAwareSandbox {
  private vibeKit: VibeKit;
  
  constructor(config: VibeKitConfig) {
    this.vibeKit = new VibeKit(config);
  }

  async pauseForMaintenance(durationMinutes: number) {
    await this.vibeKit.pause();
    console.log(`Sandbox paused for ${durationMinutes} minute maintenance window`);
    
    return new Promise((resolve) => {
      setTimeout(async () => {
        await this.vibeKit.resume();
        console.log("Maintenance complete. Sandbox resumed.");
        resolve(void 0);
      }, durationMinutes * 60 * 1000);
    });
  }

  async emergencyResume() {
    console.log("Emergency resume initiated...");
    await this.vibeKit.resume();
    console.log("Sandbox resumed for emergency operation");
  }
}

State Restoration

When a sandbox is resumed, all previously saved state is restored including:

File system contents (exactly as they were when paused)
Environment variables
Working directory
Previously installed packages

Performance Considerations

Resume Time

Cold Resume: First resume after a long pause may take 10-30 seconds
Warm Resume: Subsequent resumes are typically faster (5-15 seconds)
State Check: The sandbox performs internal state validation during resume

Resource Usage

// Monitor resume performance
const startTime = Date.now();
await vibeKit.resume();
const resumeTime = Date.now() - startTime;
console.log(`Sandbox resumed in ${resumeTime}ms`);

Notes

State Continuity: All sandbox state is preserved and restored exactly as it was when paused
Process Restoration: Running processes are resumed from their paused state
Network Connections: Some network connections may need to be re-established
File System: All files and directories remain exactly as they were
Best Practice: Always resume before attempting to generate new code on a paused sandbox
Automatic Resume: Consider implementing automatic resume logic in your application flow

Get Started

Agents

Supported Sandboxes

SDK Reference

Method signature

Parameters

Return value

Behavior

Examples

Basic Usage

With Error Handling

State Management Pattern

Auto-Resume on Activity

Scheduled Resume

Error handling

Agent Type Error

Initialization Error

Example Error Handling

Use Cases

Morning Startup Routine

On-Demand Resumption

Recovery from Breaks

State Restoration

Performance Considerations

Resume Time

Resource Usage

Notes

​Method signature

​Parameters

​Return value

​Behavior

​Examples

​Basic Usage

​With Error Handling

​State Management Pattern

​Auto-Resume on Activity

​Scheduled Resume

​Error handling

​Agent Type Error

​Initialization Error

​Example Error Handling

​Use Cases

​Morning Startup Routine

​On-Demand Resumption

​Recovery from Breaks

​State Restoration

​Performance Considerations

​Resume Time

​Resource Usage

​Notes

Method signature

Parameters

Return value

Behavior

Examples

Basic Usage

With Error Handling

State Management Pattern

Auto-Resume on Activity

Scheduled Resume

Error handling

Agent Type Error

Initialization Error

Example Error Handling

Use Cases

Morning Startup Routine

On-Demand Resumption

Recovery from Breaks

State Restoration

Performance Considerations

Resume Time

Resource Usage

Notes