Wrap a sandbox as an MCP tool handler

import asyncio

from boxlite import SimpleBox, BoxliteError

async def run_in_sandbox(command: str, *args: str) -> dict:
    """Run one command in an isolated sandbox and return a serializable result."""
    try:
        # auto_remove=True tears the box down on exit; image is required
        async with SimpleBox(image="alpine:latest", auto_remove=True) as box:
            result = await box.exec(command, *args, timeout=30.0)
            # A non-zero exit code does NOT raise — return it as data
            return {
                "exit_code": result.exit_code,
                "stdout": result.stdout,
                "stderr": result.stderr,
            }
    except BoxliteError as exc:
        # Wrapper-layer errors (e.g. ExecError) subclass BoxliteError
        return {"error": str(exc)}
    except RuntimeError as exc:
        # Image pull failures and missing virtualization surface as RuntimeError
        return {"error": f"runtime failure: {exc}"}

async def main() -> None:
    print(await run_in_sandbox("echo", "hello from the box"))

if __name__ == "__main__":
    asyncio.run(main())

import { BoxliteError, SimpleBox } from "@boxlite-ai/boxlite";

interface RunResult {
  exitCode?: number;
  stdout?: string;
  stderr?: string;
  error?: string;
}

// Run one command in an isolated sandbox and return a serializable result.
async function runInSandbox(command: string, ...args: string[]): Promise<RunResult> {
  try {
    // autoRemove: true tears the box down on exit; image is required
    await using box = new SimpleBox({ image: "alpine:latest", autoRemove: true });
    const result = await box.exec(command, args, {}, { timeoutSecs: 30 });
    // A non-zero exit code does NOT throw — return it as data
    return { exitCode: result.exitCode, stdout: result.stdout, stderr: result.stderr };
  } catch (err) {
    if (err instanceof BoxliteError) {
      // Wrapper-layer errors (e.g. ExecError) subclass BoxliteError
      return { error: err.message };
    }
    // Image pull failures and missing virtualization surface as a standard Error
    return { error: `runtime failure: ${err instanceof Error ? err.message : err}` };
  }
}

async function main(): Promise<void> {
  console.log(await runInSandbox("echo", "hello from the box"));
}

main();