@earendil-works/gondolin 0.0.1 → 0.1.0

package/dist/virtio-protocol.js

@@ -1,96 +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.FrameReader = exports.MAX_FRAME = void 0;
-exports.normalize = normalize;
-exports.decodeMessage = decodeMessage;
-exports.buildExecRequest = buildExecRequest;
-exports.buildStdinData = buildStdinData;
-exports.encodeFrame = encodeFrame;
-const cbor_1 = __importDefault(require("cbor"));
-exports.MAX_FRAME = 4 * 1024 * 1024;
-class FrameReader {
-    constructor() {
-        this.buffer = Buffer.alloc(0);
-        this.expectedLength = null;
-    }
-    push(chunk, onFrame) {
-        this.buffer = Buffer.concat([this.buffer, chunk]);
-        while (true) {
-            if (this.expectedLength === null) {
-                if (this.buffer.length < 4)
-                    return;
-                this.expectedLength = this.buffer.readUInt32BE(0);
-                this.buffer = this.buffer.slice(4);
-                if (this.expectedLength > exports.MAX_FRAME) {
-                    throw new Error(`Frame too large: ${this.expectedLength}`);
-                }
-            }
-            if (this.buffer.length < this.expectedLength)
-                return;
-            const frame = this.buffer.slice(0, this.expectedLength);
-            this.buffer = this.buffer.slice(this.expectedLength);
-            this.expectedLength = null;
-            onFrame(frame);
-        }
-    }
-}
-exports.FrameReader = FrameReader;
-function normalize(value) {
-    if (value instanceof Map) {
-        const obj = {};
-        for (const [key, entry] of value.entries()) {
-            obj[String(key)] = normalize(entry);
-        }
-        return obj;
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => normalize(entry));
-    }
-    if (value instanceof Uint8Array && !Buffer.isBuffer(value)) {
-        return Buffer.from(value);
-    }
-    return value;
-}
-function decodeMessage(frame) {
-    const raw = cbor_1.default.decodeFirstSync(frame);
-    return normalize(raw);
-}
-function buildExecRequest(id, payload) {
-    const cleaned = { cmd: payload.cmd };
-    if (payload.argv !== undefined)
-        cleaned.argv = payload.argv;
-    if (payload.env !== undefined)
-        cleaned.env = payload.env;
-    if (payload.cwd !== undefined)
-        cleaned.cwd = payload.cwd;
-    if (payload.stdin !== undefined)
-        cleaned.stdin = payload.stdin;
-    if (payload.pty !== undefined)
-        cleaned.pty = payload.pty;
-    return {
-        v: 1,
-        t: "exec_request",
-        id,
-        p: cleaned,
-    };
-}
-function buildStdinData(id, data, eof) {
-    return {
-        v: 1,
-        t: "stdin_data",
-        id,
-        p: {
-            data,
-            ...(eof ? { eof } : {}),
-        },
-    };
-}
-function encodeFrame(message) {
-    const payload = cbor_1.default.encode(message);
-    const header = Buffer.alloc(4);
-    header.writeUInt32BE(payload.length, 0);
-    return Buffer.concat([header, payload]);
-}

package/dist/vm.js

@@ -1,523 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VM = void 0;
-const ws_1 = require("ws");
-const stream_1 = require("stream");
-const ws_protocol_1 = require("./ws-protocol");
-const sandbox_ws_server_1 = require("./sandbox-ws-server");
-const MAX_REQUEST_ID = 0xffffffff;
-const DEFAULT_STDIN_CHUNK = 32 * 1024;
-class VM {
-    constructor(options = {}) {
-        this.ws = null;
-        this.connectPromise = null;
-        this.startPromise = null;
-        this.stopPromise = null;
-        this.statusPromise = null;
-        this.statusResolve = null;
-        this.statusReject = null;
-        this.state = "unknown";
-        this.stateWaiters = [];
-        this.sessions = new Map();
-        this.nextId = 1;
-        if (options.url && options.server) {
-            throw new Error("VM cannot specify both url and server options");
-        }
-        this.token =
-            options.token ?? process.env.ELWING_TOKEN ?? process.env.SANDBOX_WS_TOKEN;
-        this.autoStart = options.autoStart ?? true;
-        this.policy = options.policy ?? null;
-        if (options.url) {
-            this.url = options.url;
-            this.server = null;
-            return;
-        }
-        const serverOptions = { ...options.server };
-        if (serverOptions.host === undefined)
-            serverOptions.host = "127.0.0.1";
-        if (serverOptions.port === undefined)
-            serverOptions.port = 0;
-        if (this.policy && serverOptions.policy === undefined) {
-            serverOptions.policy = this.policy;
-        }
-        this.server = new sandbox_ws_server_1.SandboxWsServer(serverOptions);
-        this.url = null;
-    }
-    getState() {
-        return this.state;
-    }
-    getUrl() {
-        return this.url;
-    }
-    getPolicy() {
-        return this.policy;
-    }
-    setPolicy(policy) {
-        this.policy = policy;
-        if (this.server) {
-            this.server.setPolicy(policy);
-        }
-        if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN) {
-            this.sendJson({ type: "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 exec(command, options = {}) {
-        const stream = await this.execStream(command, { ...options, buffer: true });
-        return stream.result;
-    }
-    async execStream(command, options = {}) {
-        await this.start();
-        const { cmd, argv } = normalizeCommand(command, options);
-        const id = this.allocateId();
-        const stdinSetting = options.stdin;
-        const stdinEnabled = stdinSetting !== undefined && stdinSetting !== false;
-        const session = this.createSession(id, {
-            bufferOutput: options.buffer ?? false,
-            stdinEnabled,
-            stdout: options.stdout,
-            stderr: options.stderr,
-            signal: options.signal,
-        });
-        this.sessions.set(id, session);
-        const message = {
-            type: "exec",
-            id,
-            cmd,
-            argv: argv.length ? argv : undefined,
-            env: options.env && options.env.length ? options.env : undefined,
-            cwd: options.cwd,
-            stdin: stdinEnabled ? true : undefined,
-            pty: options.pty ? true : undefined,
-        };
-        try {
-            this.sendJson(message);
-        }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.rejectSession(session, error);
-            throw error;
-        }
-        if (stdinEnabled && stdinSetting !== true) {
-            void this.pipeStdin(id, stdinSetting ?? "", session);
-        }
-        return {
-            id,
-            stdout: session.stdout,
-            stderr: session.stderr,
-            sendStdin: async (data) => {
-                this.ensureStdinAllowed(id);
-                this.sendStdinData(id, data);
-            },
-            endStdin: async () => {
-                this.ensureStdinAllowed(id);
-                this.sendStdinEof(id);
-            },
-            result: session.result,
-        };
-    }
-    async startInternal() {
-        if (this.server) {
-            const address = await this.server.start();
-            this.url = address.url;
-        }
-        await this.ensureConnection();
-        await this.ensureRunning();
-    }
-    async stopInternal() {
-        if (this.server) {
-            await this.server.stop();
-            this.url = null;
-        }
-        await this.disconnect();
-    }
-    allocateId() {
-        for (let i = 0; i <= MAX_REQUEST_ID; i += 1) {
-            const id = this.nextId;
-            this.nextId = this.nextId + 1;
-            if (this.nextId > MAX_REQUEST_ID)
-                this.nextId = 1;
-            if (!this.sessions.has(id))
-                return id;
-        }
-        throw new Error("no available request ids");
-    }
-    createSession(id, options) {
-        let resolve;
-        let reject;
-        const result = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        const session = {
-            id,
-            stdout: new stream_1.PassThrough(),
-            stderr: new stream_1.PassThrough(),
-            bufferOutput: options.bufferOutput,
-            stdoutChunks: [],
-            stderrChunks: [],
-            resolve,
-            reject,
-            result,
-            stdinEnabled: options.stdinEnabled,
-            stdoutCallback: options.stdout,
-            stderrCallback: options.stderr,
-            signal: options.signal,
-        };
-        if (options.signal) {
-            const onAbort = () => {
-                this.rejectSession(session, new Error("exec aborted"));
-            };
-            options.signal.addEventListener("abort", onAbort, { once: true });
-            session.signalListener = onAbort;
-        }
-        return session;
-    }
-    ensureStdinAllowed(id) {
-        const session = this.sessions.get(id);
-        if (!session) {
-            throw new Error(`stdin is not available for request ${id}`);
-        }
-        if (!session.stdinEnabled) {
-            throw new Error(`stdin was not enabled for request ${id}`);
-        }
-    }
-    async pipeStdin(id, input, session) {
-        if (!session.stdinEnabled)
-            return;
-        try {
-            if (typeof input === "string" || Buffer.isBuffer(input)) {
-                this.sendStdinData(id, input);
-            }
-            else if (typeof input === "boolean") {
-                // no-op
-            }
-            else {
-                for await (const chunk of toAsyncIterable(input)) {
-                    if (!this.sessions.has(id))
-                        return;
-                    this.sendStdinData(id, chunk);
-                }
-            }
-            if (this.sessions.has(id)) {
-                this.sendStdinEof(id);
-            }
-        }
-        catch (err) {
-            const error = err instanceof Error ? err : new Error(String(err));
-            this.rejectSession(session, error);
-        }
-    }
-    sendStdinData(id, data) {
-        const payload = typeof data === "string" ? Buffer.from(data) : Buffer.from(data);
-        for (let offset = 0; offset < payload.length; offset += DEFAULT_STDIN_CHUNK) {
-            const slice = payload.subarray(offset, offset + DEFAULT_STDIN_CHUNK);
-            this.sendJson({
-                type: "stdin",
-                id,
-                data: slice.toString("base64"),
-            });
-        }
-    }
-    sendStdinEof(id) {
-        this.sendJson({
-            type: "stdin",
-            id,
-            eof: true,
-        });
-    }
-    async ensureConnection() {
-        if (this.ws && this.ws.readyState === ws_1.WebSocket.OPEN)
-            return;
-        if (this.connectPromise)
-            return this.connectPromise;
-        if (!this.url) {
-            throw new Error("WebSocket URL is not available");
-        }
-        this.resetConnectionState();
-        this.connectPromise = new Promise((resolve, reject) => {
-            const headers = {};
-            if (this.token)
-                headers.Authorization = `Bearer ${this.token}`;
-            const ws = new ws_1.WebSocket(this.url, { headers });
-            this.ws = ws;
-            let opened = false;
-            ws.on("open", () => {
-                opened = true;
-                this.flushPolicy();
-                resolve();
-            });
-            ws.on("message", (data, isBinary) => {
-                this.handleMessage(data, isBinary);
-            });
-            ws.on("close", () => {
-                const error = new Error("WebSocket closed");
-                if (!opened) {
-                    reject(error);
-                }
-                this.handleDisconnect(error);
-            });
-            ws.on("error", (err) => {
-                if (!opened) {
-                    reject(err);
-                    return;
-                }
-                const error = err instanceof Error ? err : new Error(String(err));
-                this.handleDisconnect(error);
-            });
-        }).finally(() => {
-            this.connectPromise = null;
-        });
-        return this.connectPromise;
-    }
-    resetConnectionState() {
-        this.state = "unknown";
-        this.initStatusPromise();
-    }
-    initStatusPromise() {
-        this.statusPromise = new Promise((resolve, reject) => {
-            this.statusResolve = resolve;
-            this.statusReject = reject;
-        });
-    }
-    flushPolicy() {
-        if (this.policy) {
-            this.sendJson({ type: "policy", policy: this.policy });
-        }
-    }
-    async ensureRunning() {
-        const state = await this.waitForStatus();
-        if (state === "running")
-            return;
-        if (state === "stopped") {
-            if (!this.autoStart) {
-                throw new Error("sandbox is stopped");
-            }
-            this.sendJson({ type: "lifecycle", action: "restart" });
-        }
-        await this.waitForState("running");
-    }
-    async waitForStatus() {
-        if (this.state !== "unknown")
-            return this.state;
-        if (!this.statusPromise) {
-            this.initStatusPromise();
-        }
-        return this.statusPromise;
-    }
-    waitForState(state) {
-        if (this.state === state)
-            return Promise.resolve();
-        return new Promise((resolve, reject) => {
-            this.stateWaiters.push({ state, resolve, reject });
-        });
-    }
-    handleMessage(data, isBinary) {
-        if (isBinary) {
-            const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
-            const frame = (0, ws_protocol_1.decodeOutputFrame)(buffer);
-            const session = this.sessions.get(frame.id);
-            if (!session)
-                return;
-            if (frame.stream === "stdout") {
-                session.stdout.write(frame.data);
-                if (session.bufferOutput)
-                    session.stdoutChunks.push(frame.data);
-                session.stdoutCallback?.(frame.data);
-            }
-            else {
-                session.stderr.write(frame.data);
-                if (session.bufferOutput)
-                    session.stderrChunks.push(frame.data);
-                session.stderrCallback?.(frame.data);
-            }
-            return;
-        }
-        let message;
-        try {
-            message = JSON.parse(data.toString());
-        }
-        catch {
-            return;
-        }
-        if (message.type === "status") {
-            this.updateState(message.state);
-            return;
-        }
-        if (message.type === "exec_response") {
-            this.handleExecResponse(message);
-            return;
-        }
-        if (message.type === "error") {
-            this.handleError(message);
-        }
-    }
-    updateState(state) {
-        this.state = state;
-        if (this.statusResolve) {
-            this.statusResolve(state);
-            this.statusResolve = null;
-            this.statusReject = null;
-            this.statusPromise = null;
-        }
-        if (this.stateWaiters.length > 0) {
-            const remaining = [];
-            for (const waiter of this.stateWaiters) {
-                if (waiter.state === state) {
-                    waiter.resolve();
-                }
-                else {
-                    remaining.push(waiter);
-                }
-            }
-            this.stateWaiters = remaining;
-        }
-    }
-    handleExecResponse(message) {
-        const session = this.sessions.get(message.id);
-        if (!session)
-            return;
-        const result = {
-            id: message.id,
-            exitCode: message.exit_code ?? 1,
-            signal: message.signal,
-            stdout: session.bufferOutput ? Buffer.concat(session.stdoutChunks) : Buffer.alloc(0),
-            stderr: session.bufferOutput ? Buffer.concat(session.stderrChunks) : Buffer.alloc(0),
-        };
-        this.finishSession(session, result);
-    }
-    handleError(message) {
-        const error = new Error(`error ${message.code}: ${message.message}`);
-        if (message.id === undefined) {
-            this.rejectAll(error);
-            return;
-        }
-        const session = this.sessions.get(message.id);
-        if (session) {
-            this.rejectSession(session, error);
-        }
-    }
-    finishSession(session, result) {
-        this.sessions.delete(session.id);
-        session.stdout.end();
-        session.stderr.end();
-        if (session.signal && session.signalListener) {
-            session.signal.removeEventListener("abort", session.signalListener);
-        }
-        session.resolve(result);
-    }
-    rejectSession(session, error) {
-        this.sessions.delete(session.id);
-        session.stdout.end();
-        session.stderr.end();
-        if (session.signal && session.signalListener) {
-            session.signal.removeEventListener("abort", session.signalListener);
-        }
-        session.reject(error);
-    }
-    rejectAll(error) {
-        for (const session of this.sessions.values()) {
-            this.rejectSession(session, error);
-        }
-        this.sessions.clear();
-    }
-    handleDisconnect(error) {
-        this.ws = null;
-        if (this.statusReject) {
-            this.statusReject(error ?? new Error("WebSocket disconnected"));
-            this.statusReject = null;
-            this.statusResolve = null;
-            this.statusPromise = null;
-        }
-        if (this.stateWaiters.length > 0) {
-            for (const waiter of this.stateWaiters) {
-                waiter.reject(error ?? new Error("WebSocket disconnected"));
-            }
-            this.stateWaiters = [];
-        }
-        this.rejectAll(error ?? new Error("WebSocket disconnected"));
-    }
-    async disconnect() {
-        if (!this.ws)
-            return;
-        const ws = this.ws;
-        this.ws = null;
-        if (ws.readyState === ws_1.WebSocket.CLOSED)
-            return;
-        await new Promise((resolve) => {
-            let finished = false;
-            const finish = () => {
-                if (finished)
-                    return;
-                finished = true;
-                clearTimeout(timeout);
-                resolve();
-            };
-            const timeout = setTimeout(() => {
-                ws.terminate();
-                finish();
-            }, 1000);
-            ws.once("close", finish);
-            ws.once("error", finish);
-            if (ws.readyState === ws_1.WebSocket.CLOSING) {
-                return;
-            }
-            ws.close();
-        });
-    }
-    sendJson(message) {
-        if (!this.ws || this.ws.readyState !== ws_1.WebSocket.OPEN) {
-            throw new Error("WebSocket is not connected");
-        }
-        this.ws.send(JSON.stringify(message));
-    }
-}
-exports.VM = VM;
-function normalizeCommand(command, options) {
-    if (Array.isArray(command)) {
-        if (command.length === 0) {
-            throw new Error("command array must include the executable");
-        }
-        return { cmd: command[0], argv: command.slice(1) };
-    }
-    return { cmd: command, argv: options.argv ?? [] };
-}
-function isAsyncIterable(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        Symbol.asyncIterator in value &&
-        typeof value[Symbol.asyncIterator] === "function");
-}
-async function* toAsyncIterable(value) {
-    if (typeof value === "string" || Buffer.isBuffer(value) || typeof value === "boolean") {
-        return;
-    }
-    if (isAsyncIterable(value)) {
-        for await (const chunk of value) {
-            yield Buffer.from(chunk);
-        }
-        return;
-    }
-    if (value instanceof stream_1.Readable) {
-        for await (const chunk of value) {
-            yield Buffer.from(chunk);
-        }
-        return;
-    }
-    throw new Error("unsupported stdin type");
-}

package/dist/ws-protocol.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OUTPUT_HEADER_BYTES = void 0;
-exports.encodeOutputFrame = encodeOutputFrame;
-exports.decodeOutputFrame = decodeOutputFrame;
-exports.OUTPUT_HEADER_BYTES = 5;
-function encodeOutputFrame(id, stream, data) {
-    if (!Number.isInteger(id) || id < 0 || id > 0xffffffff) {
-        throw new RangeError("id must be a uint32");
-    }
-    const header = Buffer.alloc(exports.OUTPUT_HEADER_BYTES);
-    header.writeUInt8(stream === "stdout" ? 1 : 2, 0);
-    header.writeUInt32BE(id, 1);
-    return Buffer.concat([header, data]);
-}
-function decodeOutputFrame(frame) {
-    if (frame.length < exports.OUTPUT_HEADER_BYTES) {
-        throw new Error("output frame too short");
-    }
-    const streamFlag = frame.readUInt8(0);
-    const stream = streamFlag === 1 ? "stdout" : "stderr";
-    const id = frame.readUInt32BE(1);
-    return {
-        id,
-        stream,
-        data: frame.slice(exports.OUTPUT_HEADER_BYTES),
-    };
-}