@secure-exec/core 0.0.0-split-runtime-preview.7b0dded

package/dist/frame-stream.js

@@ -0,0 +1,99 @@
+import { encodeLengthPrefixedPayload, tryDecodeLengthPrefixedPayload, } from "./framing.js";
+export class StdioFrameTransport {
+    stdin;
+    stdout;
+    encodeFrame;
+    decodeFrame;
+    frameListeners = new Set();
+    errorListeners = new Set();
+    endListeners = new Set();
+    stdoutBuffer = Buffer.alloc(0);
+    constructor(options) {
+        this.stdin = options.stdin;
+        this.stdout = options.stdout;
+        this.encodeFrame = options.encodeFrame;
+        this.decodeFrame = options.decodeFrame;
+        this.stdout.on("data", this.handleData);
+        this.stdout.on("end", this.handleEnd);
+        this.stdout.on("error", this.handleError);
+    }
+    onFrame(handler) {
+        this.frameListeners.add(handler);
+        return () => {
+            this.frameListeners.delete(handler);
+        };
+    }
+    onError(handler) {
+        this.errorListeners.add(handler);
+        return () => {
+            this.errorListeners.delete(handler);
+        };
+    }
+    onEnd(handler) {
+        this.endListeners.add(handler);
+        return () => {
+            this.endListeners.delete(handler);
+        };
+    }
+    async writeFrame(frame) {
+        const payload = this.encodeFrame(frame);
+        const encoded = encodeLengthPrefixedPayload(payload);
+        await new Promise((resolve, reject) => {
+            this.stdin.write(encoded, (error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+    }
+    dispose() {
+        this.stdout.off("data", this.handleData);
+        this.stdout.off("end", this.handleEnd);
+        this.stdout.off("error", this.handleError);
+        this.frameListeners.clear();
+        this.errorListeners.clear();
+        this.endListeners.clear();
+    }
+    handleData = (chunk) => {
+        const bytes = typeof chunk === "string"
+            ? Buffer.from(chunk)
+            : Buffer.isBuffer(chunk)
+                ? chunk
+                : Buffer.from(chunk);
+        this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, bytes]);
+        this.drainFrames();
+    };
+    handleEnd = () => {
+        for (const listener of this.endListeners) {
+            listener();
+        }
+    };
+    handleError = (error) => {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        for (const listener of this.errorListeners) {
+            listener(normalized);
+        }
+    };
+    drainFrames() {
+        for (;;) {
+            const decoded = tryDecodeLengthPrefixedPayload(this.stdoutBuffer);
+            if (!decoded) {
+                return;
+            }
+            this.stdoutBuffer = decoded.remaining;
+            let frame;
+            try {
+                frame = this.decodeFrame(decoded.payload);
+            }
+            catch (error) {
+                this.handleError(error);
+                continue;
+            }
+            for (const listener of this.frameListeners) {
+                listener(frame);
+            }
+        }
+    }
+}

package/dist/framing.d.ts

@@ -0,0 +1,7 @@
+export declare const LENGTH_PREFIX_BYTES = 4;
+export interface LengthPrefixedPayload {
+    payload: Buffer;
+    remaining: Buffer;
+}
+export declare function encodeLengthPrefixedPayload(payload: Uint8Array): Buffer;
+export declare function tryDecodeLengthPrefixedPayload(buffer: Uint8Array): LengthPrefixedPayload | null;

package/dist/framing.js

@@ -0,0 +1,22 @@
+export const LENGTH_PREFIX_BYTES = 4;
+export function encodeLengthPrefixedPayload(payload) {
+    const encoded = Buffer.allocUnsafe(LENGTH_PREFIX_BYTES + payload.length);
+    encoded.writeUInt32BE(payload.length, 0);
+    encoded.set(payload, LENGTH_PREFIX_BYTES);
+    return encoded;
+}
+export function tryDecodeLengthPrefixedPayload(buffer) {
+    const source = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+    if (source.length < LENGTH_PREFIX_BYTES) {
+        return null;
+    }
+    const declaredLength = source.readUInt32BE(0);
+    const frameEnd = LENGTH_PREFIX_BYTES + declaredLength;
+    if (source.length < frameEnd) {
+        return null;
+    }
+    return {
+        payload: source.subarray(LENGTH_PREFIX_BYTES, frameEnd),
+        remaining: source.subarray(frameEnd),
+    };
+}