Sandbox

await using sandbox = await Sandbox.builder("api")
  .image("python")
  .create();

const handle = await Sandbox.get("api");
console.log(handle.status);

for (const h of await Sandbox.list()) {
  console.log(`${h.name} - ${h.status}`);
}

const workers = await Sandbox.listWith({ labels: { role: "worker" } });

await Sandbox.remove("api");

await using sandbox = await Sandbox.start("api");

const sandbox = await Sandbox.startDetached("worker");

const config = await sandbox.config();
console.log(`${config.memoryMib} MiB`);

await sandbox.detach(); // keeps running in the background

await sandbox.fs().writeFile("/tmp/hello.txt", "hi");

await sandbox.kill(); // no graceful shutdown

await sandbox.killWithTimeout(2000);

import { Sandbox } from "microsandbox";

const handle = await Sandbox.get("web");

// Default: all user-program output, regardless of pipe/pty mode
const entries = await handle.logs();

for (const e of entries) {
  const source =
    e.source === "stdout" ? "OUT" :
    e.source === "stderr" ? "ERR" :
    e.source === "output" ? "PTY" :
    "SYS";

  console.log(
    `[${e.timestamp.toISOString()}] ${source} ${e.sessionId}: ${e.text().trimEnd()}`
  );
}

// Filtered: last 50 entries from the past hour, including system lines
const recent = await handle.logs({
  tail: 50,
  since: new Date(Date.now() - 60 * 60 * 1000),
  sources: ["stdout", "stderr", "output", "system"],
});

await using stream = await sandbox.logStream({ follow: true });
for await (const e of stream) {
  console.log(e.text().trimEnd());
}

const health = await sandbox.ping();
console.log(`${health.name}: ${health.latencyMs.toFixed(1)} ms`);

const keepalive = await sandbox.touch();
console.log(`${keepalive.name}: ${keepalive.activitySeq}`);

// Live resize: applies to the running VM when within the booted capacity
const plan = await sandbox.modify({ cpus: 4, memory: 4096 });
for (const r of plan.resizeStatus) {
  console.log(`${r.resource}: ${r.requested} -> ${r.actual} (${r.state})`);
}

// Preview a change without applying it
const preview = await sandbox.modify({ maxMemory: 16384, dryRun: true });
for (const c of preview.changes) {
  console.log(`${c.field}: ${c.disposition}`);
}

// Make an env change active now by restarting
await sandbox.modify({ env: { MODE: "prod" }, policy: "restart" });

const m = await sandbox.metrics();
console.log(`cpu ${m.cpuPercent.toFixed(1)}% · mem ${Math.round(m.memoryBytes / 1048576)} MiB`);

await using stream = await sandbox.metricsStream(1000);
for await (const snapshot of stream) {
  console.log(`${snapshot.cpuPercent.toFixed(1)}%`);
}

await sandbox.requestDrain();
await sandbox.waitUntilStopped();

await sandbox.requestKill();

await sandbox.requestStop();

await sandbox.stop();

await sandbox.stopWithTimeout(5000);

const result = await sandbox.waitUntilStopped();
console.log(result.status, result.exitCode);

{
  await using sandbox = await Sandbox.builder("api").image("python").create();
  await sandbox.exec("python", ["-V"]);
} // sandbox.stop() runs here, automatically

const sandbox = await Sandbox.builder("worker")
  .image("python")
  .detached(true)
  .create();
await sandbox.detach();

const creation = await Sandbox.builder("demo")
  .image("alpine")
  .createWithPullProgress();

for await (const ev of creation) {
  if (ev.kind === "layerDownloadProgress") {
    console.log(`${ev.layerIndex}: ${ev.downloadedBytes}/${ev.totalBytes}`);
  }
}

const sandbox = await creation.awaitSandbox();

const sandbox = await Sandbox.builder("worker")
  .imageWith((i) => i.oci("python:3.12").upperSize(8192))
  .create();

const sandbox = await Sandbox.builder("worker")
  .image("jrei/systemd-debian:12")
  .init("auto")
  .create();

const sandbox = await Sandbox.builder("worker")
  .image("jrei/systemd-debian:12")
  .initWith("/lib/systemd/systemd", (i) =>
    i.args(["--unit=multi-user.target"]).env("container", "microsandbox"))
  .create();

const sandbox = await Sandbox.builder("worker")
  .image("python")
  .patch((p) => p.text("/etc/app.conf", "mode=prod\n", { mode: 0o644 }))
  .create();

const sandbox = await Sandbox.builder("worker")
  .image("registry.internal/app:latest")
  .registry((r) => r.auth("user", "token"))
  .create();