@torkbot/sandbox 0.1.0-pre.0 → 0.1.1

package/dist/host-process.js

@@ -0,0 +1,705 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { Binary, BSON } from "bson";
+import { hostBinaryPath, macosHostSigningError } from "./artifacts.js";
+import { isSandboxWritableFileSystem } from "./vfs.js";
+export class HostProcessSandboxVm {
+    hasControlSocket = true;
+    packets;
+    #child;
+    #options;
+    #packets = new AsyncQueue();
+    #packetActivity = new AsyncSignal();
+    #hostFs = new Map();
+    #requestHeaderHooks;
+    #buffer = new Uint8Array();
+    #stderr = "";
+    #closed = false;
+    #exitError = null;
+    #stdinError = null;
+    constructor(child, options, requestHeaderHooks) {
+        this.#child = child;
+        this.#options = options;
+        this.packets = this.#packets;
+        this.#requestHeaderHooks = requestHeaderHooks;
+        for (const mount of options.mounts ?? []) {
+            if (mount.kind === "virtual-fs") {
+                this.#hostFs.set(mount.path, mount.fileSystem);
+            }
+        }
+        child.stdout.on("data", (chunk) => {
+            this.#receive(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            const text = chunk.toString("utf8").trim();
+            if (text.length > 0) {
+                this.#stderr = this.#stderr.length === 0 ? text : `${this.#stderr}\n${text}`;
+            }
+        });
+        child.stdin.on("error", (error) => {
+            this.#stdinError = error;
+            if (this.#exitError === null) {
+                this.#exitError = new Error(`sandbox-host stdin failed: ${error.message}`);
+            }
+        });
+        child.on("exit", (code, signal) => {
+            if (this.#closed) {
+                return;
+            }
+            const exitText = signal === null
+                ? `sandbox-host exited with ${code ?? "unknown status"}`
+                : `sandbox-host exited from signal ${signal}`;
+            this.#exitError = new Error(this.#stderr.length === 0 ? exitText : `${exitText}\n${this.#stderr}`);
+            this.#packets.close(this.#exitError);
+            this.#packetActivity.close(this.#exitError);
+        });
+    }
+    static async spawn(options, hostOptions, requestHeaderHooks = new Map()) {
+        let vm;
+        const hostPath = hostBinaryPath();
+        try {
+            const child = spawn(hostPath, ["--stdio"], {
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            vm = new HostProcessSandboxVm(child, options, requestHeaderHooks);
+            await Promise.race([
+                once(child, "spawn"),
+                once(child, "error").then(([error]) => {
+                    throw error;
+                }),
+            ]);
+            vm.#writeToHost(encodeHostSpawn(hostOptions));
+            await vm.#waitForLaunch();
+            return vm;
+        }
+        catch (error) {
+            await vm?.close();
+            const signingError = macosHostSigningError(hostPath);
+            if (signingError !== null) {
+                throw signingError;
+            }
+            throw error;
+        }
+    }
+    writeControlPacket(packet) {
+        this.#assertOpen();
+        this.#writeToHost(packet);
+    }
+    async close() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        this.#packets.close();
+        this.#packetActivity.close();
+        const exited = this.#child.exitCode !== null || this.#child.signalCode !== null
+            ? Promise.resolve()
+            : once(this.#child, "exit").then(() => undefined);
+        this.#child.stdin.destroy();
+        this.#child.kill("SIGTERM");
+        await Promise.race([
+            exited,
+            delay(500),
+        ]);
+        if (this.#child.exitCode !== null || this.#child.signalCode !== null) {
+            return;
+        }
+        this.#child.kill("SIGKILL");
+        await Promise.race([
+            exited,
+            delay(1_000),
+        ]);
+    }
+    async terminateHostForTest() {
+        if (this.#child.exitCode !== null || this.#child.signalCode !== null) {
+            return;
+        }
+        const exited = once(this.#child, "exit").then(() => undefined);
+        this.#child.kill("SIGTERM");
+        await Promise.race([
+            exited,
+            delay(1_000),
+        ]);
+        if (this.#child.exitCode !== null || this.#child.signalCode !== null) {
+            return;
+        }
+        this.#child.kill("SIGKILL");
+        await exited;
+    }
+    #assertOpen() {
+        if (this.#closed) {
+            throw new Error("sandbox VM is closed");
+        }
+        if (this.#stdinError !== null) {
+            throw this.#stdinError;
+        }
+        if (this.#exitError !== null) {
+            throw this.#exitError;
+        }
+    }
+    #writeToHost(packet) {
+        this.#assertOpen();
+        this.#writeOpenPacket(packet);
+    }
+    #writeOpenPacket(packet) {
+        if (!this.#child.stdin.writable) {
+            throw new Error("sandbox-host stdin is closed");
+        }
+        this.#child.stdin.write(packet, (error) => {
+            if (error !== null && error !== undefined) {
+                this.#stdinError = error;
+                if (this.#exitError === null) {
+                    this.#exitError = new Error(`sandbox-host stdin failed: ${error.message}`);
+                }
+            }
+        });
+    }
+    #tryWriteToHost(packet) {
+        if (this.#closed || this.#stdinError !== null || this.#exitError !== null) {
+            return;
+        }
+        try {
+            this.#writeOpenPacket(packet);
+        }
+        catch (error) {
+            if (!this.#closed && this.#stdinError === null && this.#exitError === null) {
+                throw error;
+            }
+        }
+    }
+    #receive(chunk) {
+        const next = new Uint8Array(this.#buffer.byteLength + chunk.byteLength);
+        next.set(this.#buffer);
+        next.set(chunk, this.#buffer.byteLength);
+        this.#buffer = next;
+        while (this.#buffer.byteLength >= 4) {
+            const frameLength = new DataView(this.#buffer.buffer, this.#buffer.byteOffset, 4).getUint32(0, true);
+            const packetLength = 4 + frameLength;
+            if (this.#buffer.byteLength < packetLength) {
+                return;
+            }
+            const packet = this.#buffer.slice(0, packetLength);
+            this.#buffer = this.#buffer.slice(packetLength);
+            this.#packetActivity.notify();
+            if (!this.#routeHostPacket(packet)) {
+                this.#packets.push(packet);
+            }
+        }
+    }
+    #routeHostPacket(packet) {
+        let document;
+        try {
+            document = BSON.deserialize(packet.slice(4));
+        }
+        catch {
+            return false;
+        }
+        const type = document.type;
+        if (type !== "host.vfs.stat"
+            && type !== "host.vfs.list"
+            && type !== "host.vfs.read"
+            && type !== "host.vfs.create"
+            && type !== "host.vfs.write"
+            && type !== "host.vfs.truncate"
+            && type !== "host.vfs.mkdir"
+            && type !== "host.vfs.unlink"
+            && type !== "host.vfs.rmdir"
+            && type !== "host.vfs.rename"
+            && type !== "host.vfs.symlink"
+            && type !== "host.vfs.readlink"
+            && type !== "host.http.requestHeaders"
+            && type !== "host.http.activeRequestHeaderHooks") {
+            return false;
+        }
+        if (type === "host.http.requestHeaders") {
+            void this.#handleHttpRequestHeaders(document);
+        }
+        else if (type === "host.http.activeRequestHeaderHooks") {
+            void this.#handleActiveRequestHeaderHooks(document);
+        }
+        else {
+            void this.#handleVirtualFsRequest(document);
+        }
+        return true;
+    }
+    async #handleHttpRequestHeaders(document) {
+        const id = typeof document.id === "string" ? document.id : "";
+        try {
+            const hookIds = assertStringArray(document.hookIds, "hookIds");
+            const originalHeaders = assertHeaderPairs(document.headers, "headers");
+            const headers = new Headers(originalHeaders);
+            const mutatedHeaders = trackHeaderMutations(headers);
+            const request = {
+                protocol: assertProtocol(document.protocol),
+                url: new URL(assertString(document.url, "url")),
+                method: assertString(document.method, "method"),
+                headers,
+                destination: {
+                    originalIp: assertString(document.originalDestinationIp, "originalDestinationIp"),
+                    originalPort: assertNumber(document.originalDestinationPort, "originalDestinationPort"),
+                    upstreamIp: assertString(document.upstreamDialIp, "upstreamDialIp"),
+                    upstreamPort: assertNumber(document.upstreamDialPort, "upstreamDialPort"),
+                },
+                tls: optionalTlsMetadata(document.tls),
+            };
+            for (const hookId of hookIds) {
+                const registration = this.#requestHeaderHooks.get(hookId);
+                if (registration?.active === true) {
+                    await registration.hook(request);
+                }
+            }
+            this.#tryWriteToHost(encodePacket({
+                type: "host.http.response",
+                id,
+                ok: true,
+                headers: mutatedHeaders()
+                    ? Array.from(headers.entries())
+                    : originalHeaders,
+            }));
+        }
+        catch (error) {
+            this.#tryWriteToHost(encodePacket({
+                type: "host.http.response",
+                id,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }
+    async #handleActiveRequestHeaderHooks(document) {
+        const id = typeof document.id === "string" ? document.id : "";
+        try {
+            const hookIds = assertStringArray(document.hookIds, "hookIds");
+            this.#tryWriteToHost(encodePacket({
+                type: "host.http.response",
+                id,
+                ok: true,
+                hookIds: hookIds.filter((hookId) => this.#requestHeaderHooks.get(hookId)?.active === true),
+            }));
+        }
+        catch (error) {
+            this.#tryWriteToHost(encodePacket({
+                type: "host.http.response",
+                id,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }
+    async #handleVirtualFsRequest(document) {
+        const id = typeof document.id === "string" ? document.id : "";
+        try {
+            const mountPath = assertString(document.mountPath, "mountPath");
+            const fileSystem = this.#hostFs.get(mountPath);
+            if (fileSystem === undefined) {
+                throw new Error(`host filesystem mount not found: ${mountPath}`);
+            }
+            switch (document.type) {
+                case "host.vfs.stat": {
+                    const path = assertString(document.path, "path");
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        stat: await fileSystem.stat(path),
+                    }));
+                    return;
+                }
+                case "host.vfs.list": {
+                    const path = assertString(document.path, "path");
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        entries: await fileSystem.list(path),
+                    }));
+                    return;
+                }
+                case "host.vfs.read": {
+                    const path = assertString(document.path, "path");
+                    const offset = assertNumber(document.offset, "offset");
+                    const size = assertNumber(document.size, "size");
+                    const contents = await fileSystem.read({
+                        path,
+                        range: { offset, length: size },
+                        signal: AbortSignal.timeout(30_000),
+                    });
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        contents,
+                    }));
+                    return;
+                }
+                case "host.vfs.create": {
+                    const path = assertString(document.path, "path");
+                    if (!isSandboxWritableFileSystem(fileSystem)) {
+                        throw new Error(`host filesystem mount is read-only: ${mountPath}`);
+                    }
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        stat: await fileSystem.createFile(path),
+                    }));
+                    return;
+                }
+                case "host.vfs.write": {
+                    const path = assertString(document.path, "path");
+                    if (!isSandboxWritableFileSystem(fileSystem)) {
+                        throw new Error(`host filesystem mount is read-only: ${mountPath}`);
+                    }
+                    const offset = assertNumber(document.offset, "offset");
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        written: await fileSystem.write({
+                            path,
+                            offset,
+                            contents: binaryField(document.contents, "contents"),
+                        }),
+                    }));
+                    return;
+                }
+                case "host.vfs.truncate": {
+                    const path = assertString(document.path, "path");
+                    if (!isSandboxWritableFileSystem(fileSystem)) {
+                        throw new Error(`host filesystem mount is read-only: ${mountPath}`);
+                    }
+                    const size = assertNumber(document.size, "size");
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        stat: await fileSystem.truncate(path, size),
+                    }));
+                    return;
+                }
+                case "host.vfs.mkdir": {
+                    const path = assertString(document.path, "path");
+                    const posix = assertPosixFileSystem(fileSystem, mountPath);
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        stat: await posix.mkdir(path),
+                    }));
+                    return;
+                }
+                case "host.vfs.unlink": {
+                    const path = assertString(document.path, "path");
+                    const posix = assertPosixFileSystem(fileSystem, mountPath);
+                    await posix.unlink(path);
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                    }));
+                    return;
+                }
+                case "host.vfs.rmdir": {
+                    const path = assertString(document.path, "path");
+                    const posix = assertPosixFileSystem(fileSystem, mountPath);
+                    await posix.rmdir(path);
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                    }));
+                    return;
+                }
+                case "host.vfs.rename": {
+                    const posix = assertPosixFileSystem(fileSystem, mountPath);
+                    const from = assertString(document.from, "from");
+                    const to = assertString(document.to, "to");
+                    const flags = assertNumber(document.flags, "flags");
+                    await posix.rename(from, to, flags);
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                    }));
+                    return;
+                }
+                case "host.vfs.symlink": {
+                    const path = assertString(document.path, "path");
+                    const posix = assertPosixFileSystem(fileSystem, mountPath);
+                    const target = assertString(document.target, "target");
+                    const stat = await posix.symlink(target, path);
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        stat,
+                    }));
+                    return;
+                }
+                case "host.vfs.readlink": {
+                    const path = assertString(document.path, "path");
+                    const posix = assertPosixFileSystem(fileSystem, mountPath);
+                    this.#tryWriteToHost(encodePacket({
+                        type: "host.vfs.response",
+                        id,
+                        ok: true,
+                        target: await posix.readlink(path),
+                    }));
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            this.#tryWriteToHost(encodePacket({
+                type: "host.vfs.response",
+                id,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }
+    async #waitForLaunch() {
+        await Promise.race([
+            this.#packetActivity.wait(),
+            once(this.#child, "exit").then(() => {
+                throw this.#exitError ?? new Error("sandbox-host exited before VM launch completed");
+            }),
+            delay(10_000).then(() => {
+                throw new Error("sandbox-host did not produce a launch acknowledgement");
+            }),
+        ]);
+    }
+}
+export { hostBinaryPath };
+function assertString(value, field) {
+    if (typeof value !== "string") {
+        throw new Error(`host vfs request ${field} must be a string`);
+    }
+    return value;
+}
+function assertNumber(value, field) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`host request ${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
+function assertStringArray(value, field) {
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new Error(`host request ${field} must be a string array`);
+    }
+    return value;
+}
+function assertHeaderPairs(value, field) {
+    if (!Array.isArray(value)
+        || value.some((entry) => {
+            return !Array.isArray(entry)
+                || entry.length !== 2
+                || typeof entry[0] !== "string"
+                || typeof entry[1] !== "string";
+        })) {
+        throw new Error(`host request ${field} must be header pairs`);
+    }
+    return value;
+}
+function trackHeaderMutations(headers) {
+    let mutated = false;
+    const set = headers.set.bind(headers);
+    const append = headers.append.bind(headers);
+    const deleteHeader = headers.delete.bind(headers);
+    Object.defineProperties(headers, {
+        set: {
+            value(name, value) {
+                mutated = true;
+                set(name, value);
+            },
+        },
+        append: {
+            value(name, value) {
+                mutated = true;
+                append(name, value);
+            },
+        },
+        delete: {
+            value(name) {
+                mutated = true;
+                deleteHeader(name);
+            },
+        },
+    });
+    return () => mutated;
+}
+function assertProtocol(value) {
+    if (value === "http/1.1" || value === "h2") {
+        return value;
+    }
+    throw new Error("host request protocol must be http/1.1 or h2");
+}
+function optionalTlsMetadata(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== "object") {
+        throw new Error("host request tls must be a document");
+    }
+    const document = value;
+    return {
+        sni: document.sni === undefined || document.sni === null
+            ? undefined
+            : assertString(document.sni, "tls.sni"),
+        alpn: document.alpn === undefined || document.alpn === null
+            ? undefined
+            : assertString(document.alpn, "tls.alpn"),
+    };
+}
+function binaryField(value, field) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (value instanceof Binary) {
+        return value.buffer;
+    }
+    throw new Error(`host request ${field} must be binary`);
+}
+function assertPosixFileSystem(fileSystem, mountPath) {
+    const candidate = fileSystem;
+    if (!isSandboxWritableFileSystem(fileSystem)
+        || typeof candidate.mkdir !== "function"
+        || typeof candidate.unlink !== "function"
+        || typeof candidate.rmdir !== "function"
+        || typeof candidate.rename !== "function"
+        || typeof candidate.symlink !== "function"
+        || typeof candidate.readlink !== "function") {
+        throw new Error(`host filesystem mount does not support POSIX mutations: ${mountPath}`);
+    }
+    return candidate;
+}
+function delay(milliseconds) {
+    return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+class AsyncQueue {
+    #values = [];
+    #nextWaiters = [];
+    #closed = false;
+    #error;
+    get length() {
+        return this.#values.length;
+    }
+    push(value) {
+        if (this.#closed) {
+            return;
+        }
+        const nextWaiter = this.#nextWaiters.shift();
+        if (nextWaiter !== undefined) {
+            nextWaiter.resolve({ value, done: false });
+        }
+        else {
+            this.#values.push(value);
+        }
+    }
+    close(error) {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        this.#error = error;
+        for (const waiter of this.#nextWaiters.splice(0)) {
+            if (error === undefined) {
+                waiter.resolve({ value: undefined, done: true });
+            }
+            else {
+                waiter.reject(error);
+            }
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: async () => {
+                const value = this.#values.shift();
+                if (value !== undefined) {
+                    return { value, done: false };
+                }
+                if (this.#closed) {
+                    if (this.#error !== undefined) {
+                        throw this.#error;
+                    }
+                    return { value: undefined, done: true };
+                }
+                return await new Promise((resolve, reject) => {
+                    this.#nextWaiters.push({
+                        resolve,
+                        reject,
+                    });
+                });
+            },
+        };
+    }
+}
+class AsyncSignal {
+    #waiters = [];
+    #signaled = false;
+    #closed = false;
+    #error;
+    notify() {
+        if (this.#closed) {
+            return;
+        }
+        this.#signaled = true;
+        for (const waiter of this.#waiters.splice(0)) {
+            waiter.resolve();
+        }
+    }
+    close(error) {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        this.#error = error;
+        for (const waiter of this.#waiters.splice(0)) {
+            if (error === undefined) {
+                waiter.resolve();
+            }
+            else {
+                waiter.reject(error);
+            }
+        }
+    }
+    async wait() {
+        if (this.#signaled) {
+            return;
+        }
+        if (this.#closed) {
+            if (this.#error !== undefined) {
+                throw this.#error;
+            }
+            throw new Error("sandbox-host packet activity closed");
+        }
+        return await new Promise((resolve, reject) => {
+            this.#waiters.push({ resolve, reject });
+        });
+    }
+}
+function encodeHostSpawn(options) {
+    return encodePacket({
+        type: "host.spawn",
+        name: options.name,
+        vcpus: options.cpu?.vcpus,
+        memoryMib: options.memory?.mib,
+        kernelFormat: options.kernel.format,
+        initCrate: options.init.crateName,
+        rootfsPath: options.rootfs.path,
+        rootfsReadonly: options.rootfs.readonly,
+        rootfsFormat: options.rootfs.format,
+        rootfsOverlayMode: options.rootfsOverlay?.mode,
+        mounts: options.mounts ?? [],
+        networkOutbound: options.network?.outbound,
+        networkHttp: options.network?.http === undefined ? undefined : options.network.http,
+    });
+}
+function encodePacket(document) {
+    const frame = BSON.serialize(document, { ignoreUndefined: true });
+    const packet = new Uint8Array(4 + frame.byteLength);
+    new DataView(packet.buffer, packet.byteOffset, 4).setUint32(0, frame.byteLength, true);
+    packet.set(frame, 4);
+    return packet;
+}
+//# sourceMappingURL=host-process.js.map