secure-exec 0.0.1 → 0.1.0-rc.1

package/dist/bridge/network.js

@@ -0,0 +1,1117 @@
+// @ts-nocheck
+// Network module polyfill for isolated-vm
+// Provides fetch, http, https, and dns module emulation that bridges to host
+import { exposeCustomGlobal } from "../shared/global-exposure.js";
+// Fetch polyfill
+export async function fetch(url, options = {}) {
+    if (typeof _networkFetchRaw === 'undefined') {
+        console.error('fetch requires NetworkAdapter to be configured');
+        throw new Error('fetch requires NetworkAdapter to be configured');
+    }
+    const optionsJson = JSON.stringify({
+        method: options.method || "GET",
+        headers: options.headers || {},
+        body: options.body || null,
+    });
+    const responseJson = await _networkFetchRaw.apply(undefined, [String(url), optionsJson], {
+        result: { promise: true },
+    });
+    const response = JSON.parse(responseJson);
+    // Create Response-like object
+    return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Map(Object.entries(response.headers || {})),
+        url: response.url || String(url),
+        redirected: response.redirected || false,
+        type: "basic",
+        async text() {
+            return response.body || "";
+        },
+        async json() {
+            return JSON.parse(response.body || "{}");
+        },
+        async arrayBuffer() {
+            // Not fully supported - return empty buffer
+            return new ArrayBuffer(0);
+        },
+        async blob() {
+            throw new Error("Blob not supported in sandbox");
+        },
+        clone() {
+            return { ...this };
+        },
+    };
+}
+// Headers class
+export class Headers {
+    _headers = {};
+    constructor(init) {
+        if (init && init !== null) {
+            if (init instanceof Headers) {
+                this._headers = { ...init._headers };
+            }
+            else if (Array.isArray(init)) {
+                init.forEach(([key, value]) => {
+                    this._headers[key.toLowerCase()] = value;
+                });
+            }
+            else if (typeof init === "object") {
+                Object.entries(init).forEach(([key, value]) => {
+                    this._headers[key.toLowerCase()] = value;
+                });
+            }
+        }
+    }
+    get(name) {
+        return this._headers[name.toLowerCase()] || null;
+    }
+    set(name, value) {
+        this._headers[name.toLowerCase()] = value;
+    }
+    has(name) {
+        return name.toLowerCase() in this._headers;
+    }
+    delete(name) {
+        delete this._headers[name.toLowerCase()];
+    }
+    entries() {
+        return Object.entries(this._headers)[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    keys() {
+        return Object.keys(this._headers)[Symbol.iterator]();
+    }
+    values() {
+        return Object.values(this._headers)[Symbol.iterator]();
+    }
+    forEach(callback) {
+        Object.entries(this._headers).forEach(([k, v]) => callback(v, k, this));
+    }
+}
+// Request class
+export class Request {
+    url;
+    method;
+    headers;
+    body;
+    mode;
+    credentials;
+    cache;
+    redirect;
+    referrer;
+    integrity;
+    constructor(input, init = {}) {
+        this.url = typeof input === "string" ? input : input.url;
+        this.method = init.method || (typeof input !== "string" ? input.method : undefined) || "GET";
+        this.headers = new Headers(init.headers || (typeof input !== "string" ? input.headers : undefined));
+        this.body = init.body || null;
+        this.mode = init.mode || "cors";
+        this.credentials = init.credentials || "same-origin";
+        this.cache = init.cache || "default";
+        this.redirect = init.redirect || "follow";
+        this.referrer = init.referrer || "about:client";
+        this.integrity = init.integrity || "";
+    }
+    clone() {
+        return new Request(this.url, this);
+    }
+}
+// Response class
+export class Response {
+    _body;
+    status;
+    statusText;
+    headers;
+    ok;
+    type;
+    url;
+    redirected;
+    constructor(body, init = {}) {
+        this._body = body || null;
+        this.status = init.status || 200;
+        this.statusText = init.statusText || "OK";
+        this.headers = new Headers(init.headers);
+        this.ok = this.status >= 200 && this.status < 300;
+        this.type = "default";
+        this.url = "";
+        this.redirected = false;
+    }
+    async text() {
+        return String(this._body || "");
+    }
+    async json() {
+        return JSON.parse(this._body || "{}");
+    }
+    clone() {
+        return new Response(this._body, this);
+    }
+    static error() {
+        return new Response(null, { status: 0, statusText: "" });
+    }
+    static redirect(url, status = 302) {
+        return new Response(null, { status, headers: { Location: url } });
+    }
+}
+// DNS module polyfill
+export const dns = {
+    lookup(hostname, options, callback) {
+        let cb = callback;
+        if (typeof options === "function") {
+            cb = options;
+        }
+        _networkDnsLookupRaw
+            .apply(undefined, [hostname], { result: { promise: true } })
+            .then((resultJson) => {
+            const result = JSON.parse(resultJson);
+            if (result.error) {
+                const err = new Error(result.error);
+                err.code = result.code || "ENOTFOUND";
+                cb?.(err);
+            }
+            else {
+                cb?.(null, result.address, result.family);
+            }
+        })
+            .catch((err) => {
+            cb?.(err);
+        });
+    },
+    resolve(hostname, rrtype, callback) {
+        let cb = callback;
+        if (typeof rrtype === "function") {
+            cb = rrtype;
+        }
+        // Simplified - just do lookup for A records
+        dns.lookup(hostname, (err, address) => {
+            if (err) {
+                cb?.(err);
+            }
+            else {
+                cb?.(null, address ? [address] : []);
+            }
+        });
+    },
+    resolve4(hostname, callback) {
+        dns.resolve(hostname, "A", callback);
+    },
+    resolve6(hostname, callback) {
+        dns.resolve(hostname, "AAAA", callback);
+    },
+    promises: {
+        lookup(hostname, _options) {
+            return new Promise((resolve, reject) => {
+                dns.lookup(hostname, _options, (err, address, family) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve({ address: address || "", family: family || 4 });
+                });
+            });
+        },
+        resolve(hostname, rrtype) {
+            return new Promise((resolve, reject) => {
+                dns.resolve(hostname, rrtype || "A", (err, addresses) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(addresses || []);
+                });
+            });
+        },
+    },
+};
+// IncomingMessage class
+export class IncomingMessage {
+    headers;
+    rawHeaders;
+    trailers;
+    rawTrailers;
+    httpVersion;
+    httpVersionMajor;
+    httpVersionMinor;
+    method;
+    url;
+    statusCode;
+    statusMessage;
+    _body;
+    _isBinary;
+    _listeners;
+    complete;
+    aborted;
+    socket;
+    _bodyConsumed;
+    _ended;
+    _flowing;
+    readable;
+    readableEnded;
+    readableFlowing;
+    destroyed;
+    _encoding;
+    constructor(response) {
+        this.headers = response?.headers || {};
+        this.rawHeaders = [];
+        if (this.headers && typeof this.headers === "object") {
+            Object.entries(this.headers).forEach(([k, v]) => {
+                this.rawHeaders.push(k, v);
+            });
+        }
+        this.trailers = {};
+        this.rawTrailers = [];
+        this.httpVersion = "1.1";
+        this.httpVersionMajor = 1;
+        this.httpVersionMinor = 1;
+        this.method = null;
+        this.url = response?.url || "";
+        this.statusCode = response?.status;
+        this.statusMessage = response?.statusText;
+        // Decode base64 body if x-body-encoding header is set
+        const bodyEncoding = this.headers['x-body-encoding'];
+        if (bodyEncoding === 'base64' && response?.body && typeof Buffer !== 'undefined') {
+            this._body = Buffer.from(response.body, 'base64').toString('binary');
+            this._isBinary = true;
+        }
+        else {
+            this._body = response?.body || "";
+            this._isBinary = false;
+        }
+        this._listeners = {};
+        this.complete = false;
+        this.aborted = false;
+        this.socket = null;
+        this._bodyConsumed = false;
+        this._ended = false;
+        this._flowing = false;
+        this.readable = true;
+        this.readableEnded = false;
+        this.readableFlowing = null;
+        this.destroyed = false;
+    }
+    on(event, listener) {
+        if (!this._listeners[event])
+            this._listeners[event] = [];
+        this._listeners[event].push(listener);
+        // When 'data' listener is added, start flowing mode
+        // Note: We check for non-empty body (this._body.length > 0) because we need to
+        // emit 'end' even for empty responses, but only emit 'data' if there's actual data
+        if (event === "data" && !this._bodyConsumed) {
+            this._flowing = true;
+            this.readableFlowing = true;
+            // Emit data in next microtask
+            Promise.resolve().then(() => {
+                if (!this._bodyConsumed) {
+                    this._bodyConsumed = true;
+                    // Only emit data if there's actual content
+                    if (this._body && this._body.length > 0) {
+                        let buf;
+                        if (typeof Buffer !== "undefined") {
+                            // For binary data, use 'binary' encoding to preserve bytes
+                            buf = this._isBinary ? Buffer.from(this._body, 'binary') : Buffer.from(this._body);
+                        }
+                        else {
+                            buf = this._body;
+                        }
+                        this.emit("data", buf);
+                    }
+                    // Always emit end after data (even if no data was emitted)
+                    Promise.resolve().then(() => {
+                        if (!this._ended) {
+                            this._ended = true;
+                            this.complete = true;
+                            this.readable = false;
+                            this.readableEnded = true;
+                            this.emit("end");
+                        }
+                    });
+                }
+            });
+        }
+        // If 'end' listener is added after data was already consumed, emit end
+        if (event === "end" && this._bodyConsumed && !this._ended) {
+            Promise.resolve().then(() => {
+                if (!this._ended) {
+                    this._ended = true;
+                    this.complete = true;
+                    this.readable = false;
+                    this.readableEnded = true;
+                    listener();
+                }
+            });
+        }
+        return this;
+    }
+    once(event, listener) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            listener(...args);
+        };
+        wrapper._originalListener = listener;
+        return this.on(event, wrapper);
+    }
+    off(event, listener) {
+        if (this._listeners[event]) {
+            const idx = this._listeners[event].findIndex((fn) => fn === listener || fn._originalListener === listener);
+            if (idx !== -1)
+                this._listeners[event].splice(idx, 1);
+        }
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    removeAllListeners(event) {
+        if (event) {
+            delete this._listeners[event];
+        }
+        else {
+            this._listeners = {};
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const handlers = this._listeners[event];
+        if (handlers) {
+            handlers.slice().forEach((fn) => fn(...args));
+        }
+        return handlers !== undefined && handlers.length > 0;
+    }
+    setEncoding(encoding) {
+        this._encoding = encoding;
+        return this;
+    }
+    read(_size) {
+        if (this._bodyConsumed)
+            return null;
+        this._bodyConsumed = true;
+        let buf;
+        if (typeof Buffer !== "undefined") {
+            buf = this._isBinary ? Buffer.from(this._body, 'binary') : Buffer.from(this._body);
+        }
+        else {
+            buf = this._body;
+        }
+        // Schedule end event
+        Promise.resolve().then(() => {
+            if (!this._ended) {
+                this._ended = true;
+                this.complete = true;
+                this.readable = false;
+                this.readableEnded = true;
+                this.emit("end");
+            }
+        });
+        return buf;
+    }
+    pipe(dest) {
+        let buf;
+        if (typeof Buffer !== "undefined") {
+            buf = this._isBinary ? Buffer.from(this._body || "", 'binary') : Buffer.from(this._body || "");
+        }
+        else {
+            buf = this._body || "";
+        }
+        if (typeof dest.write === "function" && (typeof buf === "string" ? buf.length : buf.length) > 0) {
+            dest.write(buf);
+        }
+        if (typeof dest.end === "function") {
+            Promise.resolve().then(() => dest.end());
+        }
+        this._bodyConsumed = true;
+        this._ended = true;
+        this.complete = true;
+        this.readable = false;
+        this.readableEnded = true;
+        return dest;
+    }
+    pause() {
+        this._flowing = false;
+        this.readableFlowing = false;
+        return this;
+    }
+    resume() {
+        this._flowing = true;
+        this.readableFlowing = true;
+        if (!this._bodyConsumed && this._body) {
+            Promise.resolve().then(() => {
+                if (!this._bodyConsumed) {
+                    this._bodyConsumed = true;
+                    let buf;
+                    if (typeof Buffer !== "undefined") {
+                        buf = this._isBinary ? Buffer.from(this._body, 'binary') : Buffer.from(this._body);
+                    }
+                    else {
+                        buf = this._body;
+                    }
+                    this.emit("data", buf);
+                    Promise.resolve().then(() => {
+                        if (!this._ended) {
+                            this._ended = true;
+                            this.complete = true;
+                            this.readable = false;
+                            this.readableEnded = true;
+                            this.emit("end");
+                        }
+                    });
+                }
+            });
+        }
+        return this;
+    }
+    unpipe(_dest) {
+        return this;
+    }
+    destroy(err) {
+        this.destroyed = true;
+        this.readable = false;
+        if (err)
+            this.emit("error", err);
+        this.emit("close");
+        return this;
+    }
+    [Symbol.asyncIterator]() {
+        const self = this;
+        let dataEmitted = false;
+        let ended = false;
+        return {
+            async next() {
+                if (ended || self._ended) {
+                    return { done: true, value: undefined };
+                }
+                if (!dataEmitted && !self._bodyConsumed) {
+                    dataEmitted = true;
+                    self._bodyConsumed = true;
+                    let buf;
+                    if (typeof Buffer !== "undefined") {
+                        buf = self._isBinary ? Buffer.from(self._body || "", 'binary') : Buffer.from(self._body || "");
+                    }
+                    else {
+                        buf = self._body || "";
+                    }
+                    return { done: false, value: buf };
+                }
+                ended = true;
+                self._ended = true;
+                self.complete = true;
+                self.readable = false;
+                self.readableEnded = true;
+                return { done: true, value: undefined };
+            },
+            return() {
+                ended = true;
+                return Promise.resolve({ done: true, value: undefined });
+            },
+            throw(err) {
+                ended = true;
+                self.emit("error", err);
+                return Promise.resolve({ done: true, value: undefined });
+            },
+        };
+    }
+}
+// ClientRequest class
+export class ClientRequest {
+    _options;
+    _callback;
+    _listeners = {};
+    _body = "";
+    _ended = false;
+    socket = null;
+    finished = false;
+    aborted = false;
+    constructor(options, callback) {
+        this._options = options;
+        this._callback = callback;
+        // Execute request asynchronously using Promise microtask
+        Promise.resolve().then(() => this._execute());
+    }
+    async _execute() {
+        try {
+            if (typeof _networkHttpRequestRaw === 'undefined') {
+                console.error('http/https request requires NetworkAdapter to be configured');
+                throw new Error('http/https request requires NetworkAdapter to be configured');
+            }
+            const url = this._buildUrl();
+            const optionsJson = JSON.stringify({
+                method: this._options.method || "GET",
+                headers: this._options.headers || {},
+                body: this._body || null,
+            });
+            const responseJson = await _networkHttpRequestRaw.apply(undefined, [url, optionsJson], {
+                result: { promise: true },
+            });
+            const response = JSON.parse(responseJson);
+            const res = new IncomingMessage(response);
+            this.finished = true;
+            if (this._callback) {
+                this._callback(res);
+            }
+            this._emit("response", res);
+        }
+        catch (err) {
+            this._emit("error", err);
+        }
+    }
+    _buildUrl() {
+        const opts = this._options;
+        const protocol = opts.protocol || (opts.port === 443 ? "https:" : "http:");
+        const host = opts.hostname || opts.host || "localhost";
+        const port = opts.port ? ":" + opts.port : "";
+        const path = opts.path || "/";
+        return protocol + "//" + host + port + path;
+    }
+    on(event, listener) {
+        if (!this._listeners[event])
+            this._listeners[event] = [];
+        this._listeners[event].push(listener);
+        return this;
+    }
+    once(event, listener) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            listener(...args);
+        };
+        return this.on(event, wrapper);
+    }
+    off(event, listener) {
+        if (this._listeners[event]) {
+            const idx = this._listeners[event].indexOf(listener);
+            if (idx !== -1)
+                this._listeners[event].splice(idx, 1);
+        }
+        return this;
+    }
+    _emit(event, ...args) {
+        if (this._listeners[event]) {
+            this._listeners[event].forEach((fn) => fn(...args));
+        }
+    }
+    write(data) {
+        this._body += data;
+        return true;
+    }
+    end(data) {
+        if (data)
+            this._body += data;
+        this._ended = true;
+        return this;
+    }
+    abort() {
+        this.aborted = true;
+    }
+    setTimeout(_timeout) {
+        return this;
+    }
+    setNoDelay() {
+        return this;
+    }
+    setSocketKeepAlive() {
+        return this;
+    }
+    flushHeaders() {
+        // no-op
+    }
+}
+// Agent class - no-op stub (connection pooling not applicable with fetch-based implementation)
+class Agent {
+    maxSockets;
+    maxFreeSockets;
+    keepAlive;
+    keepAliveMsecs;
+    timeout;
+    constructor(options) {
+        // Accept options but ignore them - our fetch-based implementation doesn't use connection pooling
+        this.keepAlive = options?.keepAlive ?? false;
+        this.keepAliveMsecs = options?.keepAliveMsecs ?? 1000;
+        this.maxSockets = options?.maxSockets ?? Infinity;
+        this.maxFreeSockets = options?.maxFreeSockets ?? 256;
+        this.timeout = options?.timeout ?? -1;
+    }
+    destroy() {
+        // no-op
+    }
+}
+let nextServerId = 1;
+const serverRequestListeners = new Map();
+class ServerIncomingMessage {
+    headers;
+    rawHeaders;
+    method;
+    url;
+    socket;
+    rawBody;
+    destroyed = false;
+    errored;
+    _listeners = {};
+    constructor(request) {
+        this.headers = request.headers || {};
+        this.rawHeaders = request.rawHeaders || [];
+        if (!Array.isArray(this.rawHeaders) || this.rawHeaders.length % 2 !== 0) {
+            this.rawHeaders = [];
+        }
+        this.method = request.method || "GET";
+        this.url = request.url || "/";
+        this.socket = { encrypted: false };
+        const rawHost = this.headers.host;
+        if (typeof rawHost === "string" && rawHost.includes(",")) {
+            this.headers.host = rawHost.split(",")[0].trim();
+        }
+        if (!this.headers.host) {
+            this.headers.host = "127.0.0.1";
+        }
+        if (this.rawHeaders.length === 0) {
+            Object.entries(this.headers).forEach(([key, value]) => {
+                this.rawHeaders.push(key, value);
+            });
+        }
+        if (request.bodyBase64 && typeof Buffer !== "undefined") {
+            this.rawBody = Buffer.from(request.bodyBase64, "base64");
+        }
+    }
+    on(event, listener) {
+        if (!this._listeners[event])
+            this._listeners[event] = [];
+        this._listeners[event].push(listener);
+        if (event === "end") {
+            Promise.resolve().then(() => listener());
+        }
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const listeners = this._listeners[event];
+        if (!listeners)
+            return this;
+        const index = listeners.indexOf(listener);
+        if (index !== -1)
+            listeners.splice(index, 1);
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    emit(event, ...args) {
+        const listeners = this._listeners[event];
+        if (!listeners || listeners.length === 0)
+            return false;
+        listeners.slice().forEach((fn) => fn(...args));
+        return true;
+    }
+    destroy(err) {
+        this.destroyed = true;
+        this.errored = err;
+        if (err) {
+            this.emit("error", err);
+        }
+        this.emit("close");
+        return this;
+    }
+}
+class ServerResponseBridge {
+    statusCode = 200;
+    statusMessage = "OK";
+    headersSent = false;
+    writable = true;
+    writableFinished = false;
+    _headers = new Map();
+    _chunks = [];
+    _listeners = {};
+    _closedPromise;
+    _resolveClosed = null;
+    constructor() {
+        this._closedPromise = new Promise((resolve) => {
+            this._resolveClosed = resolve;
+        });
+    }
+    on(event, listener) {
+        if (!this._listeners[event])
+            this._listeners[event] = [];
+        this._listeners[event].push(listener);
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const listeners = this._listeners[event];
+        if (!listeners)
+            return this;
+        const index = listeners.indexOf(listener);
+        if (index !== -1)
+            listeners.splice(index, 1);
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    _emit(event, ...args) {
+        const listeners = this._listeners[event];
+        if (!listeners)
+            return;
+        listeners.slice().forEach((fn) => fn(...args));
+    }
+    writeHead(statusCode, headers) {
+        this.statusCode = statusCode;
+        if (headers) {
+            if (Array.isArray(headers)) {
+                headers.forEach(([key, value]) => this.setHeader(key, value));
+            }
+            else {
+                Object.entries(headers).forEach(([key, value]) => this.setHeader(key, value));
+            }
+        }
+        this.headersSent = true;
+        return this;
+    }
+    setHeader(name, value) {
+        const normalized = Array.isArray(value) ? value.join(", ") : String(value);
+        this._headers.set(name.toLowerCase(), normalized);
+        return this;
+    }
+    getHeader(name) {
+        return this._headers.get(name.toLowerCase());
+    }
+    hasHeader(name) {
+        return this._headers.has(name.toLowerCase());
+    }
+    removeHeader(name) {
+        this._headers.delete(name.toLowerCase());
+    }
+    write(chunk) {
+        this.headersSent = true;
+        if (typeof chunk === "string") {
+            this._chunks.push(Buffer.from(chunk));
+        }
+        else {
+            this._chunks.push(chunk);
+        }
+        return true;
+    }
+    end(chunk) {
+        if (chunk !== undefined) {
+            this.write(chunk);
+        }
+        this._finalize();
+        return this;
+    }
+    flushHeaders() {
+        this.headersSent = true;
+    }
+    destroy(err) {
+        if (err) {
+            this._emit("error", err);
+        }
+        this._finalize();
+    }
+    async waitForClose() {
+        await this._closedPromise;
+    }
+    serialize() {
+        const bodyBuffer = this._chunks.length > 0 ? Buffer.concat(this._chunks) : Buffer.alloc(0);
+        return {
+            status: this.statusCode,
+            headers: Array.from(this._headers.entries()),
+            body: bodyBuffer.toString("base64"),
+            bodyEncoding: "base64",
+        };
+    }
+    _finalize() {
+        if (this.writableFinished) {
+            return;
+        }
+        this.writableFinished = true;
+        this.writable = false;
+        this._emit("finish");
+        this._emit("close");
+        this._resolveClosed?.();
+        this._resolveClosed = null;
+    }
+}
+class Server {
+    listening = false;
+    _listeners = {};
+    _serverId;
+    _listenPromise = null;
+    _address = null;
+    _handleId = null;
+    constructor(requestListener) {
+        this._serverId = nextServerId++;
+        if (requestListener) {
+            serverRequestListeners.set(this._serverId, requestListener);
+        }
+        else {
+            serverRequestListeners.set(this._serverId, () => undefined);
+        }
+    }
+    _emit(event, ...args) {
+        const listeners = this._listeners[event];
+        if (!listeners || listeners.length === 0)
+            return;
+        listeners.slice().forEach((listener) => listener(...args));
+    }
+    async _start(port, hostname) {
+        if (typeof _networkHttpServerListenRaw === "undefined") {
+            throw new Error("http.createServer requires NetworkAdapter.httpServerListen support");
+        }
+        const resultJson = await _networkHttpServerListenRaw.apply(undefined, [JSON.stringify({ serverId: this._serverId, port, hostname })], { result: { promise: true } });
+        const result = JSON.parse(resultJson);
+        this._address = result.address;
+        this.listening = true;
+        this._handleId = `http-server:${this._serverId}`;
+        if (typeof _registerHandle === "function") {
+            _registerHandle(this._handleId, "http server");
+        }
+    }
+    listen(portOrCb, hostOrCb, cb) {
+        const port = typeof portOrCb === "number" ? portOrCb : undefined;
+        const hostname = typeof hostOrCb === "string" ? hostOrCb : undefined;
+        const callback = typeof cb === "function"
+            ? cb
+            : typeof hostOrCb === "function"
+                ? hostOrCb
+                : typeof portOrCb === "function"
+                    ? portOrCb
+                    : undefined;
+        if (!this._listenPromise) {
+            this._listenPromise = this._start(port, hostname)
+                .then(() => {
+                this._emit("listening");
+                callback?.();
+            })
+                .catch((error) => {
+                this._emit("error", error);
+            });
+        }
+        return this;
+    }
+    close(cb) {
+        const run = async () => {
+            try {
+                if (this._listenPromise) {
+                    await this._listenPromise;
+                }
+                if (this.listening && typeof _networkHttpServerCloseRaw !== "undefined") {
+                    await _networkHttpServerCloseRaw.apply(undefined, [this._serverId], {
+                        result: { promise: true },
+                    });
+                }
+                this.listening = false;
+                this._address = null;
+                if (this._handleId && typeof _unregisterHandle === "function") {
+                    _unregisterHandle(this._handleId);
+                }
+                this._handleId = null;
+                cb?.();
+                this._emit("close");
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error(String(err));
+                cb?.(error);
+                this._emit("error", error);
+            }
+        };
+        void run();
+        return this;
+    }
+    address() {
+        return this._address;
+    }
+    on(event, listener) {
+        if (!this._listeners[event])
+            this._listeners[event] = [];
+        this._listeners[event].push(listener);
+        return this;
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        return this.on(event, wrapped);
+    }
+    off(event, listener) {
+        const listeners = this._listeners[event];
+        if (!listeners)
+            return this;
+        const index = listeners.indexOf(listener);
+        if (index !== -1)
+            listeners.splice(index, 1);
+        return this;
+    }
+    removeListener(event, listener) {
+        return this.off(event, listener);
+    }
+    removeAllListeners(event) {
+        if (event) {
+            delete this._listeners[event];
+        }
+        else {
+            this._listeners = {};
+        }
+        return this;
+    }
+    ref() {
+        return this;
+    }
+    unref() {
+        return this;
+    }
+}
+async function dispatchServerRequest(serverId, requestJson) {
+    const listener = serverRequestListeners.get(serverId);
+    if (!listener) {
+        throw new Error(`Unknown HTTP server: ${serverId}`);
+    }
+    const request = JSON.parse(requestJson);
+    const incoming = new ServerIncomingMessage(request);
+    const outgoing = new ServerResponseBridge();
+    try {
+        await Promise.resolve(listener(incoming, outgoing));
+    }
+    catch (err) {
+        outgoing.statusCode = 500;
+        outgoing.end(err instanceof Error ? `Error: ${err.message}` : "Error");
+    }
+    if (!outgoing.writableFinished) {
+        outgoing.end();
+    }
+    await outgoing.waitForClose();
+    return JSON.stringify(outgoing.serialize());
+}
+// Create HTTP module
+function createHttpModule(_protocol) {
+    return {
+        request(options, callback) {
+            let opts;
+            if (typeof options === "string") {
+                const url = new URL(options);
+                opts = {
+                    protocol: url.protocol,
+                    hostname: url.hostname,
+                    port: url.port,
+                    path: url.pathname + url.search,
+                };
+            }
+            else if (options instanceof URL) {
+                opts = {
+                    protocol: options.protocol,
+                    hostname: options.hostname,
+                    port: options.port,
+                    path: options.pathname + options.search,
+                };
+            }
+            else {
+                opts = options;
+            }
+            return new ClientRequest(opts, callback);
+        },
+        get(options, callback) {
+            let opts;
+            if (typeof options === "string") {
+                const url = new URL(options);
+                opts = {
+                    protocol: url.protocol,
+                    hostname: url.hostname,
+                    port: url.port,
+                    path: url.pathname + url.search,
+                    method: "GET",
+                };
+            }
+            else if (options instanceof URL) {
+                opts = {
+                    protocol: options.protocol,
+                    hostname: options.hostname,
+                    port: options.port,
+                    path: options.pathname + options.search,
+                    method: "GET",
+                };
+            }
+            else {
+                opts = { ...options, method: "GET" };
+            }
+            const req = new ClientRequest(opts, callback);
+            req.end();
+            return req;
+        },
+        createServer(_optionsOrListener, maybeListener) {
+            const listener = typeof _optionsOrListener === "function"
+                ? _optionsOrListener
+                : maybeListener;
+            return new Server(listener);
+        },
+        Agent,
+        globalAgent: new Agent({ keepAlive: false }),
+        Server: Server,
+        ServerResponse: ServerResponseBridge,
+        IncomingMessage: IncomingMessage,
+        ClientRequest: ClientRequest,
+        METHODS: ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"],
+        STATUS_CODES: {
+            200: "OK",
+            201: "Created",
+            204: "No Content",
+            301: "Moved Permanently",
+            302: "Found",
+            304: "Not Modified",
+            400: "Bad Request",
+            401: "Unauthorized",
+            403: "Forbidden",
+            404: "Not Found",
+            500: "Internal Server Error",
+        },
+    };
+}
+export const http = createHttpModule("http");
+export const https = createHttpModule("https");
+export const http2 = {
+    Http2ServerRequest: class Http2ServerRequest {
+    },
+    Http2ServerResponse: class Http2ServerResponse {
+    },
+    createServer() {
+        throw new Error("http2.createServer is not supported in sandbox");
+    },
+    createSecureServer() {
+        throw new Error("http2.createSecureServer is not supported in sandbox");
+    },
+};
+// Export modules and make them available as globals for require()
+exposeCustomGlobal("_httpModule", http);
+exposeCustomGlobal("_httpsModule", https);
+exposeCustomGlobal("_http2Module", http2);
+exposeCustomGlobal("_dnsModule", dns);
+exposeCustomGlobal("_httpServerDispatch", dispatchServerRequest);
+// Make fetch API available globally
+globalThis.fetch = fetch;
+globalThis.Headers = Headers;
+globalThis.Request = Request;
+globalThis.Response = Response;
+if (typeof globalThis.Blob === "undefined") {
+    // Minimal Blob stub used by server frameworks for instanceof checks.
+    globalThis.Blob = class BlobStub {
+    };
+}
+export default {
+    fetch,
+    Headers,
+    Request,
+    Response,
+    dns,
+    http,
+    https,
+    http2,
+    IncomingMessage,
+    ClientRequest,
+};