react-native-nitro-net 0.2.0 → 0.3.1

package/lib/http.js

@@ -0,0 +1,1126 @@
+import { Writable, Readable } from 'readable-stream';
+import { EventEmitter } from 'eventemitter3';
+import { Driver } from './Driver';
+import { Socket, isVerbose } from './net';
+import { TLSSocket } from './tls';
+import { Buffer } from 'react-native-nitro-buffer';
+function debugLog(message) {
+    if (isVerbose()) {
+        const timestamp = new Date().toISOString().split('T')[1].split('Z')[0];
+        console.log(`[HTTP DEBUG ${timestamp}] ${message}`);
+    }
+}
+// ========== STATUS_CODES ==========
+export const STATUS_CODES = {
+    100: 'Continue',
+    101: 'Switching Protocols',
+    102: 'Processing',
+    200: 'OK',
+    201: 'Created',
+    202: 'Accepted',
+    203: 'Non-Authoritative Information',
+    204: 'No Content',
+    205: 'Reset Content',
+    206: 'Partial Content',
+    300: 'Multiple Choices',
+    301: 'Moved Permanently',
+    302: 'Found',
+    303: 'See Other',
+    304: 'Not Modified',
+    307: 'Temporary Redirect',
+    308: 'Permanent Redirect',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    402: 'Payment Required',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    406: 'Not Acceptable',
+    407: 'Proxy Authentication Required',
+    408: 'Request Timeout',
+    409: 'Conflict',
+    410: 'Gone',
+    411: 'Length Required',
+    412: 'Precondition Failed',
+    413: 'Payload Too Large',
+    414: 'URI Too Long',
+    415: 'Unsupported Media Type',
+    416: 'Range Not Satisfiable',
+    417: 'Expectation Failed',
+    418: "I'm a teapot",
+    421: 'Misdirected Request',
+    422: 'Unprocessable Entity',
+    423: 'Locked',
+    424: 'Failed Dependency',
+    425: 'Too Early',
+    426: 'Upgrade Required',
+    428: 'Precondition Required',
+    429: 'Too Many Requests',
+    431: 'Request Header Fields Too Large',
+    451: 'Unavailable For Legal Reasons',
+    500: 'Internal Server Error',
+    501: 'Not Implemented',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+    504: 'Gateway Timeout',
+    505: 'HTTP Version Not Supported',
+    506: 'Variant Also Negotiates',
+    507: 'Insufficient Storage',
+    508: 'Loop Detected',
+    510: 'Not Extended',
+    511: 'Network Authentication Required',
+};
+export const METHODS = [
+    'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD',
+    'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL',
+    'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH',
+    'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SOURCE', 'SUBSCRIBE',
+    'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE'
+];
+// ========== IncomingMessage ==========
+export class IncomingMessage extends Readable {
+    constructor(socket) {
+        // @ts-ignore
+        super({ autoDestroy: false });
+        this.httpVersion = '1.1';
+        this.httpVersionMajor = 1;
+        this.httpVersionMinor = 1;
+        this.headers = {};
+        this.rawHeaders = [];
+        this.aborted = false;
+        this.complete = false;
+        this.trailers = {};
+        this.socket = socket;
+    }
+    _read() {
+        this.socket.resume();
+    }
+    setTimeout(msecs, callback) {
+        this.socket.setTimeout(msecs, callback);
+        return this;
+    }
+    destroy(error) {
+        super.destroy(error);
+        this.socket.destroy();
+        return this;
+    }
+    setNoDelay(noDelay = true) {
+        this.socket.setNoDelay(noDelay);
+    }
+    setKeepAlive(enable = false, initialDelay = 0) {
+        this.socket.setKeepAlive(enable, initialDelay);
+    }
+}
+// ========== OutgoingMessage ==========
+export class OutgoingMessage extends Writable {
+    constructor() {
+        // @ts-ignore - disable autoDestroy to prevent socket from being destroyed when stream ends
+        super({ autoDestroy: false });
+        this.headersSent = false;
+        this._headers = {};
+        this._headerNames = {};
+        this.socket = null;
+        this.chunkedEncoding = false;
+        this._hasBody = true;
+        this._sendHeadersSent = false;
+        this.aborted = false;
+        this._trailers = null;
+        this.once('finish', () => {
+            this.emit('close');
+        });
+    }
+    destroy(error) {
+        super.destroy(error);
+        if (this.socket) {
+            this.socket.destroy();
+        }
+        return this;
+    }
+    setHeader(name, value) {
+        if (this.headersSent)
+            throw new Error('Cannot set headers after they are sent');
+        const key = name.toLowerCase();
+        this._headers[key] = value;
+        this._headerNames[key] = name;
+        return this;
+    }
+    getHeader(name) {
+        return this._headers[name.toLowerCase()];
+    }
+    removeHeader(name) {
+        if (this.headersSent)
+            throw new Error('Cannot remove headers after they are sent');
+        const key = name.toLowerCase();
+        delete this._headers[key];
+        delete this._headerNames[key];
+    }
+    hasHeader(name) {
+        return name.toLowerCase() in this._headers;
+    }
+    getHeaderNames() {
+        return Object.values(this._headerNames);
+    }
+    setTimeout(ms, callback) {
+        if (this.socket) {
+            this.socket.setTimeout(ms, () => {
+                this.emit('timeout');
+                if (callback)
+                    callback();
+            });
+        }
+        else {
+            this.once('socket', (s) => {
+                s.setTimeout(ms, () => {
+                    this.emit('timeout');
+                    if (callback)
+                        callback();
+                });
+            });
+        }
+        return this;
+    }
+    _renderHeaders(firstLine) {
+        let headerStr = firstLine + '\r\n';
+        for (const key in this._headers) {
+            const name = this._headerNames[key];
+            const value = this._headers[key];
+            if (Array.isArray(value)) {
+                for (const v of value) {
+                    headerStr += `${name}: ${v}\r\n`;
+                }
+            }
+            else {
+                headerStr += `${name}: ${value}\r\n`;
+            }
+        }
+        headerStr += '\r\n';
+        return headerStr;
+    }
+    _sendHeaders(firstLine) {
+        if (this.headersSent)
+            return;
+        // Check for Chunked Encoding
+        if (!this.hasHeader('Content-Length') && this._hasBody) {
+            this.setHeader('Transfer-Encoding', 'chunked');
+            this.chunkedEncoding = true;
+        }
+        this.headersSent = true;
+        const headerStr = this._renderHeaders(firstLine);
+        debugLog(`OutgoingMessage._sendHeaders: writing ${headerStr.length} bytes to socket (socket=${!!this.socket})`);
+        this.socket.write(Buffer.from(headerStr));
+    }
+    _write(chunk, encoding, callback) {
+        if (!this.socket) {
+            callback(new Error('Socket not assigned'));
+            return;
+        }
+        if (this.chunkedEncoding) {
+            const len = typeof chunk === 'string' ? Buffer.byteLength(chunk, encoding) : chunk.length;
+            const header = len.toString(16) + '\r\n';
+            this.socket.write(Buffer.from(header));
+            // Note: We don't return the backpressure status here because we are doing multiple writes
+            // The final write determines the callback.
+            this.socket.write(chunk, encoding, (err) => {
+                if (err)
+                    return callback(err);
+                this.socket.write(Buffer.from('\r\n'), undefined, callback);
+            });
+        }
+        else {
+            this.socket.write(chunk, encoding, callback);
+        }
+    }
+    write(chunk, encoding, callback) {
+        const ret = super.write(chunk, encoding, callback);
+        // If writableLength is too high, return false
+        // But since we are proxying to socket, we should also check socket backpressure
+        if (this.socket && this.socket._writableState) {
+            // This is a bit hacky but if we have a real Node-like socket, we respect its state
+            return ret && !this.socket._writableState.needDrain;
+        }
+        return ret;
+    }
+    // _final is called by the stream when all writes are complete before 'finish' event
+    _final(callback) {
+        if (this.chunkedEncoding && this.socket) {
+            let terminator = '0\r\n';
+            if (this._trailers) {
+                for (const [key, value] of Object.entries(this._trailers)) {
+                    terminator += `${key}: ${value}\r\n`;
+                }
+            }
+            terminator += '\r\n';
+            this.socket.write(Buffer.from(terminator), undefined, (err) => {
+                callback(err);
+            });
+        }
+        else {
+            callback();
+        }
+    }
+    addTrailers(headers) {
+        if (this.headersSent && !this.chunkedEncoding) {
+            throw new Error('Trailers can only be used with chunked encoding');
+        }
+        this._trailers = headers;
+    }
+    end(chunk, encoding, callback) {
+        debugLog(`OutgoingMessage.end() called, already ending: ${this._writableState?.ending}, chunk: ${!!chunk}`);
+        if (chunk) {
+            this.write(chunk, encoding);
+        }
+        super.end(undefined, undefined, callback);
+        return this;
+    }
+    setNoDelay(noDelay = true) {
+        this.socket?.setNoDelay(noDelay);
+    }
+    setSocketKeepAlive(enable = false, initialDelay = 0) {
+        this.socket?.setKeepAlive(enable, initialDelay);
+    }
+}
+// ========== ServerResponse ==========
+export class ServerResponse extends OutgoingMessage {
+    constructor(socket) {
+        super();
+        this.statusCode = 200;
+        this.socket = socket;
+    }
+    writeHead(statusCode, statusMessage, headers) {
+        if (this.headersSent)
+            throw new Error('Cannot write headers after they are sent');
+        this.statusCode = statusCode;
+        if (typeof statusMessage === 'object') {
+            headers = statusMessage;
+            statusMessage = undefined;
+        }
+        if (statusMessage)
+            this.statusMessage = statusMessage;
+        if (headers) {
+            for (const key in headers) {
+                this.setHeader(key, headers[key]);
+            }
+        }
+        // Note: Do NOT send headers here. They will be sent on first write/end
+        // when Content-Length can be determined.
+        return this;
+    }
+    _sendResponseHeaders() {
+        if (this.headersSent)
+            return;
+        const firstLine = `HTTP/1.1 ${this.statusCode} ${this.statusMessage || STATUS_CODES[this.statusCode] || 'OK'}`;
+        this._sendHeaders(firstLine);
+    }
+    _write(chunk, encoding, callback) {
+        if (!this.headersSent)
+            this._sendResponseHeaders();
+        super._write(chunk, encoding, callback);
+    }
+    write(chunk, encoding, callback) {
+        return super.write(chunk, encoding, callback);
+    }
+    end(chunk, encoding, callback) {
+        if (!this.headersSent) {
+            // If we have a single chunk and no headers sent yet, we can add Content-Length
+            // to avoid chunked encoding for simple responses.
+            if (chunk) {
+                const len = typeof chunk === 'string' ? Buffer.byteLength(chunk, encoding) : chunk.length;
+                this.setHeader('Content-Length', len);
+            }
+            else {
+                this.setHeader('Content-Length', 0);
+            }
+            this._sendResponseHeaders();
+        }
+        // super.end will trigger _write if chunk was provided.
+        super.end(chunk, encoding, () => {
+            if (callback)
+                callback();
+        });
+        return this;
+    }
+}
+export class Server extends EventEmitter {
+    constructor(options, requestListener) {
+        super();
+        this._httpConnections = new Set();
+        this.maxHeaderSize = 16384;
+        this.maxRequestsPerSocket = 0;
+        this.headersTimeout = 60000;
+        this.requestTimeout = 300000;
+        this.keepAliveTimeout = 5000;
+        // Use net.Server from index.ts
+        const { Server: NetServer } = require('./net');
+        this._netServer = new NetServer();
+        let listener;
+        if (typeof options === 'function') {
+            listener = options;
+        }
+        else if (options) {
+            if (options.keepAliveTimeout !== undefined)
+                this.keepAliveTimeout = options.keepAliveTimeout;
+            if (options.requestTimeout !== undefined)
+                this.requestTimeout = options.requestTimeout;
+            if (options.headersTimeout !== undefined)
+                this.headersTimeout = options.headersTimeout;
+            if (options.maxHeaderSize !== undefined)
+                this.maxHeaderSize = options.maxHeaderSize;
+            if (options.maxRequestsPerSocket !== undefined)
+                this.maxRequestsPerSocket = options.maxRequestsPerSocket;
+            listener = requestListener;
+        }
+        if (listener) {
+            this.on('request', listener);
+        }
+        // Forward net.Server events
+        this._netServer.on('listening', () => this.emit('listening'));
+        this._netServer.on('close', () => this.emit('close'));
+        this._netServer.on('error', (err) => this.emit('error', err));
+        this._netServer.on('connection', (socket) => {
+            this._setupHttpConnection(socket);
+        });
+    }
+    _setupHttpConnection(socket) {
+        this._httpConnections.add(socket);
+        let req = null;
+        let res = null;
+        const parser = Driver.createHttpParser(0); // 0 = Request mode
+        // @ts-ignore
+        let bodyBytesRead = 0;
+        // @ts-ignore
+        let contentLength = -1;
+        // headersTimeout logic
+        let headersTimer = null;
+        if (this.headersTimeout > 0) {
+            headersTimer = setTimeout(() => {
+                debugLog(`Server: headersTimeout reached for socket, destroying`);
+                socket.destroy();
+            }, this.headersTimeout);
+        }
+        const onData = (data) => {
+            const handleParsedResult = (result) => {
+                if (result.startsWith('ERROR:')) {
+                    if (headersTimer)
+                        clearTimeout(headersTimer);
+                    this.emit('error', new Error(result));
+                    socket.destroy();
+                    return;
+                }
+                const parsed = JSON.parse(result);
+                if (parsed.is_headers) {
+                    if (headersTimer) {
+                        clearTimeout(headersTimer);
+                        headersTimer = null;
+                    }
+                    // Handle CONNECT method (HTTP Tunneling)
+                    if (parsed.is_connect) {
+                        const req = new IncomingMessage(socket);
+                        req.method = parsed.method;
+                        req.url = parsed.path;
+                        req.httpVersion = '1.' + parsed.version;
+                        req.headers = parsed.headers;
+                        // Remove our data listener to stop feeding the parser
+                        // The user is responsible for handling the socket data stream from now on
+                        socket.removeListener('data', onData);
+                        debugLog(`Server: CONNECT request received, emitting 'connect' event`);
+                        // TODO: retrieve any remaining body from parser as 'head'
+                        const head = Buffer.alloc(0);
+                        if (this.listenerCount('connect') > 0) {
+                            this.emit('connect', req, socket, head);
+                        }
+                        else {
+                            // Default behavior: close connection if no listener
+                            socket.destroy();
+                        }
+                        return;
+                    }
+                    const currentReq = new IncomingMessage(socket);
+                    currentReq.method = parsed.method;
+                    currentReq.url = parsed.path;
+                    currentReq.httpVersion = '1.' + parsed.version;
+                    currentReq.headers = parsed.headers;
+                    req = currentReq;
+                    const currentRes = new ServerResponse(socket);
+                    res = currentRes;
+                    // Support Keep-Alive: reset state once response is done
+                    currentRes.on('finish', () => {
+                        req = null;
+                        res = null;
+                        // The parser should already be reset in Rust
+                    });
+                    const upgrade = req.headers['upgrade'];
+                    if (upgrade && this.listenerCount('upgrade') > 0) {
+                        debugLog(`Server: Upgrade request received, emitting 'upgrade' event`);
+                        this.emit('upgrade', req, socket, Buffer.alloc(0));
+                        return;
+                    }
+                    const expect = req.headers['expect'];
+                    if (expect && (typeof expect === 'string' && expect.toLowerCase() === '100-continue')) {
+                        if (this.listenerCount('checkContinue') > 0) {
+                            this.emit('checkContinue', req, res);
+                        }
+                        else {
+                            socket.write(Buffer.from('HTTP/1.1 100 Continue\r\n\r\n'));
+                            this.emit('request', req, res);
+                        }
+                    }
+                    else {
+                        debugLog(`Server: Emitting 'request' for ${req.method} ${req.url}`);
+                        this.emit('request', req, res);
+                    }
+                }
+                if (req && parsed.body && parsed.body.length > 0) {
+                    req.push(Buffer.from(parsed.body));
+                }
+                if (req && parsed.complete) {
+                    req.complete = true;
+                    if (parsed.trailers) {
+                        req.trailers = parsed.trailers;
+                    }
+                    req.push(null);
+                }
+                // For Keep-Alive, try to parse remaining buffer in case of pipelining
+                if (parsed.complete && !req) {
+                    // This case is handled by the feed loop if multiple messages in data
+                }
+            };
+            let input = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            let iterations = 0;
+            const maxIterations = 100; // Safety limit
+            while (iterations < maxIterations) {
+                iterations++;
+                const result = parser.feed(input);
+                if (!result || result === '' || result.startsWith('ERROR:')) {
+                    // Empty result (partial) or error - exit loop
+                    if (result && result.startsWith('ERROR:')) {
+                        console.log(`[HTTP] Server: Parser error: ${result}`);
+                    }
+                    break;
+                }
+                handleParsedResult(result);
+                input = new ArrayBuffer(0); // Continue with empty input to drain Rust buffer
+            }
+        };
+        socket.on('data', onData);
+        // CRITICAL: Ensure server-side socket starts flowing!
+        socket.resume();
+        socket.on('close', () => {
+            if (headersTimer)
+                clearTimeout(headersTimer);
+            this._httpConnections.delete(socket);
+            if (req && !req.readableEnded) {
+                req.push(null);
+            }
+        });
+        socket.on('error', (err) => {
+            if (req)
+                req.emit('error', err);
+            else
+                this.emit('error', err);
+        });
+    }
+    listen(...args) {
+        this._netServer.listen(...args);
+        return this;
+    }
+    close(callback) {
+        this._netServer.close(callback);
+        return this;
+    }
+    // @ts-ignore
+    async [Symbol.asyncDispose]() {
+        return new Promise((resolve) => {
+            this.close(() => resolve());
+        });
+    }
+    address() {
+        return this._netServer.address();
+    }
+    get listening() {
+        return this._netServer.listening;
+    }
+    setTimeout(ms, callback) {
+        this._netServer.setTimeout(ms, callback);
+        return this;
+    }
+}
+export class Agent extends EventEmitter {
+    /**
+     * Gets the proxy URL for the given request options.
+     * Checks HTTP_PROXY, HTTPS_PROXY, and NO_PROXY environment variables.
+     *
+     * @param options Request options to determine if proxy should be used
+     * @returns Proxy URL or null if no proxy should be used
+     */
+    getProxy(options) {
+        // If explicitly set on agent, use that
+        if (this.proxy)
+            return this.proxy;
+        // Check environment variables (React Native may not have process.env)
+        const env = typeof process !== 'undefined' && process.env ? process.env : {};
+        const isHttps = options.protocol === 'https:';
+        const host = options.hostname || options.host || 'localhost';
+        // Check NO_PROXY first
+        const noProxy = env.NO_PROXY || env.no_proxy;
+        if (noProxy) {
+            const noProxyList = noProxy.split(',').map(s => s.trim().toLowerCase());
+            const hostLower = host.toLowerCase();
+            for (const pattern of noProxyList) {
+                if (pattern === '*')
+                    return null;
+                if (pattern.startsWith('.') && hostLower.endsWith(pattern))
+                    return null;
+                if (hostLower === pattern)
+                    return null;
+                if (hostLower.endsWith('.' + pattern))
+                    return null;
+            }
+        }
+        // Get proxy URL based on protocol
+        const proxyUrl = isHttps
+            ? (env.HTTPS_PROXY || env.https_proxy || env.HTTP_PROXY || env.http_proxy)
+            : (env.HTTP_PROXY || env.http_proxy);
+        return proxyUrl || null;
+    }
+    constructor(options) {
+        super();
+        this.maxSockets = Infinity;
+        this.maxTotalSockets = Infinity;
+        this.maxFreeSockets = 256;
+        this.keepAlive = false;
+        this.keepAliveMsecs = 1000;
+        this.maxCachedSessions = 100;
+        this.scheduling = 'lifo';
+        this.requests = {};
+        this.sockets = {};
+        this.freeSockets = {};
+        this._totalSockets = 0;
+        this.proxy = null;
+        if (options?.maxSockets)
+            this.maxSockets = options.maxSockets;
+        if (options?.maxTotalSockets)
+            this.maxTotalSockets = options.maxTotalSockets;
+        if (options?.maxFreeSockets)
+            this.maxFreeSockets = options.maxFreeSockets;
+        if (options?.keepAlive)
+            this.keepAlive = options.keepAlive;
+        if (options?.keepAliveMsecs)
+            this.keepAliveMsecs = options.keepAliveMsecs;
+        if (options?.scheduling)
+            this.scheduling = options.scheduling;
+        if (options?.maxCachedSessions !== undefined)
+            this.maxCachedSessions = options.maxCachedSessions;
+    }
+    getName(options) {
+        let name = `${options.host || options.hostname || 'localhost'}:${options.port || (options.protocol === 'https:' ? 443 : 80)}:`;
+        if (options.localAddress)
+            name += `${options.localAddress}:`;
+        if (options.family)
+            name += `${options.family}:`;
+        return name;
+    }
+    addRequest(req, options) {
+        const name = this.getName(options);
+        debugLog(`Agent.addRequest: name=${name}, totalSockets=${this._totalSockets}`);
+        // 1. Check if there's an idle socket in freeSockets
+        if (this.freeSockets[name] && this.freeSockets[name].length > 0) {
+            const socket = this.scheduling === 'lifo'
+                ? this.freeSockets[name].pop()
+                : this.freeSockets[name].shift();
+            if (this.freeSockets[name].length === 0)
+                delete this.freeSockets[name];
+            // Re-use socket
+            if (!this.sockets[name])
+                this.sockets[name] = [];
+            this.sockets[name].push(socket);
+            req.onSocket(socket);
+            return;
+        }
+        // 2. Check if we can create a new connection
+        const currentSockets = (this.sockets[name]?.length || 0);
+        if (currentSockets < this.maxSockets && this._totalSockets < this.maxTotalSockets) {
+            if (!this.sockets[name])
+                this.sockets[name] = [];
+            // Increment total sockets early
+            this._totalSockets++;
+            // ClientRequest handles connection but we signal it to proceed
+            req.onSocket(null);
+            return;
+        }
+        // 3. Queue the request
+        if (!this.requests[name])
+            this.requests[name] = [];
+        this.requests[name].push(req);
+    }
+    createConnection(options, callback) {
+        const name = this.getName(options);
+        const isHttps = options.protocol === 'https:';
+        const port = options.port || (isHttps ? 443 : 80);
+        const host = options.hostname || options.host || 'localhost';
+        debugLog(`Agent.createConnection: name=${name}, isHttps=${isHttps}, host=${host}, port=${port}`);
+        // Build clean connection options - DO NOT pass HTTP path as it will be confused with Unix socket path
+        const connectOptions = {
+            host: host,
+            port: port,
+        };
+        if (isHttps) {
+            connectOptions.servername = options.servername || host;
+            connectOptions.rejectUnauthorized = options.rejectUnauthorized !== false;
+            if (options.ca)
+                connectOptions.ca = options.ca;
+            if (options.cert)
+                connectOptions.cert = options.cert;
+            if (options.key)
+                connectOptions.key = options.key;
+        }
+        const socket = isHttps ? new TLSSocket(connectOptions) : new Socket();
+        // Re-emit keylog events from TLSSockets
+        if (isHttps) {
+            socket.on('keylog', (line) => {
+                // @ts-ignore - Agent is an EventEmitter via Node-like inheritance or internal use
+                this.emit('keylog', line, socket);
+            });
+        }
+        let called = false;
+        const onConnected = () => {
+            if (called)
+                return;
+            called = true;
+            debugLog(`Agent.createConnection: socket ${isHttps ? 'SECURE_CONNECTED' : 'CONNECTED'} for ${name}`);
+            callback(null, socket);
+        };
+        if (isHttps) {
+            socket.on('secureConnect', onConnected);
+        }
+        else {
+            socket.on('connect', onConnected);
+        }
+        socket.on('error', (err) => {
+            if (called)
+                return;
+            called = true;
+            debugLog(`Agent.createConnection: socket ERROR for ${name}: ${err.message}`);
+            this._totalSockets--;
+            if (this.sockets[name]) {
+                const idx = this.sockets[name].indexOf(socket);
+                if (idx !== -1)
+                    this.sockets[name].splice(idx, 1);
+            }
+            callback(err, null);
+        });
+        socket.connect(connectOptions);
+        if (!this.sockets[name])
+            this.sockets[name] = [];
+        this.sockets[name].push(socket);
+        return socket;
+    }
+    releaseSocket(socket, options) {
+        const name = this.getName(options);
+        // Remove from active sockets
+        if (this.sockets[name]) {
+            const idx = this.sockets[name].indexOf(socket);
+            if (idx !== -1)
+                this.sockets[name].splice(idx, 1);
+            if (this.sockets[name].length === 0)
+                delete this.sockets[name];
+        }
+        const onClose = () => {
+            debugLog(`Agent: socket closed while in pool, removing from ${name}`);
+            this._removeSocket(socket, name);
+        };
+        socket.once('close', onClose);
+        socket.once('error', onClose);
+        socket._agentOnClose = onClose;
+        // Check if there are pending requests - ALWAYS reuse if something is waiting
+        if (this.requests[name] && this.requests[name].length > 0) {
+            const req = this.requests[name].shift();
+            if (this.requests[name].length === 0)
+                delete this.requests[name];
+            if (!this.sockets[name])
+                this.sockets[name] = [];
+            this.sockets[name].push(socket);
+            this.reuseSocket(socket, req);
+            return;
+        }
+        if (this.keepAlive && this.keepSocketAlive(socket)) {
+            // Return to free pool
+            if (!this.freeSockets[name])
+                this.freeSockets[name] = [];
+            if (this.freeSockets[name].length < this.maxFreeSockets) {
+                this.freeSockets[name].push(socket);
+            }
+            else {
+                this._totalSockets--;
+                socket.end();
+            }
+        }
+        else {
+            this._totalSockets--;
+            socket.end();
+        }
+    }
+    keepSocketAlive(_socket) {
+        return true;
+    }
+    reuseSocket(socket, req) {
+        debugLog(`Agent.reuseSocket: reusing socket for ${req.method} ${req.path}`);
+        // Remove agent listeners before reusing
+        if (socket._agentOnClose) {
+            socket.removeListener('close', socket._agentOnClose);
+            socket.removeListener('error', socket._agentOnClose);
+            delete socket._agentOnClose;
+        }
+        req.onSocket(socket);
+    }
+    _removeSocket(socket, name) {
+        if (this.sockets[name]) {
+            const idx = this.sockets[name].indexOf(socket);
+            if (idx !== -1) {
+                this.sockets[name].splice(idx, 1);
+                this._totalSockets--;
+            }
+        }
+        if (this.freeSockets[name]) {
+            const idx = this.freeSockets[name].indexOf(socket);
+            if (idx !== -1) {
+                this.freeSockets[name].splice(idx, 1);
+                this._totalSockets--;
+            }
+        }
+    }
+    destroy() {
+        for (const name in this.sockets) {
+            for (const socket of this.sockets[name]) {
+                socket.destroy();
+            }
+        }
+        for (const name in this.freeSockets) {
+            for (const socket of this.freeSockets[name]) {
+                socket.destroy();
+            }
+        }
+    }
+}
+export const globalAgent = new Agent();
+export class ClientRequest extends OutgoingMessage {
+    constructor(options, callback) {
+        super();
+        this._connected = false;
+        this._pendingWrites = [];
+        this._ended = false;
+        this._expectContinue = false;
+        this._continueReceived = false;
+        this._options = options;
+        this.method = options.method || 'GET';
+        this.path = options.path || '/';
+        this.host = options.hostname || options.host || 'localhost';
+        if (['GET', 'HEAD'].includes(this.method.toUpperCase())) {
+            this._hasBody = false;
+        }
+        if (options.headers) {
+            for (const key in options.headers) {
+                this.setHeader(key, options.headers[key]);
+            }
+        }
+        if (callback) {
+            this.once('response', callback);
+        }
+        const expect = this.getHeader('expect');
+        if (expect && typeof expect === 'string' && expect.toLowerCase() === '100-continue') {
+            this._expectContinue = true;
+        }
+        if (options.timeout) {
+            this.setTimeout(options.timeout);
+        }
+        const agent = options.agent === false ? new Agent() : (options.agent instanceof Agent ? options.agent : globalAgent);
+        // Use setImmediate or setTimeout for React Native compatibility
+        const nextTick = typeof setImmediate !== 'undefined' ? setImmediate : (fn) => setTimeout(fn, 0);
+        nextTick(() => {
+            debugLog(`ClientRequest: nextTick fired for ${this.method} ${this.host}${this.path}`);
+            agent.addRequest(this, this._options);
+        });
+    }
+    /** @internal */
+    onSocket(socket) {
+        if (socket) {
+            this.socket = socket;
+            this._connected = true;
+            this.emit('socket', this.socket);
+            this._sendRequest();
+            this._flushPendingWrites();
+            this._attachSocketListeners();
+        }
+        else {
+            this._connect();
+        }
+    }
+    _connect() {
+        const agent = this._options.agent === false ? new Agent() : (this._options.agent instanceof Agent ? this._options.agent : globalAgent);
+        const connectCallback = (err, socket) => {
+            if (err) {
+                debugLog(`ClientRequest._connect: ERROR: ${err.message}`);
+                this.emit('error', err);
+                return;
+            }
+            debugLog(`ClientRequest._connect: Socket connected! socket=${!!socket}, socket._driver=${!!socket._driver}`);
+            console.log(`[HTTP] _connect: Socket connected!`);
+            this.socket = socket;
+            this._connected = true;
+            this.emit('socket', this.socket);
+            debugLog(`ClientRequest._connect: Calling _sendRequest`);
+            this._sendRequest();
+            this._flushPendingWrites();
+            this._attachSocketListeners();
+        };
+        this.socket = agent.createConnection(this._options, connectCallback);
+    }
+    _attachSocketListeners() {
+        if (!this.socket)
+            return;
+        const parser = Driver.createHttpParser(1); // 1 = Response mode
+        const onData = (data) => {
+            const handleParsedResult = (result) => {
+                if (result.startsWith('ERROR:')) {
+                    this.emit('error', new Error(result));
+                    this.socket.destroy();
+                    return;
+                }
+                const parsed = JSON.parse(result);
+                console.log(`[HTTP] _connect: Parser result: ${parsed.is_headers ? 'HEADERS' : 'DATA'}${parsed.complete ? ' (COMPLETE)' : ''}`);
+                if (parsed.is_headers) {
+                    const status = parsed.status || 0;
+                    if (status >= 100 && status < 200 && status !== 101) {
+                        const info = {
+                            httpVersion: '1.' + parsed.version,
+                            httpVersionMajor: 1,
+                            httpVersionMinor: parsed.version,
+                            statusCode: status,
+                            statusMessage: STATUS_CODES[status] || '',
+                            headers: parsed.headers,
+                            rawHeaders: []
+                        };
+                        if (status === 100) {
+                            this._continueReceived = true;
+                            this.emit('continue');
+                            this._flushPendingWrites();
+                        }
+                        else {
+                            this.emit('information', info);
+                        }
+                        return;
+                    }
+                    this._res = new IncomingMessage(this.socket);
+                    this._res.statusCode = status;
+                    this._res.httpVersion = '1.' + parsed.version;
+                    this._res.headers = parsed.headers;
+                    if (status === 101) {
+                        debugLog(`ClientRequest: 101 Switching Protocols received, detaching parser`);
+                        this.socket.removeListener('data', onData);
+                        this.socket.removeListener('error', onError);
+                        this.emit('upgrade', this._res, this.socket, Buffer.alloc(0));
+                        return;
+                    }
+                    // Handle CONNECT method response (HTTP Tunneling)
+                    if (this.method.toUpperCase() === 'CONNECT' && status >= 200 && status < 300) {
+                        debugLog(`ClientRequest: CONNECT tunnel established (status=${status}), emitting 'connect' event`);
+                        this.socket.removeListener('data', onData);
+                        this.socket.removeListener('error', onError);
+                        this.emit('connect', this._res, this.socket, Buffer.alloc(0));
+                        return;
+                    }
+                    this.emit('response', this._res);
+                }
+                if (this._res && parsed.body && parsed.body.length > 0) {
+                    this._res.push(Buffer.from(parsed.body));
+                }
+                if (this._res && parsed.complete) {
+                    this._res.complete = true;
+                    if (parsed.trailers) {
+                        this._res.trailers = parsed.trailers;
+                    }
+                    this._res.push(null);
+                    this._finishResponse();
+                }
+            };
+            let input = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            let iterations = 0;
+            const maxIterations = 100; // Safety limit
+            while (iterations < maxIterations) {
+                iterations++;
+                const result = parser.feed(input);
+                if (!result || result === '' || result.startsWith('ERROR:')) {
+                    // Empty result (partial) or error - exit loop
+                    if (result && result.startsWith('ERROR:')) {
+                        console.log(`[HTTP] ClientRequest: Parser error: ${result}`);
+                    }
+                    break;
+                }
+                handleParsedResult(result);
+                input = new ArrayBuffer(0); // Continue with empty input to drain Rust buffer
+            }
+        };
+        const onError = (err) => {
+            console.log(`[HTTP] _connect: Socket error: ${err.message}`);
+            this.emit('error', err);
+            this._cleanupSocket();
+        };
+        const onClose = () => {
+            console.log(`[HTTP] _connect: Socket closed`);
+            if (this._res && !this._res.readableEnded)
+                this._res.push(null);
+            this.emit('close');
+            this._cleanupSocket();
+        };
+        this.socket.on('data', onData);
+        this.socket.on('error', onError);
+        this.socket.on('close', onClose);
+        this._socketCleanup = () => {
+            this.socket?.removeListener('data', onData);
+            this.socket?.removeListener('error', onError);
+            this.socket?.removeListener('close', onClose);
+        };
+    }
+    _cleanupSocket() {
+        if (this._socketCleanup)
+            this._socketCleanup();
+        this._socketCleanup = undefined;
+        this.socket = null;
+        this._connected = false;
+    }
+    _finishResponse() {
+        // Release socket back to agent
+        const agent = this._options.agent === false ? new Agent() : (this._options.agent instanceof Agent ? this._options.agent : globalAgent);
+        const socket = this.socket;
+        this._cleanupSocket();
+        if (socket)
+            agent.releaseSocket(socket, this._options);
+    }
+    _flushPendingWrites() {
+        if (!this.socket)
+            return;
+        if (!this.headersSent)
+            this._sendRequest();
+        // If we are waiting for 100-continue, don't flush yet
+        if (this._expectContinue && !this._continueReceived) {
+            return;
+        }
+        const writes = this._pendingWrites;
+        this._pendingWrites = [];
+        for (const pending of writes) {
+            this._write(pending.chunk, pending.encoding, pending.callback);
+        }
+        if (this._ended) {
+            this._finishRequest();
+        }
+    }
+    _finishRequest() {
+        if (!this._ended)
+            return;
+        super.end();
+    }
+    _sendRequest() {
+        debugLog(`ClientRequest._sendRequest: headersSent=${this.headersSent}, socket=${!!this.socket}`);
+        if (this.headersSent)
+            return;
+        if (!this.hasHeader('host')) {
+            this.setHeader('Host', this.host);
+        }
+        const firstLine = `${this.method} ${this.path} HTTP/1.1`;
+        debugLog(`ClientRequest._sendRequest: sending firstLine=${firstLine}`);
+        this._sendHeaders(firstLine);
+    }
+    _write(chunk, encoding, callback) {
+        if (!this._connected) {
+            this._pendingWrites.push({ chunk, encoding, callback });
+            return;
+        }
+        if (!this.headersSent)
+            this._sendRequest();
+        super._write(chunk, encoding, callback);
+    }
+    write(chunk, encoding, callback) {
+        if (!this._connected) {
+            this._pendingWrites.push({ chunk, encoding, callback });
+            return true;
+        }
+        if (!this.headersSent)
+            this._sendRequest();
+        return super.write(chunk, encoding, callback);
+    }
+    end(chunk, encoding, callback) {
+        debugLog(`ClientRequest.end() called, connected=${this._connected}, headersSent=${this.headersSent}`);
+        if (chunk) {
+            this.write(chunk, encoding);
+        }
+        this._ended = true;
+        // If connected, we can send request and end immediately
+        if (this._connected) {
+            if (!this.headersSent) {
+                this._sendRequest();
+            }
+            // Call super.end only when connected
+            super.end(undefined, undefined, callback);
+        }
+        else {
+            // Socket not connected yet - _flushPendingWrites will handle ending
+            // Store callback if provided
+            if (callback) {
+                this.once('finish', callback);
+            }
+        }
+        return this;
+    }
+    abort() {
+        if (this.aborted)
+            return;
+        this.aborted = true;
+        this.emit('abort');
+        this.destroy();
+    }
+    flushHeaders() {
+        if (this._connected && !this.headersSent) {
+            this._sendRequest();
+        }
+    }
+}
+export function createServer(optionsOrListener, requestListener) {
+    return new Server(optionsOrListener, requestListener);
+}
+export function request(urlOrOptions, optionsOrCallback, callback) {
+    let opts = {};
+    let cb = callback;
+    if (typeof urlOrOptions === 'string') {
+        const url = new URL(urlOrOptions);
+        opts = {
+            protocol: url.protocol,
+            hostname: url.hostname,
+            path: url.pathname + url.search,
+            port: url.port ? parseInt(url.port) : undefined
+        };
+    }
+    else if (urlOrOptions instanceof URL) {
+        opts = {
+            protocol: urlOrOptions.protocol,
+            hostname: urlOrOptions.hostname,
+            path: urlOrOptions.pathname + urlOrOptions.search,
+            port: urlOrOptions.port ? parseInt(urlOrOptions.port) : undefined
+        };
+    }
+    else {
+        opts = urlOrOptions;
+    }
+    // Handle (url, options, callback) or (url, callback) signatures
+    if (typeof optionsOrCallback === 'function') {
+        cb = optionsOrCallback;
+    }
+    else if (optionsOrCallback) {
+        // Merge options
+        opts = { ...opts, ...optionsOrCallback };
+    }
+    return new ClientRequest(opts, cb);
+}
+export function get(urlOrOptions, optionsOrCallback, callback) {
+    const req = request(urlOrOptions, optionsOrCallback, callback);
+    req.end();
+    return req;
+}