unfazed 0.9.0 → 0.10.1

package/dist/eve-sandbox/daemon.js

@@ -0,0 +1,687 @@
+/**
+ * The eve sandbox daemon: runs as root inside an unfazed box and gives the
+ * apps it trusts sandboxes, one Unix user per eve session.
+ *
+ * It serves the box's :3000, which unfazed publishes at the box's URL, and
+ * accepts only workload identity tokens (OIDC, issuer
+ * `https://unfazed.dev/oidc`) whose audience is that URL and whose app is on
+ * its allow list. A session's commands and file operations run as that
+ * session's user, so the kernel keeps sessions apart; the daemon itself only
+ * creates and removes users and relays bytes.
+ *
+ * Started by a box boot hook (`/data/boot.d/50-eve-sandbox`, see setup.ts):
+ *
+ *   node|bun <this file> serve [--config /data/eve-sandbox/config.json]
+ *
+ * and invoked as the session user for file operations:
+ *
+ *   setpriv --reuid U --regid G --init-groups -- node|bun <this file> fileop
+ */
+import { spawn, spawnSync } from "node:child_process";
+import { createHash, randomUUID, webcrypto } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { API_PREFIX, DAEMON_VERSION, TEMPLATE_HOME, TEMPLATE_WORKSPACE, } from "./protocol.js";
+const DEFAULT_CONFIG_PATH = "/data/eve-sandbox/config.json";
+/**
+ * The box's env snapshot (the work drive, rebuilt on every boot). The box
+ * init exports it to SSH sessions but not to boot hooks, so a daemon started
+ * at boot reads the box's URL from here.
+ */
+export const BOX_ENV_SNAPSHOT = "/work/.unfazed/env.json";
+const PATH_ENV = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin";
+/** Output kept per process for a client that reads late or reconnects. */
+const MAX_PROCESS_OUTPUT = 64 * 1024 * 1024;
+/** A finished process is forgotten this long after it exited. */
+const PROCESS_RETENTION_MS = 10 * 60 * 1000;
+const MAX_BODY = 128 * 1024 * 1024;
+/** Root-owned file in a session's home whose mtime is the session's last call. */
+const LAST_USED = ".eve-sandbox-last-used";
+const SESSION_USER = /^eve[0-9a-f]{12}$/;
+/** The box's own variables: the process's, else the box's env snapshot. */
+function boxEnv(env, snapshot) {
+    if (env.UNFZ_PUBLIC_URL)
+        return env;
+    try {
+        const parsed = JSON.parse(readFileSync(snapshot, "utf8"));
+        const out = { ...env };
+        for (const [key, value] of Object.entries(parsed))
+            if (typeof value === "string" && out[key] === undefined)
+                out[key] = value;
+        return out;
+    }
+    catch {
+        return env;
+    }
+}
+export function loadConfig(path = DEFAULT_CONFIG_PATH, env = process.env, snapshot = BOX_ENV_SNAPSHOT) {
+    const raw = existsSync(path) ? JSON.parse(readFileSync(path, "utf8")) : {};
+    const box = boxEnv(env, snapshot);
+    const audience = raw.audience ?? box.UNFZ_PUBLIC_URL ?? "";
+    if (!audience)
+        throw new Error(`eve sandbox: no audience (set "audience" in ${path}, or UNFZ_PUBLIC_URL; ${snapshot} has none either)`);
+    const envAllow = (box.EVE_SANDBOX_ALLOW ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    const allow = [...(raw.allow ?? []), ...envAllow];
+    if (allow.length === 0)
+        throw new Error(`eve sandbox: nothing is allowed (set "allow" in ${path} or EVE_SANDBOX_ALLOW)`);
+    return {
+        audience: audience.replace(/\/+$/, ""),
+        allow,
+        issuer: raw.issuer ?? "https://unfazed.dev/oidc",
+        port: raw.port ?? 3000,
+        homeRoot: raw.homeRoot ?? "/home",
+        idleMinutes: raw.idleMinutes ?? 20,
+        retentionDays: raw.retentionDays ?? 14,
+        env: raw.env ?? {},
+    };
+}
+class HttpError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message ?? code);
+        this.status = status;
+        this.code = code;
+    }
+}
+function b64urlDecode(part) {
+    return new Uint8Array(Buffer.from(part.replace(/-/g, "+").replace(/_/g, "/"), "base64"));
+}
+export class TokenVerifier {
+    config;
+    fetchJson;
+    now;
+    keys = new Map();
+    fetchedAt = 0;
+    refreshing;
+    constructor(config, fetchJson = async (url) => {
+        const res = await fetch(url, { signal: AbortSignal.timeout(10_000) });
+        if (!res.ok)
+            throw new Error(`${url}: ${res.status}`);
+        return await res.json();
+    }, now = () => Date.now()) {
+        this.config = config;
+        this.fetchJson = fetchJson;
+        this.now = now;
+    }
+    /** The calling app's namespace (its app id) for a valid, allowed token. */
+    async verify(authorization) {
+        const match = /^Bearer ([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]+)$/.exec(authorization ?? "");
+        if (!match)
+            throw new HttpError(401, "invalid_token", "a workload identity bearer token is required");
+        const [, h, p, s] = match;
+        let header;
+        let claims;
+        try {
+            header = JSON.parse(Buffer.from(b64urlDecode(h)).toString("utf8"));
+            claims = JSON.parse(Buffer.from(b64urlDecode(p)).toString("utf8"));
+        }
+        catch {
+            throw new HttpError(401, "invalid_token", "malformed token");
+        }
+        if (header.alg !== "ES256" || !header.kid)
+            throw new HttpError(401, "invalid_token", "unsupported token algorithm");
+        const key = await this.key(header.kid);
+        const ok = await webcrypto.subtle.verify({ name: "ECDSA", hash: "SHA-256" }, key, b64urlDecode(s), new TextEncoder().encode(`${h}.${p}`));
+        if (!ok)
+            throw new HttpError(401, "invalid_token", "bad signature");
+        const nowS = Math.floor(this.now() / 1000);
+        const audiences = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
+        if (claims.iss !== this.config.issuer)
+            throw new HttpError(401, "invalid_token", "wrong issuer");
+        if (!audiences.some((a) => a.replace(/\/+$/, "") === this.config.audience))
+            throw new HttpError(401, "invalid_token", "wrong audience");
+        if (typeof claims.exp !== "number" || claims.exp < nowS - 30)
+            throw new HttpError(401, "invalid_token", "token expired");
+        if (typeof claims.nbf === "number" && claims.nbf > nowS + 30)
+            throw new HttpError(401, "invalid_token", "token not yet valid");
+        const app = claims.app_id ?? "";
+        if (!app)
+            throw new HttpError(403, "forbidden", "the token names no app");
+        const allowed = this.config.allow.some((entry) => entry.startsWith("owner:") ? entry.slice(6) === claims.owner_id : entry === app);
+        if (!allowed)
+            throw new HttpError(403, "forbidden", `app ${app} may not use this box`);
+        return app;
+    }
+    async key(kid) {
+        const cached = this.keys.get(kid);
+        if (cached && this.now() - this.fetchedAt < 10 * 60 * 1000)
+            return cached;
+        // Unknown kid: refetch, but at most every 30 s.
+        if (!cached || this.now() - this.fetchedAt >= 30_000)
+            await this.refresh();
+        const key = this.keys.get(kid);
+        if (!key)
+            throw new HttpError(401, "invalid_token", "unknown signing key");
+        return key;
+    }
+    async refresh() {
+        this.refreshing ??= (async () => {
+            try {
+                const discovery = (await this.fetchJson(`${this.config.issuer}/.well-known/openid-configuration`));
+                const jwks = (await this.fetchJson(discovery.jwks_uri ?? `${this.config.issuer}/jwks`));
+                const next = new Map();
+                for (const jwk of jwks.keys ?? []) {
+                    const kid = jwk.kid;
+                    if (!kid || jwk.kty !== "EC" || jwk.crv !== "P-256")
+                        continue;
+                    next.set(kid, await webcrypto.subtle.importKey("jwk", jwk, { name: "ECDSA", namedCurve: "P-256" }, false, ["verify"]));
+                }
+                this.keys = next;
+                this.fetchedAt = this.now();
+            }
+            finally {
+                this.refreshing = undefined;
+            }
+        })();
+        await this.refreshing;
+    }
+}
+/** The Unix name of an app's session: bounded, derived from the ids only. */
+export function sessionName(app, sessionId) {
+    return `eve${createHash("sha256").update(`${app}\n${sessionId}`).digest("hex").slice(0, 12)}`;
+}
+function run(argv, input) {
+    const result = spawnSync(argv[0], argv.slice(1), { input, encoding: "utf8", env: { PATH: PATH_ENV } });
+    return { status: result.status ?? 1, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+}
+class Sessions {
+    config;
+    lastUsed = new Map();
+    constructor(config) {
+        this.config = config;
+    }
+    describe(name) {
+        const entry = run(["getent", "passwd", name]);
+        if (entry.status !== 0)
+            return undefined;
+        const [, , uid, gid, , home] = entry.stdout.trim().split(":");
+        return { name, uid: Number(uid), gid: Number(gid), home: home, workspace: `${home}/workspace` };
+    }
+    get(app, sessionId) {
+        const session = this.describe(sessionName(app, sessionId));
+        if (session)
+            this.touch(session.name);
+        return session;
+    }
+    ensure(app, sessionId, template) {
+        const name = sessionName(app, sessionId);
+        const existing = this.describe(name);
+        if (existing) {
+            this.touch(name);
+            return { ...existing, created: false };
+        }
+        const home = `${this.config.homeRoot}/${name}`;
+        const added = run(["useradd", "--create-home", "--home-dir", home, "--shell", "/bin/bash", "--user-group", "--comment", "eve sandbox", name]);
+        const session = this.describe(name);
+        if (!session)
+            throw new HttpError(500, "session_create_failed", added.stderr.trim() || "useradd failed");
+        run(["chmod", "0700", home]);
+        const files = [
+            { path: `${session.workspace}/.keep`, b64: "" },
+            ...template.map((file) => ({ path: mapTemplatePath(file.path, session), b64: file.b64 })),
+        ];
+        fileop(session, { op: "write", files });
+        this.touch(name);
+        return { ...session, created: true };
+    }
+    stop(name) {
+        run(["pkill", "-KILL", "-u", name]);
+    }
+    delete(app, sessionId) {
+        const name = sessionName(app, sessionId);
+        if (!this.describe(name))
+            return;
+        this.stop(name);
+        for (let attempt = 0; attempt < 5; attempt++) {
+            if (run(["userdel", "--remove", name]).status === 0)
+                break;
+            this.stop(name);
+            spawnSync("sleep", ["0.2"]);
+        }
+        rmSync(`${this.config.homeRoot}/${name}`, { recursive: true, force: true });
+        this.lastUsed.delete(name);
+    }
+    touch(name) {
+        const now = Date.now();
+        const previous = this.lastUsed.get(name) ?? 0;
+        this.lastUsed.set(name, now);
+        if (now - previous < 60_000)
+            return;
+        const marker = `${this.config.homeRoot}/${name}/${LAST_USED}`;
+        try {
+            if (!existsSync(marker))
+                writeFileSync(marker, "");
+            utimesSync(marker, now / 1000, now / 1000);
+        }
+        catch {
+            // the home may be gone mid-delete
+        }
+    }
+    /** Deletes sessions without a call for longer than the retention, users and homes included. */
+    expireOld() {
+        if (this.config.retentionDays <= 0)
+            return;
+        const limit = this.config.retentionDays * 24 * 60 * 60 * 1000;
+        const passwd = run(["getent", "passwd"]).stdout.split("\n");
+        for (const line of passwd) {
+            const [name, , , , , home] = line.split(":");
+            if (!name || !SESSION_USER.test(name) || home !== `${this.config.homeRoot}/${name}`)
+                continue;
+            let at;
+            try {
+                at = statSync(`${home}/${LAST_USED}`).mtimeMs;
+            }
+            catch {
+                try {
+                    at = statSync(home).mtimeMs;
+                }
+                catch {
+                    at = 0;
+                }
+            }
+            if (Date.now() - at > limit) {
+                this.stop(name);
+                run(["userdel", "--remove", name]);
+                rmSync(home, { recursive: true, force: true });
+                this.lastUsed.delete(name);
+            }
+        }
+    }
+    /** Kills the processes of sessions idle for longer than the limit. */
+    reapIdle() {
+        if (this.config.idleMinutes <= 0)
+            return;
+        const limit = this.config.idleMinutes * 60 * 1000;
+        for (const [name, at] of this.lastUsed) {
+            if (Date.now() - at > limit) {
+                this.stop(name);
+                this.lastUsed.delete(name);
+            }
+        }
+    }
+}
+function mapTemplatePath(path, session) {
+    if (path === TEMPLATE_WORKSPACE || path.startsWith(`${TEMPLATE_WORKSPACE}/`))
+        return session.workspace + path.slice(TEMPLATE_WORKSPACE.length);
+    if (path === TEMPLATE_HOME || path.startsWith(`${TEMPLATE_HOME}/`))
+        return session.home + path.slice(TEMPLATE_HOME.length);
+    return path;
+}
+function sessionEnv(session, extra) {
+    return {
+        PATH: PATH_ENV,
+        HOME: session.home,
+        USER: session.name,
+        LOGNAME: session.name,
+        SHELL: "/bin/bash",
+        LANG: "C.UTF-8",
+        ...extra,
+    };
+}
+function asUser(session, argv) {
+    return ["setpriv", `--reuid=${session.uid}`, `--regid=${session.gid}`, "--init-groups", "--", ...argv];
+}
+const FILEOP_MISSING = 3;
+const FILEOP_DIRECTORY = 4;
+const FILEOP_FAILED = 5;
+function fileop(session, request) {
+    // This module itself, whoever loaded it (its own entry or `unfazed eve-sandbox serve`).
+    const argv = asUser(session, [process.execPath, fileURLToPath(import.meta.url), "fileop"]);
+    const result = spawnSync(argv[0], argv.slice(1), {
+        input: JSON.stringify(request),
+        env: { PATH: PATH_ENV, HOME: session.home },
+        maxBuffer: MAX_BODY,
+    });
+    const status = result.status ?? FILEOP_FAILED;
+    if (status === 0)
+        return result.stdout;
+    const message = (result.stderr?.toString() ?? "").trim().slice(0, 500);
+    if (status === FILEOP_MISSING)
+        throw new HttpError(404, "not_found", message || "no such file");
+    if (status === FILEOP_DIRECTORY)
+        throw new HttpError(409, "is_directory", message || "the path is a directory");
+    throw new HttpError(422, "file_operation_failed", message || "the file operation failed");
+}
+/** The `fileop` subcommand: one request on stdin, run with the caller's own permissions. */
+export function runFileOp() {
+    try {
+        const request = JSON.parse(readFileSync(0, "utf8"));
+        if (request.op === "read") {
+            let st;
+            try {
+                st = statSync(request.path);
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    process.exit(FILEOP_MISSING);
+                throw error;
+            }
+            if (st.isDirectory())
+                process.exit(FILEOP_DIRECTORY);
+            process.stdout.write(readFileSync(request.path), () => process.exit(0));
+            return undefined;
+        }
+        if (request.op === "write") {
+            for (const file of request.files) {
+                if (!file.path.startsWith("/"))
+                    throw new Error(`not an absolute path: ${file.path}`);
+                mkdirSync(dirname(file.path), { recursive: true });
+                writeFileSync(file.path, Buffer.from(file.b64, "base64"));
+            }
+            process.exit(0);
+        }
+        if (request.op === "remove") {
+            if (!existsSync(request.path))
+                process.exit(request.force ? 0 : FILEOP_MISSING);
+            rmSync(request.path, { recursive: request.recursive, force: request.force });
+            process.exit(0);
+        }
+        throw new Error("unknown operation");
+    }
+    catch (error) {
+        process.stderr.write(String(error.message ?? error));
+        process.exit(FILEOP_FAILED);
+    }
+}
+const SIGNALS = { SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGSEGV: 11, SIGPIPE: 13, SIGTERM: 15 };
+class Processes {
+    all = new Map();
+    start(app, session, request, baseEnv) {
+        if (!existsSync(request.cwd))
+            throw new HttpError(400, "invalid_cwd", `working directory does not exist: ${request.cwd}`);
+        const argv = asUser(session, ["bash", "-lc", request.command]);
+        const child = spawn(argv[0], argv.slice(1), {
+            cwd: request.cwd,
+            env: { ...sessionEnv(session, { AI_AGENT: "eve", ...baseEnv }), ...request.env },
+            stdio: [request.stdin ? "pipe" : "ignore", "pipe", "pipe"],
+            // Its own process group, so a kill reaches the whole tree.
+            detached: true,
+        });
+        const proc = {
+            id: randomUUID(),
+            app,
+            session: session.name,
+            child,
+            events: [],
+            bytes: 0,
+            exit: undefined,
+            exitedAt: undefined,
+            listeners: new Set(),
+        };
+        const push = (event) => {
+            proc.events.push(event);
+            for (const listener of proc.listeners)
+                listener();
+        };
+        const pipe = (fd) => (chunk) => {
+            if (proc.bytes + chunk.length > MAX_PROCESS_OUTPUT)
+                return;
+            proc.bytes += chunk.length;
+            push({ s: proc.events.length + 1, f: fd, d: chunk.toString("base64") });
+        };
+        child.stdout?.on("data", pipe(1));
+        child.stderr?.on("data", pipe(2));
+        child.on("error", (error) => {
+            push({ s: proc.events.length + 1, f: 2, d: Buffer.from(`eve sandbox: ${error.message}\n`).toString("base64") });
+        });
+        child.on("close", (code, signal) => {
+            proc.exit = code ?? 128 + (signal ? (SIGNALS[signal] ?? 1) : 1);
+            proc.exitedAt = Date.now();
+            push({ s: proc.events.length + 1, x: proc.exit });
+        });
+        this.all.set(proc.id, proc);
+        return proc;
+    }
+    kill(proc) {
+        if (proc.exit !== undefined || proc.child.pid === undefined)
+            return;
+        try {
+            process.kill(-proc.child.pid, "SIGKILL");
+        }
+        catch {
+            proc.child.kill("SIGKILL");
+        }
+    }
+    killSession(name) {
+        for (const proc of this.all.values())
+            if (proc.session === name)
+                this.kill(proc);
+    }
+    prune() {
+        for (const [id, proc] of this.all) {
+            if (proc.exitedAt !== undefined && Date.now() - proc.exitedAt > PROCESS_RETENTION_MS)
+                this.all.delete(id);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// HTTP
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        size += chunk.length;
+        if (size > MAX_BODY)
+            throw new HttpError(413, "too_large");
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+}
+async function readJson(req) {
+    const body = await readBody(req);
+    try {
+        return JSON.parse(body.toString("utf8") || "{}");
+    }
+    catch {
+        throw new HttpError(400, "invalid_json");
+    }
+}
+function sendJson(res, status, value) {
+    const body = JSON.stringify(value);
+    res.writeHead(status, { "content-type": "application/json", "content-length": Buffer.byteLength(body), "cache-control": "no-store" });
+    res.end(body);
+}
+export function createDaemon(config, verifier = new TokenVerifier(config)) {
+    const sessions = new Sessions(config);
+    const processes = new Processes();
+    const sessionOf = (app, id) => {
+        const session = sessions.get(app, decodeURIComponent(id));
+        if (!session)
+            throw new HttpError(410, "session_gone", "no such sandbox session");
+        return session;
+    };
+    const procOf = (app, id) => {
+        const proc = processes.all.get(id);
+        if (!proc || proc.app !== app)
+            throw new HttpError(404, "no_such_process");
+        sessions.touch(proc.session);
+        return proc;
+    };
+    async function route(req, res) {
+        const url = new URL(req.url ?? "/", "http://box");
+        const path = url.pathname;
+        const method = req.method ?? "GET";
+        if (method === "GET" && path === `${API_PREFIX}/health`)
+            return sendJson(res, 200, { ok: true, version: DAEMON_VERSION });
+        if (!path.startsWith(`${API_PREFIX}/`))
+            throw new HttpError(404, "not_found");
+        const app = await verifier.verify(req.headers.authorization);
+        const parts = path.slice(API_PREFIX.length + 1).split("/");
+        if (parts[0] === "sessions" && parts[1]) {
+            const sessionId = decodeURIComponent(parts[1]);
+            const sub = parts[2];
+            if (!sub && method === "PUT") {
+                const body = await readJson(req);
+                const session = sessions.ensure(app, sessionId, body.template ?? []);
+                return sendJson(res, 200, { name: session.name, home: session.home, workspace: session.workspace, created: session.created });
+            }
+            if (!sub && method === "GET") {
+                const session = sessionOf(app, parts[1]);
+                return sendJson(res, 200, { name: session.name, home: session.home, workspace: session.workspace });
+            }
+            if (!sub && method === "DELETE") {
+                processes.killSession(sessionName(app, sessionId));
+                sessions.delete(app, sessionId);
+                return sendJson(res, 200, { deleted: true });
+            }
+            const session = sessionOf(app, parts[1]);
+            if (sub === "stop" && method === "POST") {
+                processes.killSession(session.name);
+                sessions.stop(session.name);
+                return sendJson(res, 200, { stopped: true });
+            }
+            if (sub === "processes" && method === "POST") {
+                const body = await readJson(req);
+                if (typeof body.command !== "string" || typeof body.cwd !== "string" || !body.cwd.startsWith("/"))
+                    throw new HttpError(400, "invalid_request");
+                const env = {};
+                for (const [key, value] of Object.entries(body.env ?? {}))
+                    if (typeof value === "string")
+                        env[key] = value;
+                const proc = processes.start(app, session, { command: body.command, cwd: body.cwd, env, stdin: body.stdin === true }, config.env);
+                return sendJson(res, 200, { id: proc.id, pid: proc.child.pid });
+            }
+            if (sub === "file" && method === "GET") {
+                const target = url.searchParams.get("path") ?? "";
+                if (!target.startsWith("/"))
+                    throw new HttpError(400, "invalid_path");
+                const bytes = fileop(session, { op: "read", path: target });
+                res.writeHead(200, { "content-type": "application/octet-stream", "content-length": bytes.length, "cache-control": "no-store" });
+                res.end(bytes);
+                return;
+            }
+            if (sub === "files" && method === "POST") {
+                const body = await readJson(req);
+                const files = (body.files ?? []).filter((f) => typeof f.path === "string" && typeof f.b64 === "string");
+                if (files.some((f) => !f.path.startsWith("/")))
+                    throw new HttpError(400, "invalid_path");
+                if (files.length > 0)
+                    fileop(session, { op: "write", files });
+                return sendJson(res, 200, { written: files.length });
+            }
+            if (sub === "remove" && method === "POST") {
+                const body = await readJson(req);
+                if (typeof body.path !== "string" || !body.path.startsWith("/"))
+                    throw new HttpError(400, "invalid_path");
+                fileop(session, { op: "remove", path: body.path, force: body.force === true, recursive: body.recursive === true });
+                return sendJson(res, 200, { removed: true });
+            }
+        }
+        if (parts[0] === "processes" && parts[1]) {
+            const proc = procOf(app, parts[1]);
+            const sub = parts[2];
+            if (sub === "events" && method === "GET")
+                return streamEvents(req, res, proc, Number(url.searchParams.get("after") ?? "0") || 0);
+            if (sub === "stdin" && method === "POST") {
+                const body = await readBody(req);
+                const stdin = proc.child.stdin;
+                if (!stdin)
+                    throw new HttpError(409, "no_stdin");
+                if (body.length > 0)
+                    await new Promise((resolve, reject) => stdin.write(body, (e) => (e ? reject(e) : resolve())));
+                if (url.searchParams.get("eof") === "1")
+                    stdin.end();
+                return sendJson(res, 200, { written: body.length });
+            }
+            if (sub === "kill" && method === "POST") {
+                processes.kill(proc);
+                return sendJson(res, 200, { killed: true });
+            }
+        }
+        throw new HttpError(404, "not_found");
+    }
+    function streamEvents(req, res, proc, after) {
+        res.writeHead(200, {
+            "content-type": "text/event-stream",
+            "cache-control": "no-store, no-transform",
+            "x-accel-buffering": "no",
+            connection: "keep-alive",
+        });
+        let sent = after;
+        const flush = () => {
+            while (sent < proc.events.length) {
+                const event = proc.events[sent];
+                sent = event.s;
+                res.write(`data: ${JSON.stringify(event)}\n\n`);
+                if ("x" in event) {
+                    finish();
+                    return;
+                }
+            }
+        };
+        const heartbeat = setInterval(() => res.write(": keep-alive\n\n"), 15_000);
+        const finish = () => {
+            clearInterval(heartbeat);
+            proc.listeners.delete(flush);
+            res.end();
+        };
+        req.on("close", () => {
+            clearInterval(heartbeat);
+            proc.listeners.delete(flush);
+        });
+        proc.listeners.add(flush);
+        flush();
+    }
+    const server = createServer((req, res) => {
+        route(req, res).catch((error) => {
+            if (res.headersSent) {
+                res.end();
+                return;
+            }
+            if (error instanceof HttpError)
+                return sendJson(res, error.status, { error: error.code, message: error.message });
+            sendJson(res, 500, { error: "internal", message: String(error?.message ?? error).slice(0, 300) });
+        });
+    });
+    server.requestTimeout = 0;
+    server.headersTimeout = 60_000;
+    const timers = [
+        setInterval(() => processes.prune(), 60_000),
+        setInterval(() => sessions.reapIdle(), 60_000),
+        setInterval(() => sessions.expireOld(), 60 * 60 * 1000),
+    ];
+    return {
+        server,
+        listen(port = config.port) {
+            return new Promise((resolve) => server.listen(port, "0.0.0.0", () => resolve()));
+        },
+        close() {
+            for (const timer of timers)
+                clearInterval(timer);
+            server.close();
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Entry point
+function argValue(flag) {
+    const index = process.argv.indexOf(flag);
+    return index >= 0 ? process.argv[index + 1] : undefined;
+}
+const isMain = (() => {
+    try {
+        return import.meta.url === `file://${process.argv[1]}` || (process.argv[1] ?? "").endsWith("eve-sandbox-daemon.js");
+    }
+    catch {
+        return false;
+    }
+})();
+if (isMain) {
+    const command = process.argv[2];
+    if (command === "fileop")
+        runFileOp();
+    if (command === "serve") {
+        const config = loadConfig(argValue("--config"));
+        const daemon = createDaemon(config);
+        await daemon.listen();
+        process.stdout.write(`eve sandbox daemon ${DAEMON_VERSION} on :${config.port} for ${config.audience}, ${config.allow.length} allowed\n`);
+    }
+    else if (command !== "fileop") {
+        process.stderr.write("usage: eve-sandbox-daemon serve [--config <path>] | fileop\n");
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=daemon.js.map