@aresdefencelabs/wasm-http-runtime 0.1.4 → 0.1.7

package/hostingEngine/wasm-http-runtime.js

@@ -0,0 +1,578 @@
+export function createWasmHttpRuntime(config) {
+    const {
+        wasmModule,
+        createModule,
+        debug = false,
+        responseTtlMs = 60_000,
+        maxHttpResponseHandles = 128,
+        maxTotalBridgeBytes = 8 * 1024 * 1024,
+        maxResponseBodyBytes = 2 * 1024 * 1024,
+        onLog = null,
+        onError = null,
+        beforeOutboundFetch = null,
+        afterOutboundFetch = null,
+    } = config ?? {};
+
+    if (!wasmModule) {
+        throw new Error("createWasmHttpRuntime: wasmModule is required");
+    }
+
+    if (typeof createModule !== "function") {
+        throw new Error("createWasmHttpRuntime: createModule is required");
+    }
+
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+
+    const state = {
+        instance: null,
+        requestContext: null,
+        nextHttpResponseId: 1,
+        httpResponses: new Map(),
+        options: {
+            debug,
+            responseTtlMs,
+            maxHttpResponseHandles,
+            maxTotalBridgeBytes,
+            maxResponseBodyBytes,
+            onLog,
+            onError,
+            beforeOutboundFetch,
+            afterOutboundFetch,
+        },
+    };
+
+    let instancePromise = null;
+    let currentInstance = null;
+
+    function log(...args) {
+        if (state.options.debug) {
+            console.log(...args);
+        }
+    }
+
+    function pickExport(mod, names) {
+        for (const name of names) {
+            const fn = mod?.[name];
+            if (typeof fn === "function") {
+                return fn;
+            }
+        }
+        return null;
+    }
+
+    function getModule(instance) {
+        if (!instance) {
+            throw new Error("WASM module is not available");
+        }
+        return instance;
+    }
+
+    function getHeapU8(mod) {
+        if (mod?.HEAPU8 instanceof Uint8Array) {
+            return mod.HEAPU8;
+        }
+        throw new Error("HEAPU8 is not exported on the Emscripten module");
+    }
+
+    function getBuffer(mod) {
+        return getHeapU8(mod).buffer;
+    }
+
+    function getCurrentBuffer() {
+        if (!currentInstance) {
+            throw new Error("WASM instance not ready");
+        }
+        return getBuffer(currentInstance);
+    }
+
+    function safeSetU32(ptr, value) {
+        if (!ptr) return;
+        const buffer = getCurrentBuffer();
+        const start = ptr >>> 0;
+        if (start + 4 > buffer.byteLength) return;
+        new DataView(buffer).setUint32(start, value >>> 0, true);
+    }
+
+    function safeSetU64Zero(ptr) {
+        if (!ptr) return;
+        const buffer = getCurrentBuffer();
+        const start = ptr >>> 0;
+        if (start + 8 > buffer.byteLength) return;
+        const view = new DataView(buffer);
+        view.setUint32(start, 0, true);
+        view.setUint32(start + 4, 0, true);
+    }
+
+    function headersToObject(headers) {
+        return Object.fromEntries(headers.entries());
+    }
+
+    function utf8ByteLength(value) {
+        return encoder.encode(value).length;
+    }
+
+    function normalizeHeaders(headers) {
+        const out = {};
+        for (const [key, value] of headers.entries()) {
+            out[key.toLowerCase()] = value;
+        }
+        return out;
+    }
+
+    function estimateResponseBytes(resp) {
+        let total = utf8ByteLength(resp.bodyText);
+        for (const [k, v] of Object.entries(resp.headers)) {
+            total += utf8ByteLength(k);
+            total += utf8ByteLength(v);
+        }
+        return total >>> 0;
+    }
+
+    function sweepExpiredResponses() {
+        const now = Date.now();
+        const ttl = state.options.responseTtlMs;
+
+        for (const [id, entry] of state.httpResponses.entries()) {
+            if (now - entry.createdAtMs > ttl) {
+                state.httpResponses.delete(id);
+            }
+        }
+    }
+
+    function getCurrentBridgeBytes() {
+        let total = 0;
+        for (const entry of state.httpResponses.values()) {
+            total += entry.estimatedBytes;
+        }
+        return total >>> 0;
+    }
+
+    function assertBridgeCapacity(nextEntryBytes) {
+        sweepExpiredResponses();
+
+        if (state.httpResponses.size >= state.options.maxHttpResponseHandles) {
+            throw new Error("Too many outstanding HTTP response handles");
+        }
+
+        const totalAfterInsert = getCurrentBridgeBytes() + nextEntryBytes;
+        if (totalAfterInsert > state.options.maxTotalBridgeBytes) {
+            throw new Error("HTTP response bridge memory budget exceeded");
+        }
+    }
+
+    function getResponseByIdOrEmpty(responseId) {
+        sweepExpiredResponses();
+
+        return (
+            state.httpResponses.get(responseId) ?? {
+                status: 0,
+                bodyText: "",
+                headers: {},
+                createdAtMs: 0,
+                estimatedBytes: 0,
+            }
+        );
+    }
+
+    function getAlloc(mod) {
+        const alloc = pickExport(mod, ["_alloc", "alloc", "_malloc", "malloc"]);
+        if (!alloc) {
+            throw new Error("No alloc/malloc export found");
+        }
+        return alloc;
+    }
+
+    function getFree(mod) {
+        const freeMem = pickExport(mod, ["_free_mem", "free_mem"]);
+        if (freeMem) {
+            return { fn: freeMem, takesSize: true };
+        }
+
+        const free = pickExport(mod, ["_free", "free"]);
+        if (free) {
+            return { fn: free, takesSize: false };
+        }
+
+        throw new Error("No free export found");
+    }
+
+    function writeCString(mod, value) {
+        const encoded = encoder.encode(value);
+        const alloc = getAlloc(mod);
+        const ptr = alloc(encoded.length + 1) >>> 0;
+
+        if (!ptr) {
+            throw new Error(`alloc failed for ${encoded.length + 1} bytes`);
+        }
+
+        const heap = getHeapU8(mod);
+
+        if (ptr + encoded.length + 1 > heap.length) {
+            throw new Error("Allocated CString buffer exceeds wasm memory bounds");
+        }
+
+        heap.set(encoded, ptr);
+        heap[ptr + encoded.length] = 0;
+
+        return {
+            ptr,
+            size: encoded.length + 1,
+        };
+    }
+
+    function freePtr(mod, ptr, size = 0) {
+        if (!ptr) return;
+
+        const free = getFree(mod);
+        if (free.takesSize) {
+            free.fn(ptr >>> 0, size >>> 0);
+        } else {
+            free.fn(ptr >>> 0);
+        }
+    }
+
+    function readCStringFromModule(mod, ptr, maxLen = 10_000_000) {
+        if (!ptr) return "";
+
+        if (typeof mod.UTF8ToString === "function") {
+            return mod.UTF8ToString(ptr);
+        }
+
+        const bytes = getHeapU8(mod);
+        const start = ptr >>> 0;
+
+        if (start >= bytes.length) {
+            throw new Error(`CString pointer out of bounds: ${ptr}`);
+        }
+
+        let end = start;
+        const limit = Math.min(bytes.length, start + maxLen);
+
+        while (end < limit && bytes[end] !== 0) {
+            end++;
+        }
+
+        if (end >= limit) {
+            throw new Error("CString terminator not found within safe bounds");
+        }
+
+        return decoder.decode(bytes.subarray(start, end));
+    }
+
+    function copyUtf8ToHeap(mod, value, outPtr, maxLen) {
+        const bytes = encoder.encode(value);
+        const count = Math.min(bytes.length, maxLen >>> 0);
+        getHeapU8(mod).set(bytes.subarray(0, count), outPtr >>> 0);
+        return count >>> 0;
+    }
+
+    function jsonResponse(status, body) {
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: { "content-type": "application/json; charset=utf-8" },
+        });
+    }
+
+    function makeBaseImports() {
+        return {
+            env: {
+                emscripten_notify_memory_growth: () => {},
+                emscripten_date_now: () => Date.now(),
+                emscripten_get_now: () => performance.now(),
+
+                abort: (msg, file, line, col) => {
+                    throw new Error(
+                        `abort: ${String(msg)} @ ${String(file)}:${String(line)}:${String(col)}`
+                    );
+                },
+            },
+
+            wasi_snapshot_preview1: {
+                fd_write(_fd, _iovs, _iovsLen, nwritten) {
+                    safeSetU32(nwritten, 0);
+                    return 0;
+                },
+
+                fd_read(_fd, _iovs, _iovsLen, nread) {
+                    safeSetU32(nread, 0);
+                    return 0;
+                },
+
+                fd_seek(_fd, _offsetLow, _offsetHigh, _whence, newOffset) {
+                    safeSetU64Zero(newOffset);
+                    return 0;
+                },
+
+                fd_close(_fd) {
+                    return 0;
+                },
+            },
+        };
+    }
+
+    async function bootWasm() {
+        if (instancePromise) {
+            return instancePromise;
+        }
+
+        instancePromise = (async () => {
+            const baseImports = makeBaseImports();
+
+            let mod = null;
+
+            mod = await createModule({
+                ...baseImports,
+
+                instantiateWasm(wasmImports, successCallback) {
+                    const finalImports = {
+                        ...wasmImports,
+                        env: {
+                            ...(wasmImports.env || {}),
+                            ...(baseImports.env || {}),
+                        },
+                        wasi_snapshot_preview1: {
+                            ...(wasmImports.wasi_snapshot_preview1 || {}),
+                            ...(baseImports.wasi_snapshot_preview1 || {}),
+                        },
+                    };
+
+                    const instance = new WebAssembly.Instance(wasmModule, finalImports);
+                    successCallback(instance);
+                    return instance.exports;
+                },
+
+                __aresAbiLog(messagePtr) {
+                    const message = readCStringFromModule(mod, messagePtr);
+
+                    if (typeof state.options.onLog === "function") {
+                        state.options.onLog(message);
+                    } else if (state.options.debug) {
+                        console.log("[AresWasm]", message);
+                    }
+                },
+
+                __aresAbiHttpGetUserAgentName() {
+                    const ctx = state.requestContext;
+                    const userAgent =
+                        ctx?.request?.headers.get("user-agent") ?? "Cloudflare-Worker";
+
+                    const written = writeCString(mod, userAgent);
+                    return written.ptr >>> 0;
+                },
+
+                __aresAbiHttpFetchBlockingAsync: async (requestJsonCstrPtr) => {
+                    log("[AresHost] __aresAbiHttpFetchBlockingAsync entered");
+
+                    try {
+                        const requestJson = readCStringFromModule(mod, requestJsonCstrPtr);
+                        log("[AresHost] requestJson =", requestJson);
+
+                        const outbound = JSON.parse(requestJson);
+                        log("[AresHost] parsed outbound =", outbound);
+
+                        if (typeof state.options.beforeOutboundFetch === "function") {
+                            state.options.beforeOutboundFetch(outbound);
+                        }
+
+                        log("[AresHost] before fetch:", outbound.url);
+
+                        const response = await fetch(outbound.url, {
+                            method: outbound.method ?? "GET",
+                            headers: outbound.headers,
+                            body: outbound.body ?? undefined,
+                        });
+
+                        log("[AresHost] fetch returned, status =", response.status);
+
+                        const bodyText = await response.text();
+                        log("[AresHost] response.text resolved, length =", bodyText.length);
+
+                        if (typeof state.options.afterOutboundFetch === "function") {
+                            state.options.afterOutboundFetch(response, bodyText, outbound);
+                        }
+
+                        const bodyBytes = utf8ByteLength(bodyText);
+
+                        if (bodyBytes > state.options.maxResponseBodyBytes) {
+                            throw new Error(
+                                `HTTP response body too large: ${bodyBytes} bytes exceeds maxResponseBodyBytes=${state.options.maxResponseBodyBytes}`
+                            );
+                        }
+
+                        const headers = normalizeHeaders(response.headers);
+                        const estimatedBytes = estimateResponseBytes({
+                            bodyText,
+                            headers,
+                        });
+
+                        assertBridgeCapacity(estimatedBytes);
+
+                        const responseId = state.nextHttpResponseId++;
+                        state.httpResponses.set(responseId, {
+                            status: response.status,
+                            bodyText,
+                            headers,
+                            createdAtMs: Date.now(),
+                            estimatedBytes,
+                        });
+
+                        log("[AresHost] stored responseId =", responseId);
+
+                        return responseId >>> 0;
+                    } catch (error) {
+                        console.error("[AresHost] __aresAbiHttpFetchBlockingAsync failed:", error);
+                        throw error;
+                    }
+                },
+
+                __aresAbiHttpResponseGetStatus(responseId) {
+                    return getResponseByIdOrEmpty(responseId).status >>> 0;
+                },
+
+                __aresAbiHttpResponseGetBodyLen(responseId) {
+                    return utf8ByteLength(getResponseByIdOrEmpty(responseId).bodyText);
+                },
+
+                __aresAbiHttpResponseCopyBody(responseId, outPtr, maxLen) {
+                    return copyUtf8ToHeap(
+                        mod,
+                        getResponseByIdOrEmpty(responseId).bodyText,
+                        outPtr,
+                        maxLen
+                    );
+                },
+
+                __aresAbiHttpResponseCopyHeader(responseId, keyPtr, outPtr, maxLen) {
+                    const key = readCStringFromModule(mod, keyPtr).toLowerCase();
+                    const value = getResponseByIdOrEmpty(responseId).headers[key] ?? "";
+                    return copyUtf8ToHeap(mod, value, outPtr, maxLen);
+                },
+
+                __aresAbiHttpResponseFree(responseId) {
+                    state.httpResponses.delete(responseId);
+                },
+            });
+
+            currentInstance = mod;
+            state.instance = mod;
+
+            log("WASM module keys:", Object.keys(mod));
+            log("HEAPU8 exported:", mod.HEAPU8 instanceof Uint8Array);
+            log("UTF8ToString exported:", typeof mod.UTF8ToString === "function");
+            log("ccall exported:", typeof mod.ccall === "function");
+
+            getHeapU8(mod);
+
+            const appInit = pickExport(mod, ["_app_init", "app_init"]);
+            if (appInit) {
+                const rc = await Promise.resolve(appInit());
+                if (rc !== 0) {
+                    throw new Error(`WASM app_init failed rc=${rc}`);
+                }
+            }
+
+            return mod;
+        })();
+
+        return instancePromise;
+    }
+
+    const ready = bootWasm();
+
+    async function handleFetch(request, env, ctx) {
+        let requestPtr = 0;
+        let requestSize = 0;
+        let responsePtr = 0;
+
+        try {
+            const inst = await ready;
+            const mod = getModule(inst);
+
+            state.requestContext = { request, env, ctx };
+
+            if (typeof mod.ccall !== "function") {
+                throw new Error("WASM runtime method ccall() is not available");
+            }
+
+            const bodyText = await request.text();
+            const url = new URL(request.url);
+
+            const inboundEnvelope = {
+                url: request.url,
+                path: url.pathname,
+                query: url.search,
+                method: request.method,
+                headers: headersToObject(request.headers),
+                body: bodyText,
+            };
+
+            const requestJson = JSON.stringify(inboundEnvelope);
+            const written = writeCString(mod, requestJson);
+            requestPtr = written.ptr;
+            requestSize = written.size;
+
+            responsePtr = await mod.ccall(
+                "handle_http",
+                "number",
+                ["number"],
+                [requestPtr],
+                { async: true }
+            );
+
+            log("[AresHost] ccall(handle_http) returned:", responsePtr);
+
+            if (!responsePtr) {
+                throw new Error("WASM returned null response pointer");
+            }
+
+            const responseJson = readCStringFromModule(mod, responsePtr);
+            const responseEnvelope = JSON.parse(responseJson);
+
+            return new Response(
+                typeof responseEnvelope.body === "string"
+                    ? responseEnvelope.body
+                    : JSON.stringify(responseEnvelope.body ?? ""),
+                {
+                    status: responseEnvelope.status ?? 200,
+                    headers: responseEnvelope.headers ?? {
+                        "content-type": "application/json; charset=utf-8",
+                    },
+                }
+            );
+        } catch (err) {
+            if (typeof state.options.onError === "function") {
+                try {
+                    state.options.onError(err);
+                } catch {}
+            }
+
+            return jsonResponse(500, {
+                error: "worker_wasm_failure",
+                message: err instanceof Error ? err.message : String(err),
+            });
+        } finally {
+            state.requestContext = null;
+
+            try {
+                const inst = instancePromise
+                    ? await instancePromise.catch(() => null)
+                    : null;
+
+                if (inst) {
+                    freePtr(inst, requestPtr, requestSize);
+                    freePtr(inst, responsePtr);
+                }
+            } catch {
+                // ignore cleanup failures
+            }
+        }
+    }
+
+    return {
+        fetch: handleFetch,
+        ready: () => ready,
+        getModule: () => currentInstance,
+        getState: () => state,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aresdefencelabs/wasm-http-runtime",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Runtime adapter that connects C++ WebAssembly workers to the Cloudflare Workers runtime via an ABI bridge.",
   "type": "module",
   "private": false,
@@ -36,5 +36,5 @@
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "files": ["dist", "emscripten"]
+  "files": ["dist", "emscripten", "hostingEngine"]
 }