@earendil-works/gondolin 0.0.1 → 0.1.1

package/dist/sandbox-ws-server.js

@@ -1,729 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SandboxWsServer = void 0;
-exports.resolveSandboxWsServerOptions = resolveSandboxWsServerOptions;
-const fs_1 = __importDefault(require("fs"));
-const net_1 = __importDefault(require("net"));
-const path_1 = __importDefault(require("path"));
-const child_process_1 = require("child_process");
-const events_1 = require("events");
-const ws_1 = require("ws");
-const virtio_protocol_1 = require("./virtio-protocol");
-const ws_protocol_1 = require("./ws-protocol");
-const sandbox_controller_1 = require("./sandbox-controller");
-const qemu_net_1 = require("./qemu-net");
-const MAX_REQUEST_ID = 0xffffffff;
-const DEFAULT_MAX_JSON_BYTES = 256 * 1024;
-const DEFAULT_MAX_STDIN_BYTES = 64 * 1024;
-function resolveSandboxWsServerOptions(options = {}) {
-    const repoRoot = path_1.default.resolve(__dirname, "../..");
-    const defaultKernel = path_1.default.resolve(repoRoot, "guest/image/out/vmlinuz-virt");
-    const defaultInitrd = path_1.default.resolve(repoRoot, "guest/image/out/initramfs.cpio.gz");
-    const defaultVirtio = path_1.default.resolve(repoRoot, "tmp/virtio.sock");
-    const defaultNetSock = path_1.default.resolve(repoRoot, "tmp/net.sock");
-    const defaultNetMac = "02:00:00:00:00:01";
-    const hostArch = detectHostArch();
-    const defaultQemu = hostArch === "arm64" ? "qemu-system-aarch64" : "qemu-system-x86_64";
-    const defaultMemory = hostArch === "arm64" ? "512M" : "256M";
-    return {
-        host: options.host ?? "127.0.0.1",
-        port: options.port ?? 8080,
-        qemuPath: options.qemuPath ?? defaultQemu,
-        kernelPath: options.kernelPath ?? defaultKernel,
-        initrdPath: options.initrdPath ?? defaultInitrd,
-        memory: options.memory ?? defaultMemory,
-        cpus: options.cpus ?? 1,
-        virtioSocketPath: options.virtioSocketPath ?? defaultVirtio,
-        netSocketPath: options.netSocketPath ?? defaultNetSock,
-        netMac: options.netMac ?? defaultNetMac,
-        netEnabled: options.netEnabled ?? true,
-        netDebug: options.netDebug ?? false,
-        machineType: options.machineType,
-        accel: options.accel,
-        cpu: options.cpu,
-        console: options.console,
-        token: options.token ?? process.env.ELWING_TOKEN ?? process.env.SANDBOX_WS_TOKEN,
-        autoRestart: options.autoRestart ?? true,
-        append: options.append,
-        maxJsonBytes: options.maxJsonBytes ?? DEFAULT_MAX_JSON_BYTES,
-        maxStdinBytes: options.maxStdinBytes ?? DEFAULT_MAX_STDIN_BYTES,
-        policy: options.policy ?? null,
-    };
-}
-function detectHostArch() {
-    if (process.arch === "arm64")
-        return "arm64";
-    if (process.platform === "darwin" && process.arch === "x64") {
-        try {
-            const result = (0, child_process_1.execSync)("sysctl -n hw.optional.arm64", {
-                stdio: ["ignore", "pipe", "ignore"],
-            })
-                .toString()
-                .trim();
-            if (result === "1")
-                return "arm64";
-        }
-        catch {
-            // ignore
-        }
-    }
-    return process.arch;
-}
-class VirtioBridge {
-    constructor(socketPath, maxPendingBytes = 8 * 1024 * 1024) {
-        this.socketPath = socketPath;
-        this.maxPendingBytes = maxPendingBytes;
-        this.socket = null;
-        this.server = null;
-        this.reader = new virtio_protocol_1.FrameReader();
-        this.reconnectTimer = null;
-        this.pending = [];
-        this.pendingBytes = 0;
-        this.waitingDrain = false;
-        this.allowReconnect = true;
-    }
-    connect() {
-        if (this.server)
-            return;
-        this.allowReconnect = true;
-        if (!fs_1.default.existsSync(path_1.default.dirname(this.socketPath))) {
-            fs_1.default.mkdirSync(path_1.default.dirname(this.socketPath), { recursive: true });
-        }
-        fs_1.default.rmSync(this.socketPath, { force: true });
-        const server = net_1.default.createServer((socket) => {
-            this.attachSocket(socket);
-        });
-        this.server = server;
-        server.on("error", (err) => {
-            this.onError?.(err);
-            server.close();
-        });
-        server.on("close", () => {
-            this.server = null;
-            this.scheduleReconnect();
-        });
-        server.listen(this.socketPath);
-    }
-    disconnect() {
-        this.allowReconnect = false;
-        if (this.reconnectTimer) {
-            clearTimeout(this.reconnectTimer);
-            this.reconnectTimer = null;
-        }
-        if (this.socket) {
-            this.socket.end();
-            this.socket = null;
-        }
-        if (this.server) {
-            this.server.close();
-            this.server = null;
-        }
-        this.waitingDrain = false;
-    }
-    send(message) {
-        if (!this.socket) {
-            this.connect();
-        }
-        const frame = (0, virtio_protocol_1.encodeFrame)(message);
-        if (this.pending.length === 0 && !this.waitingDrain) {
-            return this.writeFrame(frame);
-        }
-        const queued = this.queueFrame(frame);
-        if (queued && this.socket && this.socket.writable && !this.waitingDrain) {
-            this.flushPending();
-        }
-        return queued;
-    }
-    writeFrame(frame) {
-        if (!this.socket || !this.socket.writable) {
-            return this.queueFrame(frame);
-        }
-        const ok = this.socket.write(frame);
-        if (!ok) {
-            this.waitingDrain = true;
-            this.socket.once("drain", () => {
-                this.waitingDrain = false;
-                this.flushPending();
-            });
-        }
-        return true;
-    }
-    queueFrame(frame) {
-        if (this.pendingBytes + frame.length > this.maxPendingBytes) {
-            return false;
-        }
-        this.pending.push(frame);
-        this.pendingBytes += frame.length;
-        return true;
-    }
-    flushPending() {
-        if (!this.socket || this.waitingDrain || !this.socket.writable)
-            return;
-        while (this.pending.length > 0) {
-            const frame = this.pending.shift();
-            this.pendingBytes -= frame.length;
-            const ok = this.writeFrame(frame);
-            if (!ok || this.waitingDrain)
-                return;
-        }
-    }
-    attachSocket(socket) {
-        if (this.socket) {
-            this.socket.destroy();
-        }
-        this.socket = socket;
-        this.waitingDrain = false;
-        socket.on("data", (chunk) => {
-            this.reader.push(chunk, (frame) => {
-                try {
-                    const message = (0, virtio_protocol_1.decodeMessage)(frame);
-                    this.onMessage?.(message);
-                }
-                catch (err) {
-                    this.onError?.(err);
-                    this.handleDisconnect();
-                }
-            });
-        });
-        socket.on("error", (err) => {
-            this.onError?.(err);
-            this.handleDisconnect();
-        });
-        socket.on("end", () => {
-            this.handleDisconnect();
-        });
-        socket.on("close", () => {
-            this.handleDisconnect();
-        });
-        this.flushPending();
-    }
-    handleDisconnect() {
-        if (this.socket) {
-            this.socket.destroy();
-            this.socket = null;
-        }
-        this.waitingDrain = false;
-    }
-    scheduleReconnect() {
-        if (!this.allowReconnect || this.reconnectTimer)
-            return;
-        this.reconnectTimer = setTimeout(() => {
-            this.reconnectTimer = null;
-            if (this.allowReconnect) {
-                this.connect();
-            }
-        }, 500);
-    }
-}
-function parseMac(value) {
-    const parts = value.split(":");
-    if (parts.length !== 6)
-        return null;
-    const bytes = parts.map((part) => Number.parseInt(part, 16));
-    if (bytes.some((byte) => !Number.isFinite(byte) || byte < 0 || byte > 255))
-        return null;
-    return Buffer.from(bytes);
-}
-function isValidRequestId(value) {
-    return (typeof value === "number" &&
-        Number.isInteger(value) &&
-        value >= 0 &&
-        value <= MAX_REQUEST_ID);
-}
-function estimateBase64Bytes(value) {
-    const len = value.length;
-    const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
-    return Math.floor((len * 3) / 4) - padding;
-}
-function validateToken(headers, token) {
-    if (!token)
-        return true;
-    const headerToken = headers["x-elwing-token"] ?? headers["x-sandbox-token"];
-    if (typeof headerToken === "string" && headerToken === token)
-        return true;
-    if (Array.isArray(headerToken) && headerToken.includes(token))
-        return true;
-    const auth = headers.authorization;
-    if (typeof auth === "string" && auth.startsWith("Bearer ")) {
-        return auth.slice("Bearer ".length) === token;
-    }
-    return false;
-}
-function safeSend(ws, data, options) {
-    if (ws.readyState !== ws_1.WebSocket.OPEN)
-        return false;
-    try {
-        if (options) {
-            ws.send(data, options);
-        }
-        else {
-            ws.send(data);
-        }
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function sendJson(ws, message) {
-    return safeSend(ws, JSON.stringify(message));
-}
-function sendBinary(ws, data) {
-    return safeSend(ws, data, { binary: true });
-}
-function sendError(ws, error) {
-    return sendJson(ws, error);
-}
-function formatHost(host) {
-    return host.includes(":") ? `[${host}]` : host;
-}
-function resolveAddress(host, address) {
-    if (!address || typeof address === "string") {
-        const formattedHost = formatHost(host);
-        return {
-            host,
-            port: 0,
-            url: `ws://${formattedHost}`,
-        };
-    }
-    const formattedHost = formatHost(host);
-    return {
-        host,
-        port: address.port,
-        url: `ws://${formattedHost}:${address.port}`,
-    };
-}
-class SandboxWsServer extends events_1.EventEmitter {
-    constructor(options = {}) {
-        super();
-        this.wss = null;
-        this.inflight = new Map();
-        this.stdinAllowed = new Set();
-        this.startPromise = null;
-        this.stopPromise = null;
-        this.address = null;
-        this.qemuLogBuffer = "";
-        this.status = "stopped";
-        this.options = resolveSandboxWsServerOptions(options);
-        this.policy = this.options.policy;
-        const hostArch = detectHostArch();
-        const consoleDevice = hostArch === "arm64" ? "ttyAMA0" : "ttyS0";
-        const sandboxConfig = {
-            qemuPath: this.options.qemuPath,
-            kernelPath: this.options.kernelPath,
-            initrdPath: this.options.initrdPath,
-            memory: this.options.memory,
-            cpus: this.options.cpus,
-            virtioSocketPath: this.options.virtioSocketPath,
-            netSocketPath: this.options.netEnabled ? this.options.netSocketPath : undefined,
-            netMac: this.options.netMac,
-            append: this.options.append ?? `console=${consoleDevice}`,
-            machineType: this.options.machineType,
-            accel: this.options.accel,
-            cpu: this.options.cpu,
-            console: this.options.console,
-            autoRestart: this.options.autoRestart,
-        };
-        this.controller = new sandbox_controller_1.SandboxController(sandboxConfig);
-        this.bridge = new VirtioBridge(this.options.virtioSocketPath);
-        const mac = parseMac(this.options.netMac) ?? Buffer.from([0x02, 0x00, 0x00, 0x00, 0x00, 0x01]);
-        this.network = this.options.netEnabled
-            ? new qemu_net_1.QemuNetworkBackend({
-                socketPath: this.options.netSocketPath,
-                vmMac: mac,
-                debug: this.options.netDebug,
-                policy: this.policy ?? undefined,
-            })
-            : null;
-        if (this.network) {
-            this.network.on("log", (message) => {
-                this.emit("log", message);
-            });
-            this.network.on("error", (err) => {
-                this.emit("error", err);
-            });
-            this.network.on("policy", (policy) => {
-                this.emit("policy", policy);
-            });
-        }
-        this.controller.on("state", (state) => {
-            this.status = state;
-            if (state === "running") {
-                this.bridge.connect();
-            }
-            if (state === "stopped") {
-                this.failInflight("sandbox_stopped", "sandbox is not running");
-            }
-            if (!this.wss)
-                return;
-            for (const client of this.wss.clients) {
-                sendJson(client, { type: "status", state });
-            }
-            this.emit("state", state);
-        });
-        this.controller.on("exit", (info) => {
-            if (this.qemuLogBuffer.length > 0) {
-                this.emit("log", `[qemu] ${this.qemuLogBuffer}`);
-                this.qemuLogBuffer = "";
-            }
-            this.failInflight("sandbox_stopped", "sandbox exited");
-            this.emit("exit", info);
-        });
-        this.controller.on("log", (chunk) => {
-            this.qemuLogBuffer += chunk;
-            let newlineIndex = this.qemuLogBuffer.indexOf("\n");
-            while (newlineIndex !== -1) {
-                const line = this.qemuLogBuffer.slice(0, newlineIndex + 1);
-                this.qemuLogBuffer = this.qemuLogBuffer.slice(newlineIndex + 1);
-                this.emit("log", `[qemu] ${line}`);
-                newlineIndex = this.qemuLogBuffer.indexOf("\n");
-            }
-        });
-        this.bridge.onMessage = (message) => {
-            if (!isValidRequestId(message.id)) {
-                return;
-            }
-            if (message.t === "exec_output") {
-                const client = this.inflight.get(message.id);
-                if (!client)
-                    return;
-                const data = message.p.data;
-                try {
-                    if (!sendBinary(client, (0, ws_protocol_1.encodeOutputFrame)(message.id, message.p.stream, data))) {
-                        this.inflight.delete(message.id);
-                        this.stdinAllowed.delete(message.id);
-                    }
-                }
-                catch {
-                    this.inflight.delete(message.id);
-                    this.stdinAllowed.delete(message.id);
-                }
-            }
-            else if (message.t === "exec_response") {
-                const client = this.inflight.get(message.id);
-                if (client) {
-                    sendJson(client, {
-                        type: "exec_response",
-                        id: message.id,
-                        exit_code: message.p.exit_code,
-                        signal: message.p.signal,
-                    });
-                }
-                this.inflight.delete(message.id);
-                this.stdinAllowed.delete(message.id);
-            }
-            else if (message.t === "error") {
-                const client = this.inflight.get(message.id);
-                if (client) {
-                    sendError(client, {
-                        type: "error",
-                        id: message.id,
-                        code: message.p.code,
-                        message: message.p.message,
-                    });
-                }
-                this.inflight.delete(message.id);
-                this.stdinAllowed.delete(message.id);
-            }
-        };
-        this.bridge.onError = (err) => {
-            const message = err instanceof Error ? err.message : "unknown error";
-            this.emit("error", new Error(`[virtio] decode error: ${message}`));
-            this.failInflight("protocol_error", "virtio decode error");
-        };
-    }
-    getAddress() {
-        return this.address;
-    }
-    getUrl() {
-        return this.address?.url ?? null;
-    }
-    getState() {
-        return this.status;
-    }
-    getPolicy() {
-        return this.policy;
-    }
-    setPolicy(policy) {
-        this.policy = policy;
-        this.network?.setPolicy(policy);
-        this.emit("policy", policy);
-    }
-    async start() {
-        if (this.startPromise)
-            return this.startPromise;
-        this.startPromise = this.startInternal().finally(() => {
-            this.startPromise = null;
-        });
-        return this.startPromise;
-    }
-    async stop() {
-        if (this.stopPromise)
-            return this.stopPromise;
-        this.stopPromise = this.stopInternal().finally(() => {
-            this.stopPromise = null;
-        });
-        return this.stopPromise;
-    }
-    async startInternal() {
-        if (this.wss) {
-            return this.address ?? resolveAddress(this.options.host, this.wss.address());
-        }
-        this.wss = new ws_1.WebSocketServer({
-            host: this.options.host,
-            port: this.options.port,
-            maxPayload: this.options.maxJsonBytes,
-            verifyClient: (info, done) => {
-                if (!validateToken(info.req.headers, this.options.token)) {
-                    done(false, 401, "Unauthorized");
-                    return;
-                }
-                done(true);
-            },
-        });
-        this.wss.on("connection", (ws) => this.handleConnection(ws));
-        this.wss.on("close", () => {
-            this.wss = null;
-            this.address = null;
-        });
-        this.network?.start();
-        this.bridge.connect();
-        void this.controller.start();
-        const address = await new Promise((resolve, reject) => {
-            const handleError = (err) => {
-                cleanup();
-                reject(err);
-            };
-            const handleListening = () => {
-                cleanup();
-                const resolved = resolveAddress(this.options.host, this.wss?.address() ?? null);
-                this.address = resolved;
-                resolve(resolved);
-            };
-            const cleanup = () => {
-                this.wss?.off("error", handleError);
-                this.wss?.off("listening", handleListening);
-            };
-            this.wss?.once("error", handleError);
-            this.wss?.once("listening", handleListening);
-        });
-        return address;
-    }
-    async stopInternal() {
-        this.failInflight("server_shutdown", "server is shutting down");
-        await this.controller.stop();
-        this.bridge.disconnect();
-        this.network?.stop();
-        if (this.wss) {
-            for (const client of this.wss.clients) {
-                client.terminate();
-            }
-            await new Promise((resolve) => {
-                let finished = false;
-                const finish = () => {
-                    if (finished)
-                        return;
-                    finished = true;
-                    clearTimeout(timeout);
-                    resolve();
-                };
-                const timeout = setTimeout(() => {
-                    finish();
-                }, 1000);
-                this.wss?.close(() => finish());
-            });
-        }
-        this.wss = null;
-        this.address = null;
-    }
-    handleConnection(ws) {
-        if (!sendJson(ws, { type: "status", state: this.controller.getState() })) {
-            ws.close();
-            return;
-        }
-        ws.on("message", (data, isBinary) => {
-            if (isBinary) {
-                sendError(ws, {
-                    type: "error",
-                    code: "invalid_message",
-                    message: "binary input frames are not supported",
-                });
-                return;
-            }
-            const size = typeof data === "string"
-                ? Buffer.byteLength(data)
-                : Buffer.isBuffer(data)
-                    ? data.length
-                    : Array.isArray(data)
-                        ? data.reduce((total, chunk) => total + chunk.length, 0)
-                        : data.byteLength;
-            if (size > this.options.maxJsonBytes) {
-                sendError(ws, {
-                    type: "error",
-                    code: "payload_too_large",
-                    message: "message exceeds size limit",
-                });
-                return;
-            }
-            let message;
-            try {
-                message = JSON.parse(data.toString());
-            }
-            catch {
-                sendError(ws, {
-                    type: "error",
-                    code: "invalid_json",
-                    message: "failed to parse JSON",
-                });
-                return;
-            }
-            if (message.type === "exec") {
-                this.handleExec(ws, message);
-            }
-            else if (message.type === "stdin") {
-                this.handleStdin(ws, message);
-            }
-            else if (message.type === "lifecycle") {
-                if (message.action === "restart") {
-                    void this.controller.restart();
-                }
-                else if (message.action === "shutdown") {
-                    void this.controller.stop();
-                }
-            }
-            else if (message.type === "policy") {
-                this.handlePolicy(ws, message);
-            }
-            else {
-                sendError(ws, {
-                    type: "error",
-                    code: "unknown_type",
-                    message: "unsupported message type",
-                });
-            }
-        });
-        ws.on("close", () => {
-            for (const [id, client] of this.inflight.entries()) {
-                if (client === ws) {
-                    this.inflight.delete(id);
-                    this.stdinAllowed.delete(id);
-                }
-            }
-        });
-    }
-    handleExec(ws, message) {
-        if (!isValidRequestId(message.id) || !message.cmd) {
-            sendError(ws, {
-                type: "error",
-                code: "invalid_request",
-                message: "exec requires uint32 id and cmd",
-            });
-            return;
-        }
-        if (this.inflight.has(message.id)) {
-            sendError(ws, {
-                type: "error",
-                id: message.id,
-                code: "duplicate_id",
-                message: "request id already in use",
-            });
-            return;
-        }
-        this.inflight.set(message.id, ws);
-        if (message.stdin)
-            this.stdinAllowed.add(message.id);
-        const payload = {
-            cmd: message.cmd,
-            argv: message.argv ?? [],
-            env: message.env ?? [],
-            cwd: message.cwd,
-            stdin: message.stdin ?? false,
-            pty: message.pty ?? false,
-        };
-        if (!this.bridge.send((0, virtio_protocol_1.buildExecRequest)(message.id, payload))) {
-            this.inflight.delete(message.id);
-            this.stdinAllowed.delete(message.id);
-            sendError(ws, {
-                type: "error",
-                id: message.id,
-                code: "queue_full",
-                message: "virtio bridge queue exceeded",
-            });
-        }
-    }
-    handleStdin(ws, message) {
-        if (!isValidRequestId(message.id)) {
-            sendError(ws, {
-                type: "error",
-                code: "invalid_request",
-                message: "stdin requires a uint32 id",
-            });
-            return;
-        }
-        if (!this.inflight.has(message.id)) {
-            sendError(ws, {
-                type: "error",
-                id: message.id,
-                code: "unknown_id",
-                message: "request id not found",
-            });
-            return;
-        }
-        if (!this.stdinAllowed.has(message.id)) {
-            sendError(ws, {
-                type: "error",
-                id: message.id,
-                code: "stdin_disabled",
-                message: "stdin was not enabled for this request",
-            });
-            return;
-        }
-        const base64 = message.data ?? "";
-        if (base64 && estimateBase64Bytes(base64) > this.options.maxStdinBytes) {
-            sendError(ws, {
-                type: "error",
-                id: message.id,
-                code: "payload_too_large",
-                message: "stdin chunk exceeds size limit",
-            });
-            return;
-        }
-        const data = base64 ? Buffer.from(base64, "base64") : Buffer.alloc(0);
-        if (data.length > this.options.maxStdinBytes) {
-            sendError(ws, {
-                type: "error",
-                id: message.id,
-                code: "payload_too_large",
-                message: "stdin chunk exceeds size limit",
-            });
-            return;
-        }
-        if (!this.bridge.send((0, virtio_protocol_1.buildStdinData)(message.id, data, message.eof))) {
-            sendError(ws, {
-                type: "error",
-                id: message.id,
-                code: "queue_full",
-                message: "virtio bridge queue exceeded",
-            });
-        }
-    }
-    handlePolicy(_ws, message) {
-        this.setPolicy(message.policy);
-    }
-    failInflight(code, message) {
-        for (const [id, client] of this.inflight.entries()) {
-            sendError(client, {
-                type: "error",
-                id,
-                code,
-                message,
-            });
-        }
-        this.inflight.clear();
-        this.stdinAllowed.clear();
-    }
-}
-exports.SandboxWsServer = SandboxWsServer;