Run untrusted code

import { Sandbox, SandboxEgressMode } from "@brimble/sandbox";

const client = new Sandbox();

async function runUntrusted(code: string) {
  const handle = await client.sandboxes.create({
    region: "auto",
    template: "python-3.12",
    egress: { mode: SandboxEgressMode.DenyAll },
    oneShot: true,              // auto-destroy on process exit
    destroyTimeout: "30m",      // hard ceiling, even if oneShot misfires
    specs: { cpu: 500, memory: 512, disk: 2 },
  });

  try {
    const result = await handle.runCode({
      language: "python",
      code,
      timeout_seconds: 30,      // wall-clock cap
    });

    return {
      exitCode: result.exit_code,
      stdout: result.stdout,
      stderr: result.stderr,
      durationMs: result.duration_ms,
    };
  } finally {
    // belt-and-suspenders: oneShot should already destroy on exit
    await handle.destroy().catch(() => {});
  }
}

const out = await runUntrusted(`
import math
print(math.factorial(20))
`);
console.log(out);

from brimble_sandbox import Sandbox
from brimble_sandbox.enums import SandboxEgressMode

client = Sandbox()

def run_untrusted(code: str) -> dict:
    sandbox = client.sandboxes.create({
        "region": "auto",
        "template": "python-3.12",
        "egress": {"mode": SandboxEgressMode.DENY_ALL},
        "oneShot": True,
        "destroyTimeout": "30m",
        "specs": {"cpu": 500, "memory": 512, "disk": 2},
    })

    try:
        result = sandbox.run_code({
            "language": "python",
            "code": code,
            "timeout_seconds": 30,
        })
        return {
            "exit_code": result["exit_code"],
            "stdout": result["stdout"],
            "stderr": result["stderr"],
            "duration_ms": result["duration_ms"],
        }
    finally:
        try:
            sandbox.destroy()
        except Exception:
            pass

out = run_untrusted("""
import math
print(math.factorial(20))
""")
print(out)

package main

import (
    "context"
    "fmt"
    sandbox "github.com/brimblehq/brimble-sdks/sandbox-go"
)

func runUntrusted(ctx context.Context, client *sandbox.Client, code string) (*sandbox.ExecResult, error) {
    handle, err := client.Sandboxes.Create(ctx, sandbox.CreateSandboxRequest{
        Region:   "auto",
        Template: "python-3.12",
        Egress: &sandbox.SandboxEgressConfig{
            Mode: sandbox.SandboxEgressModeDenyAll,
        },
        OneShot:        true,
        DestroyTimeout: "30m",
        Specs:          &sandbox.SandboxSpecs{CPU: 500, Memory: 512, Disk: 2},
    })
    if err != nil {
        return nil, err
    }
    defer handle.Destroy(context.Background())

    return handle.RunCode(ctx, sandbox.CodeInput{
        Language:       "python",
        Code:           code,
        TimeoutSeconds: 30,
    })
}

func main() {
    ctx := context.Background()
    client, _ := sandbox.NewClient(sandbox.ClientConfig{})
    result, _ := runUntrusted(ctx, client, `
import math
print(math.factorial(20))
`)
    fmt.Println(result.Stdout, result.ExitCode)
}