sandboxedjs 0.1.0

package/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 sandboxedjs contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+This package depends on @scelar/nodepod, which is licensed MIT with the
+Commons Clause. Nodepod is not redistributed here; it is installed as a normal
+npm dependency.

package/README.md

@@ -0,0 +1,353 @@
+# sandboxedjs
+
+A Linux-like container that runs entirely inside a Node.js process. No Docker, no VM, no native
+modules — a virtual filesystem, a POSIX shell, 154 Unix programs, and both Node.js and Python
+runtimes, all in-process.
+
+Built on [Nodepod](https://github.com/R1ck404/Nodepod), which supplies the Node.js execution
+engine and the in-memory volume.
+
+```ts
+import { createContainer } from "sandboxedjs";
+
+const box = await createContainer({
+  files: { "/app/hello.js": "console.log('hi from', process.platform)" },
+});
+
+await box.exec("ls -la /app");
+await box.exec("node /app/hello.js");        // → hi from linux
+await box.exec("python3 -c 'print(2**64)'"); // → 18446744073709551616
+
+box.dispose();
+```
+
+## Why
+
+Sometimes you need to run untrusted or generated code, give an AI agent a shell, build a
+browser-based IDE backend, or teach Unix — and spinning up a real container is too heavy, too
+slow, or unavailable (serverless, CI, the browser). `sandboxedjs` boots in about 100 ms, costs
+nothing but memory, and never touches your real filesystem.
+
+## Install
+
+```bash
+npm install sandboxedjs
+```
+
+Node 18.17+. Everything is pure JavaScript and WebAssembly — no compilation step.
+
+## What's inside
+
+| | |
+|---|---|
+| **Filesystem** | Full FHS tree (`/etc`, `/usr`, `/var`, `/home`, …), permissions, ownership, symlinks, hard links, `umask`, sticky bits |
+| **Shell** | POSIX `sh` (54 builtins) — pipelines, redirection, here-docs, globbing, brace/parameter/arithmetic/command expansion, functions, `if`/`for`/`while`/`case`/`select`, job control, traps, arrays, `[[ ]]`, `(( ))` |
+| **Coreutils** | 154 programs — `ls cat cp mv rm mkdir grep sed awk find head tail sort uniq wc cut tr tee xargs chmod chown ln du df ps tar gzip base64 sha256sum diff curl wget` and the rest — plus 54 shell builtins |
+| **Node.js** | Real Node semantics via Nodepod — `require`, npm packages, `http`, `fs`, streams, `worker_threads` |
+| **Python** | MicroPython on WebAssembly, mounted on the *same* filesystem |
+| **`/proc`** | Live and synthesised — `ps`, `top`, `free` and `uptime` all read the same source |
+| **Networking** | Virtual interfaces, `/etc/hosts` resolution, in-container HTTP servers, an optional bridge to a real host port |
+| **Users** | Real `/etc/passwd` and `/etc/group`; `useradd`, `su`, `sudo`, and permission checks that deny for real — for the shell and Python, [but not Node](#the-in-container-user-model-does-not-constrain-nodejs) |
+
+Everything shares one filesystem. A file written by `echo` is readable by `require('fs')` in a
+Node script and by `open()` in Python, in either direction.
+
+## Guide
+
+### Booting
+
+```ts
+const box = await createContainer({
+  files: { "/app/index.js": "…" },   // seed the filesystem
+  cwd: "/app",                        // default working directory
+  hostname: "sandbox",
+  user: "root",                       // or a name → uid 1000 with sudo
+  env: { NODE_ENV: "production" },
+  memory: 2 * 1024 ** 3,              // what `free` and /proc/meminfo report
+  cpus: 4,                            // what `nproc` reports
+  network: { allowOutbound: false },  // outbound is off by default
+  timeoutMs: 30_000,                  // default limit for exec()
+});
+```
+
+`files` keys may be absolute or relative to `cwd`; parent directories are created for you, and
+values may be strings or `Uint8Array`s. That is the quickest way to drop a whole project in.
+
+### Running commands
+
+```ts
+const { stdout, stderr, exitCode, output } = await box.exec("grep -c . /etc/passwd");
+
+await box.exec("cat", { stdin: "piped in" });
+await box.exec("npm test", { cwd: "/app", onStdout: (t) => process.stdout.write(t) });
+await box.exec("whoami", { user: "alice" });
+await box.exec("sleep 60", { timeoutMs: 1000 }); // → { timedOut: true }
+
+await box.run(["echo", "no shell parsing here"]);
+```
+
+`exec` is stateless, like `docker exec`. For a shell that remembers things, use a session:
+
+```ts
+const session = box.session();
+await session.run("cd /app");
+await session.run("export TOKEN=abc");
+await session.run("echo $TOKEN in $(pwd)"); // → abc in /app
+```
+
+### Long-running processes
+
+```ts
+const proc = box.spawn("node server.js", { cwd: "/app" });
+
+for (;;) {
+  const line = await proc.stdout.readLine();
+  if (line === null) break;
+  console.log("[server]", line);
+}
+
+proc.kill();
+```
+
+### Servers
+
+An HTTP server started inside the container is reachable three ways:
+
+```ts
+box.spawn("node /app/server.js");
+await box.waitForPort(3000);
+
+// 1. programmatically
+const res = await box.request(3000, { path: "/api", method: "POST", body: "{}" });
+console.log(res.status, res.json());
+
+// 2. from inside, with the usual tools
+await box.exec("curl -s localhost:3000/api");
+
+// 3. from your machine or a browser
+const bridge = await box.expose(3000);
+console.log(bridge.url); // http://127.0.0.1:54321
+await bridge.close();
+```
+
+### npm
+
+```ts
+const box = await createContainer({
+  cwd: "/app",
+  network: { allowOutbound: true }, // required to reach the registry
+  files: {
+    "/app/package.json": JSON.stringify({
+      name: "api",
+      scripts: { start: "node server.js" },
+      dependencies: { express: "^4.19.2" },
+    }),
+    "/app/server.js": `
+      const express = require('express');
+      const app = express();
+      app.get('/', (req, res) => res.json({ ok: true }));
+      app.listen(3000);
+    `,
+  },
+});
+
+await box.exec("npm install", { cwd: "/app", timeoutMs: 300_000 });
+box.spawn("npm start", { cwd: "/app" });
+await box.waitForPort(3000);
+```
+
+`npx`, `yarn` and `pnpm` map onto the same installer. `apt`/`apt-get` reports the built-in
+package set rather than pretending to download Debian archives.
+
+### Python
+
+Python is MicroPython compiled to WebAssembly, mounted on the container's filesystem:
+
+```ts
+await box.exec("python3 -c \"print(open('/etc/hostname').read())\"");
+await box.exec("python3 /app/script.py arg1 arg2");
+await box.exec("echo '1 2 3' | python3 -c \"import sys; print(sum(map(int, sys.stdin.read().split())))\"");
+```
+
+The bundled standard library includes `json`, `re`, `os`, `sys`, `math`, `random`, `hashlib`,
+`binascii`, `struct`, `time`, `collections`, `itertools`, `functools`, `asyncio` and more. It is
+MicroPython, not CPython — there is no `numpy`, and `pip` can install pure-Python wheels only
+(and only with outbound networking enabled).
+
+### Filesystem from the host
+
+```ts
+await box.fs.writeFile("/app/config.json", JSON.stringify(config));
+const log = await box.fs.readFile("/var/log/app.log", "utf8");
+const entries = await box.fs.readdir("/app");
+const { files, bytes } = await box.fs.usage("/app");
+
+await box.copyIn("./my-project", "/app");     // host → container
+await box.copyOut("/app/dist", "./dist");     // container → host
+```
+
+### Snapshots
+
+```ts
+const snapshot = box.snapshot();   // serialisable
+await box.restore(snapshot);
+```
+
+### Interactive terminals
+
+`Terminal` is transport-agnostic: feed it keystrokes, it hands you back what to display. That
+works for a real TTY and for xterm.js in a browser alike.
+
+```ts
+import { Terminal } from "sandboxedjs";
+
+const terminal = new Terminal(box.session(), {
+  write: (data) => xterm.write(data),
+  columns: 80,
+  rows: 24,
+});
+xterm.onData((data) => terminal.input(data));
+terminal.start();
+```
+
+You get line editing, history, tab completion over commands and paths, multi-line continuation,
+and the usual control keys.
+
+## Command line
+
+```bash
+npx sandboxedjs                            # interactive shell
+npx sandboxedjs -c 'ls -la /etc'           # one command
+npx sandboxedjs script.sh                  # run a script
+npx sandboxedjs -v ./app:/app -w /app      # mount a host directory
+npx sandboxedjs --network -p 3000          # allow outbound, publish a port
+```
+
+Run `sandboxedjs --help` for the full list.
+
+## Security
+
+The container has no access to your filesystem, environment, or network unless you grant it:
+
+- The filesystem is entirely in memory. Code inside cannot read or write a host path — there is
+  no `/Users`, no `/home/you`, no way to reach one.
+- Outbound network access is **off by default**; `curl https://…` fails until you pass
+  `network: { allowOutbound: true }`, optionally narrowed with `allowedHosts`.
+- Host files enter only through `files`, `mount()` or `copyIn()`, and leave only through
+  `copyOut()` or `fs.readFile()`.
+- `timeoutMs` bounds runaway commands, and `exec` settles even when a process ignores its kill
+  signal.
+
+### The in-container user model does not constrain Node.js
+
+This one matters, so it gets its own heading. The Unix permission layer is enforced for the
+shell, the coreutils and Python:
+
+```ts
+await box.exec("cat /root/secret", { user: "agent" });                      // Permission denied
+await box.exec("python3 -c \"open('/etc/passwd','a')\"", { user: "agent" }); // OSError
+```
+
+It is **not** enforced for Node.js. A `node` script gets direct access to the underlying volume,
+so it can read and write any path in the container regardless of `user`:
+
+```ts
+await box.exec("node -e \"require('fs').readFileSync('/root/secret')\"", { user: "agent" }); // succeeds
+```
+
+Node code runs inside Nodepod's worker, which owns the volume and has no notion of container
+uids. Treat `user` as a way to model *ordinary* multi-user behaviour, not as a privilege
+boundary for JavaScript you do not trust. If untrusted JavaScript must not see something, keep
+it out of the container rather than relying on file modes.
+
+### And it is not a VM
+
+Everything runs in your Node process, so a true sandbox escape is a JavaScript-engine escape.
+This is isolation from mistakes and from ordinary untrusted programs — not a substitute for a
+VM or a real container when facing a determined attacker.
+
+## Known limits
+
+Honest list of what does not work:
+
+- **Vite's dev server** starts but fails resolving its own package metadata, because Nodepod's
+  ESM layer does not give bundled chunks a correct `import.meta.url`. Express, Koa, Fastify-style
+  apps and plain `http` servers work. See `examples/react-app` for a React setup that runs.
+- **Python is MicroPython**, so C extensions (`numpy`, `pandas`, `cryptography`) are unavailable.
+- **No real sockets.** HTTP servers work through the request proxy; raw TCP/UDP does not.
+- **No real processes.** Processes are cooperative async tasks: `kill -9` cannot interrupt a
+  tight synchronous loop, and `SIGSTOP` only marks state.
+- **`chroot` does not isolate**; it runs the command with its cwd inside the target.
+- **`awk`'s `system()`** does not block on the child.
+
+## API reference
+
+### `createContainer(options): Promise<Container>`
+
+| Option | Type | Default | |
+|---|---|---|---|
+| `files` | `Record<string, string \| Uint8Array>` | — | Seed the filesystem |
+| `cwd` | `string` | `"/"` | Default working directory, and base for relative `files` keys |
+| `hostname` | `string` | `"sandbox"` | |
+| `user` | `string \| null` | `"root"` | Login user; a non-root name gets uid 1000 and sudo |
+| `env` | `Record<string, string>` | — | Extra environment variables |
+| `memory` | `number` | 2 GiB | Reported by `free`, `top`, `/proc/meminfo` |
+| `cpus` | `number` | `4` | Reported by `nproc`, `/proc/cpuinfo` |
+| `network` | `NetworkOptions` | outbound off | `{ allowOutbound, allowedHosts, ipv4, gateway }` |
+| `timezone` | `string` | `"UTC"` | |
+| `timeoutMs` | `number` | none | Default limit for `exec` |
+| `onStdout` / `onStderr` | `(chunk: string) => void` | — | Container-wide output taps |
+
+### `Container`
+
+| Member | |
+|---|---|
+| `exec(command, opts?)` | Run a shell command line; returns `{ stdout, stderr, output, exitCode, timedOut, durationMs }` |
+| `run(argv, opts?)` | Run a program without shell parsing |
+| `spawn(command, opts?)` | Start a process; returns `{ pid, stdin, stdout, stderr, wait(), kill() }` |
+| `session(opts?)` | A stateful shell session |
+| `fs` | `readFile`, `writeFile`, `readdir`, `mkdir`, `rm`, `stat`, `walk`, `usage`, … |
+| `mount(files, opts?)` | Add files after boot |
+| `copyIn` / `copyOut` | Move trees between host and container |
+| `request(port, init?)` | HTTP to an in-container server |
+| `waitForPort(port, opts?)` | Resolve once something is listening |
+| `expose(port, opts?)` | Bridge to a real host port |
+| `snapshot()` / `restore(s)` | Filesystem persistence |
+| `kernel`, `pod`, `net` | Escape hatches to the internals |
+| `dispose()` | Tear everything down |
+
+Lower-level pieces — `Kernel`, `Vfs`, `Shell`, `Terminal`, `NetworkStack`, `defineCommand` — are
+exported too, so you can add your own commands or embed the shell on its own.
+
+### Adding a command
+
+```ts
+import { createContainer, defineCommand } from "sandboxedjs";
+
+const box = await createContainer();
+
+box.kernel.installCommand(
+  defineCommand({
+    name: "greet",
+    summary: "say hello",
+    run(ctx) {
+      ctx.line(`hello ${ctx.args[0] ?? "world"}`);
+      return 0;
+    },
+  }),
+);
+
+await box.exec("greet there | tr a-z A-Z"); // → HELLO THERE
+```
+
+It becomes a real file in `/usr/bin`, so `which greet`, `man greet` and shebang dispatch all work.
+
+## Examples
+
+See [`examples/`](./examples): a REPL, an Express API, a React app, a Python data pipeline, an
+agent sandbox, and a browser terminal.
+
+## License
+
+MIT. Nodepod itself is MIT with the Commons Clause; this package depends on it rather than
+redistributing it.

package/bin/sandboxedjs.mjs

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+/**
+ * `sandboxedjs` — boot a Linux-like container and drop into a shell, or run a
+ * single command inside one.
+ *
+ *   sandboxedjs                       interactive shell
+ *   sandboxedjs -c 'ls -la /'         run a command and exit
+ *   sandboxedjs script.sh             run a script
+ *   sandboxedjs -v ./app:/app -w /app mount a host directory and start there
+ *   sandboxedjs --network -p 3000     allow outbound, publish port 3000
+ */
+
+import { createContainer, Terminal } from "../dist/index.js";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const USAGE = `sandboxedjs — a Linux-like container inside Node.js
+
+Usage:
+  sandboxedjs [options]                 start an interactive shell
+  sandboxedjs [options] -c <command>    run a command and exit
+  sandboxedjs [options] <script.sh>     run a shell script and exit
+
+Options:
+  -c, --command <cmd>     run <cmd> and exit
+  -v, --volume <src:dst>  copy a host directory into the container (repeatable)
+  -o, --out <src:dst>     copy a container path back out on exit (repeatable)
+  -w, --workdir <dir>     working directory inside the container (default /)
+  -u, --user <name>       run as this user (default root)
+  -e, --env <K=V>         set an environment variable (repeatable)
+  -p, --publish <port>    publish a container port on the host (repeatable)
+  -H, --hostname <name>   container hostname (default sandbox)
+      --network           allow outbound network access (off by default)
+      --allow <host>      allow one outbound host (implies --network, repeatable)
+      --memory <bytes>    RAM reported inside the container
+      --cpus <n>          CPU count reported inside the container
+      --timeout <ms>      wall-clock limit for -c / script mode
+  -h, --help              show this message
+      --version           print the version
+`;
+
+function parseCli(argv) {
+  const opts = {
+    volumes: [],
+    outputs: [],
+    env: {},
+    publish: [],
+    allow: [],
+    network: false,
+    workdir: "/",
+    user: "root",
+    hostname: "sandbox",
+  };
+  const rest = [];
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const value = () => argv[++i];
+    switch (arg) {
+      case "-h":
+      case "--help":
+        opts.help = true;
+        break;
+      case "--version":
+        opts.version = true;
+        break;
+      case "-c":
+      case "--command":
+        opts.command = value();
+        break;
+      case "-v":
+      case "--volume":
+        opts.volumes.push(value());
+        break;
+      case "-o":
+      case "--out":
+        opts.outputs.push(value());
+        break;
+      case "-w":
+      case "--workdir":
+        opts.workdir = value();
+        break;
+      case "-u":
+      case "--user":
+        opts.user = value();
+        break;
+      case "-e":
+      case "--env": {
+        const pair = value() ?? "";
+        const eq = pair.indexOf("=");
+        if (eq > 0) opts.env[pair.slice(0, eq)] = pair.slice(eq + 1);
+        break;
+      }
+      case "-p":
+      case "--publish":
+        opts.publish.push(Number(value()));
+        break;
+      case "-H":
+      case "--hostname":
+        opts.hostname = value();
+        break;
+      case "--network":
+        opts.network = true;
+        break;
+      case "--allow":
+        opts.network = true;
+        opts.allow.push(value());
+        break;
+      case "--memory":
+        opts.memory = Number(value());
+        break;
+      case "--cpus":
+        opts.cpus = Number(value());
+        break;
+      case "--timeout":
+        opts.timeout = Number(value());
+        break;
+      default:
+        if (arg.startsWith("-") && arg.length > 1) {
+          process.stderr.write(`sandboxedjs: unknown option ${arg}\n`);
+          process.exit(2);
+        }
+        rest.push(arg);
+    }
+  }
+  opts.rest = rest;
+  return opts;
+}
+
+async function packageVersion() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const manifest = JSON.parse(await readFile(path.join(here, "..", "package.json"), "utf8"));
+    return manifest.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+async function main() {
+  const opts = parseCli(process.argv.slice(2));
+
+  if (opts.help) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  if (opts.version) {
+    process.stdout.write((await packageVersion()) + "\n");
+    return 0;
+  }
+
+  const box = await createContainer({
+    hostname: opts.hostname,
+    user: opts.user === "root" ? "root" : opts.user,
+    cwd: opts.workdir,
+    env: opts.env,
+    ...(opts.memory ? { memory: opts.memory } : {}),
+    ...(opts.cpus ? { cpus: opts.cpus } : {}),
+    network: { allowOutbound: opts.network, allowedHosts: opts.allow.length ? opts.allow : null },
+  });
+
+  // Mount host directories.
+  for (const spec of opts.volumes) {
+    const sep = spec.lastIndexOf(":");
+    if (sep <= 0) {
+      process.stderr.write(`sandboxedjs: bad volume '${spec}' (expected host:container)\n`);
+      box.dispose();
+      return 2;
+    }
+    const hostPath = path.resolve(spec.slice(0, sep));
+    const containerPath = spec.slice(sep + 1);
+    try {
+      await box.copyIn(hostPath, containerPath);
+    } catch (e) {
+      process.stderr.write(`sandboxedjs: cannot mount ${hostPath}: ${e.message}\n`);
+      box.dispose();
+      return 1;
+    }
+  }
+
+  // Publish ports.
+  const bridges = [];
+  for (const port of opts.publish) {
+    const bridge = await box.expose(port);
+    bridges.push(bridge);
+    process.stderr.write(`sandboxedjs: container :${port} -> ${bridge.url}\n`);
+  }
+
+  const finish = async (code) => {
+    for (const spec of opts.outputs) {
+      const sep = spec.lastIndexOf(":");
+      if (sep <= 0) continue;
+      try {
+        await box.copyOut(spec.slice(0, sep), path.resolve(spec.slice(sep + 1)));
+      } catch (e) {
+        process.stderr.write(`sandboxedjs: cannot copy out ${spec}: ${e.message}\n`);
+      }
+    }
+    for (const bridge of bridges) await bridge.close();
+    box.dispose();
+    return code;
+  };
+
+  // ── one-shot modes ────────────────────────────────────────────────────────
+  if (opts.command !== undefined) {
+    const result = await box.exec(opts.command, {
+      onStdout: (t) => process.stdout.write(t),
+      onStderr: (t) => process.stderr.write(t),
+      ...(opts.timeout ? { timeoutMs: opts.timeout } : {}),
+    });
+    return finish(result.exitCode);
+  }
+
+  if (opts.rest.length > 0) {
+    const scriptPath = path.resolve(opts.rest[0]);
+    let source;
+    try {
+      source = await readFile(scriptPath, "utf8");
+    } catch {
+      process.stderr.write(`sandboxedjs: cannot read ${scriptPath}\n`);
+      return finish(1);
+    }
+    const target = "/tmp/_sbx_script.sh";
+    box.mount({ [target]: source });
+    const args = opts.rest.slice(1).map((a) => `'${a.replace(/'/g, `'\\''`)}'`).join(" ");
+    const result = await box.exec(`sh ${target} ${args}`, {
+      onStdout: (t) => process.stdout.write(t),
+      onStderr: (t) => process.stderr.write(t),
+      ...(opts.timeout ? { timeoutMs: opts.timeout } : {}),
+    });
+    return finish(result.exitCode);
+  }
+
+  // ── interactive shell ─────────────────────────────────────────────────────
+  if (!process.stdin.isTTY) {
+    // Piped input: treat it as a script.
+    const chunks = [];
+    for await (const chunk of process.stdin) chunks.push(chunk);
+    const result = await box.exec(Buffer.concat(chunks).toString("utf8"), {
+      onStdout: (t) => process.stdout.write(t),
+      onStderr: (t) => process.stderr.write(t),
+    });
+    return finish(result.exitCode);
+  }
+
+  const session = box.session();
+  await new Promise((resolve) => {
+    const terminal = new Terminal(session, {
+      write: (data) => process.stdout.write(data),
+      columns: process.stdout.columns ?? 80,
+      rows: process.stdout.rows ?? 24,
+      onExit: (code) => {
+        cleanup();
+        resolve(code);
+      },
+    });
+
+    const onData = (data) => terminal.input(data.toString("utf8"));
+    const onResize = () => terminal.resize(process.stdout.columns ?? 80, process.stdout.rows ?? 24);
+
+    const cleanup = () => {
+      process.stdin.off("data", onData);
+      process.stdout.off("resize", onResize);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write("\r\n");
+    };
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+    process.stdout.on("resize", onResize);
+    terminal.resize(process.stdout.columns ?? 80, process.stdout.rows ?? 24);
+    terminal.start();
+  });
+
+  return finish(0);
+}
+
+main()
+  .then((code) => process.exit(code ?? 0))
+  .catch((e) => {
+    process.stderr.write(`sandboxedjs: ${e?.stack ?? e}\n`);
+    process.exit(1);
+  });