Async Code Not Executing Correctly in e2b Sandbox Environment

[abubakar7033]

When executing JavaScript code containing asynchronous operations (e.g., async/await), the e2b Sandbox environment fails to execute the code as expected. Instead of resolving the asynchronous functions, the sandbox returns a Promise { } as a string or encounters a syntax error with await not being allowed outside async functions.

Steps to Reproduce:

Create an async function in the code to perform asynchronous tasks (e.g., fetch requests, setTimeout, etc.).
Use await to resolve the promise within the async function.
Execute the code in the e2b Sandbox environment using the runCode method.
Expected Behavior: The async function should run as expected, resolving the promise and providing the output. The asynchronous operations should be awaited, and their results should be returned correctly.

Actual Behavior:

The output is returned as Promise { } instead of the resolved result.
In some cases, a SyntaxError is thrown indicating that await is only valid in async functions or top-level modules.

Example Code:

[linear]

E2B-1237 Async Code Not Executing Correctly in e2b Sandbox Environment

[janzheng]

Here's an example that fails — whenever the sandbox runs into the await keyword it just stops executing, but the sandbox keeps running w/ no errors

import "jsr:@std/dotenv/load";
import { AsyncSandbox } from 'npm:@e2b/code-interpreter'

const sbx = await AsyncSandbox.create();
let execution
// await sbx.commands.run('npm install puppeteer')
execution = await sbx.runCode(`
const main = async () => {

  try {
    console.log("Fetching example.com");
    const response = await fetch('https://example.com');
    const html = await response.text();
    console.log('Example.com HTML:');
    console.log(html);
    console.log('what')
  } catch (error) {
    console.log('error')
    console.error('Error fetching example.com:', error);
  }

  console.log("=== done ===");
};

Promise.all([main()])
  .then(() => {
    // This ensures the sandbox waits for completion
    process.exit(0);
  })
  .catch(error => {
    console.error('Error:', error);
    process.exit(1);
  });
`, { language: 'javascript' })
console.log(execution.logs)

// const files = await sbx.files.list('/')
// console.log(files)


// await sbx.kill()

[TheSeamau5]

I have a workaround I have been using lately (thanks to claude opus). My code is in nextjs but basically the code that runs with sandbox.runCode is sync and the actual code I want to run is being run in a separate script user_script.mjs inside the sandbox

const output = childProcess.execSync('node user_script.mjs', {
        cwd: tmpDir,
        encoding: 'utf8',
        timeout: 290000
    });

execSync runs it synchronously but the user_script.mjs holds the async code

So in the end I can pretend to run this properly

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

const { text } = await generateText({
  model: openai("o3-mini"),
  prompt: "What is love?",
});

console.log(text);

Full code from my repo

import { Sandbox } from "@e2b/code-interpreter";
import { NextResponse } from "next/server";
import { z } from "zod";

// API Keys required
const E2B_TEMPLATE_ID = z.string().parse(process.env.E2B_TEMPLATE_ID);

function jsWrapCode(userCode: string, envVars: Record<string, string>) {
  // Create environment variable declarations
  const envDeclarations = Object.entries(envVars)
    .map(([key, value]) => {
      // Escape the value properly for JavaScript string
      const escapedValue = value
        ? value
            .replace(/\\/g, "\\\\")
            .replace(/`/g, "\\`")
            .replace(/\$/g, "\\$")
            .replace(/"/g, '\\"')
            .replace(/'/g, "\\'")
        : "";
      return `process.env.${key} = "${escapedValue}";`;
    })
    .join("\n");

  return `
const childProcess = require('child_process');
const fs = require('fs');
const path = require('path');

// Set all environment variables
${envDeclarations}

// User's code
const DESIRED_CODE = \`${userCode}\`;

const scriptFilePath = '/tmp/user_script.mjs';
const tmpDir = '/tmp';
const localNodeModules = path.join(tmpDir, 'node_modules');
const globalNodeModules = '/usr/lib/node_modules';

// Create local node_modules
if (!fs.existsSync(localNodeModules)) fs.mkdirSync(localNodeModules);

// Symlink ALL packages from global node_modules
const globalPackages = fs.readdirSync(globalNodeModules);
for (const pkg of globalPackages) {
    const globalPkgPath = path.join(globalNodeModules, pkg);
    const localPkgPath = path.join(localNodeModules, pkg);
    
    if (!fs.existsSync(localPkgPath) && fs.statSync(globalPkgPath).isDirectory()) {
        if (pkg.startsWith('@')) {
            const scopeDir = path.join(localNodeModules, pkg);
            if (!fs.existsSync(scopeDir)) {
                fs.mkdirSync(scopeDir, { recursive: true });
            }
            const scopedPackages = fs.readdirSync(globalPkgPath);
            for (const scopedPkg of scopedPackages) {
                const globalScopedPath = path.join(globalPkgPath, scopedPkg);
                const localScopedPath = path.join(scopeDir, scopedPkg);
                if (!fs.existsSync(localScopedPath)) {
                    fs.symlinkSync(globalScopedPath, localScopedPath, 'dir');
                }
            }
        } else {
            fs.symlinkSync(globalPkgPath, localPkgPath, 'dir');
        }
    }
}

// Write and execute
fs.writeFileSync(scriptFilePath, DESIRED_CODE);

try {
    const output = childProcess.execSync('node user_script.mjs', {
        cwd: tmpDir,
        encoding: 'utf8',
        timeout: 290000
    });
    console.log(output);
} catch (e) {
    console.error("Execution error:", e.message);
    if (e.stdout) console.log(e.stdout.toString());
    if (e.stderr) console.error("Stderr:", e.stderr.toString());
    process.exitCode = e.status || 1;
}
`;
}

export async function POST(request: Request) {
  const body = await request.json();
  const { code, language = "python" } = z
    .object({
      code: z.string(),
      language: z.enum(["python", "js", "r", "bash"]).optional(),
    })
    .parse(body);

  const sandbox = await Sandbox.create(E2B_TEMPLATE_ID, {
    envs: {
      NODE_PATH: "/usr/lib/node_modules",
    },
    timeoutMs: 300000,
  });

  let codeActuallySent = code;

  if (language === "js") {
    // Get all environment variables to pass to the wrapper
    const envVars: Record<string, string> = {};
    for (const [key, value] of Object.entries(process.env)) {
      if (value !== undefined) {
        envVars[key] = value;
      }
    }

    codeActuallySent = jsWrapCode(code, envVars);
  }

  const exec = await sandbox.runCode(codeActuallySent, { language });
  console.dir(
    {
      execution: exec.toJSON(),
      language: language,
    },
    { depth: null },
  );

  return NextResponse.json(exec.toJSON());
}

[mishushakov]

Hey there,
We have a version of the code-interpreter in the works that supports typescript, top-level await, esm and automatic promise resolution.

You can subscribe to the PR to know when it lands in the code-interpreter, and I also published the template code-interpreter-asyncjs if you want to try this today already.