@voratiq/sandbox-runtime 0.7.0-voratiq1

package/dist/sandbox/generate-seccomp-filter.js

@@ -0,0 +1,158 @@
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as fs from 'node:fs';
+import { logForDebugging } from '../utils/debug.js';
+/**
+ * Map Node.js process.arch to our vendor directory architecture names
+ * Returns null for unsupported architectures
+ */
+function getVendorArchitecture() {
+    const arch = process.arch;
+    switch (arch) {
+        case 'x64':
+        case 'x86_64':
+            return 'x64';
+        case 'arm64':
+        case 'aarch64':
+            return 'arm64';
+        case 'ia32':
+        case 'x86':
+            // TODO: Add support for 32-bit x86 (ia32)
+            // Currently blocked because the seccomp filter does not block the socketcall() syscall,
+            // which is used on 32-bit x86 for all socket operations (socket, socketpair, bind, connect, etc.).
+            // On 32-bit x86, the direct socket() syscall doesn't exist - instead, all socket operations
+            // are multiplexed through socketcall(SYS_SOCKET, ...), socketcall(SYS_SOCKETPAIR, ...), etc.
+            //
+            // To properly support 32-bit x86, we need to:
+            // 1. Build a separate i386 BPF filter (BPF bytecode is architecture-specific)
+            // 2. Modify vendor/seccomp-src/seccomp-unix-block.c to conditionally add rules that block:
+            //    - socketcall(SYS_SOCKET, [AF_UNIX, ...])
+            //    - socketcall(SYS_SOCKETPAIR, [AF_UNIX, ...])
+            // 3. This requires complex BPF logic to inspect socketcall's sub-function argument
+            //
+            // Until then, 32-bit x86 is not supported to avoid a security bypass.
+            logForDebugging(`[SeccompFilter] 32-bit x86 (ia32) is not currently supported due to missing socketcall() syscall blocking. ` +
+                `The current seccomp filter only blocks socket(AF_UNIX, ...), but on 32-bit x86, socketcall() can be used to bypass this.`, { level: 'error' });
+            return null;
+        default:
+            logForDebugging(`[SeccompFilter] Unsupported architecture: ${arch}. Only x64 and arm64 are supported.`);
+            return null;
+    }
+}
+/**
+ * Get the path to a pre-generated BPF filter file from the vendor directory
+ * Returns the path if it exists, null otherwise
+ *
+ * Pre-generated BPF files are organized by architecture:
+ * - vendor/seccomp/{x64,arm64}/unix-block.bpf
+ *
+ * Tries multiple paths for resilience:
+ * 1. ../../vendor/seccomp/{arch}/unix-block.bpf (package root - standard npm installs)
+ * 2. ../vendor/seccomp/{arch}/unix-block.bpf (dist/vendor - for bundlers)
+ */
+export function getPreGeneratedBpfPath() {
+    // Determine architecture
+    const arch = getVendorArchitecture();
+    if (!arch) {
+        logForDebugging(`[SeccompFilter] Cannot find pre-generated BPF filter: unsupported architecture ${process.arch}`);
+        return null;
+    }
+    logForDebugging(`[SeccompFilter] Detected architecture: ${arch}`);
+    // Try to locate the BPF file with fallback paths
+    // Path is relative to the compiled code location (dist/sandbox/)
+    const baseDir = dirname(fileURLToPath(import.meta.url));
+    const relativePath = join('vendor', 'seccomp', arch, 'unix-block.bpf');
+    // Try paths in order of preference
+    const pathsToTry = [
+        join(baseDir, '..', '..', relativePath), // package root: vendor/seccomp/...
+        join(baseDir, '..', relativePath), // dist: dist/vendor/seccomp/...
+    ];
+    for (const bpfPath of pathsToTry) {
+        if (fs.existsSync(bpfPath)) {
+            logForDebugging(`[SeccompFilter] Found pre-generated BPF filter: ${bpfPath} (${arch})`);
+            return bpfPath;
+        }
+    }
+    logForDebugging(`[SeccompFilter] Pre-generated BPF filter not found in any expected location (${arch})`);
+    return null;
+}
+/**
+ * Get the path to the apply-seccomp binary from the vendor directory
+ * Returns the path if it exists, null otherwise
+ *
+ * Pre-built apply-seccomp binaries are organized by architecture:
+ * - vendor/seccomp/{x64,arm64}/apply-seccomp
+ *
+ * Tries multiple paths for resilience:
+ * 1. ../../vendor/seccomp/{arch}/apply-seccomp (package root - standard npm installs)
+ * 2. ../vendor/seccomp/{arch}/apply-seccomp (dist/vendor - for bundlers)
+ */
+export function getApplySeccompBinaryPath() {
+    // Determine architecture
+    const arch = getVendorArchitecture();
+    if (!arch) {
+        logForDebugging(`[SeccompFilter] Cannot find apply-seccomp binary: unsupported architecture ${process.arch}`);
+        return null;
+    }
+    logForDebugging(`[SeccompFilter] Looking for apply-seccomp binary for architecture: ${arch}`);
+    // Try to locate the binary with fallback paths
+    // Path is relative to the compiled code location (dist/sandbox/)
+    const baseDir = dirname(fileURLToPath(import.meta.url));
+    const relativePath = join('vendor', 'seccomp', arch, 'apply-seccomp');
+    // Try paths in order of preference
+    const pathsToTry = [
+        join(baseDir, '..', '..', relativePath), // package root: vendor/seccomp/...
+        join(baseDir, '..', relativePath), // dist: dist/vendor/seccomp/...
+    ];
+    for (const binaryPath of pathsToTry) {
+        if (fs.existsSync(binaryPath)) {
+            logForDebugging(`[SeccompFilter] Found apply-seccomp binary: ${binaryPath} (${arch})`);
+            return binaryPath;
+        }
+    }
+    logForDebugging(`[SeccompFilter] apply-seccomp binary not found in any expected location (${arch})`);
+    return null;
+}
+/**
+ * Get the path to a pre-generated seccomp BPF filter that blocks Unix domain socket creation
+ * Returns the path to the BPF filter file, or null if not available
+ *
+ * The filter blocks socket(AF_UNIX, ...) syscalls while allowing all other syscalls.
+ * This prevents creation of new Unix domain socket file descriptors.
+ *
+ * Security scope:
+ * - Blocks: socket(AF_UNIX, ...) syscall (creating new Unix socket FDs)
+ * - Does NOT block: Operations on inherited Unix socket FDs (bind, connect, sendto, etc.)
+ * - Does NOT block: Unix socket FDs passed via SCM_RIGHTS
+ * - For most sandboxing scenarios, blocking socket creation is sufficient
+ *
+ * Note: This blocks ALL Unix socket creation, regardless of path. The allowUnixSockets
+ * configuration is not supported on Linux due to seccomp-bpf limitations (it cannot
+ * read user-space memory to inspect socket paths).
+ *
+ * Requirements:
+ * - Pre-generated BPF filters included for x64 and ARM64 only
+ * - Other architectures are not supported
+ *
+ * @returns Path to the pre-generated BPF filter file, or null if not available
+ */
+export function generateSeccompFilter() {
+    const preGeneratedBpf = getPreGeneratedBpfPath();
+    if (preGeneratedBpf) {
+        logForDebugging('[SeccompFilter] Using pre-generated BPF filter');
+        return preGeneratedBpf;
+    }
+    logForDebugging('[SeccompFilter] Pre-generated BPF filter not available for this architecture. ' +
+        'Only x64 and arm64 are supported.', { level: 'error' });
+    return null;
+}
+/**
+ * Clean up a seccomp filter file
+ * Since we only use pre-generated BPF files from vendor/, this is a no-op.
+ * Pre-generated files are never deleted.
+ * Kept for backward compatibility with existing code that calls it.
+ */
+export function cleanupSeccompFilter(_filterPath) {
+    // No-op: pre-generated BPF files are never cleaned up
+}
+//# sourceMappingURL=generate-seccomp-filter.js.map

package/dist/sandbox/generate-seccomp-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-seccomp-filter.js","sourceRoot":"","sources":["../../src/sandbox/generate-seccomp-filter.ts"],"names":[],"mappings":"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"}

package/dist/sandbox/http-proxy.d.ts

@@ -0,0 +1,12 @@
+import type { Socket, Server } from 'node:net';
+import type { Duplex } from 'node:stream';
+import { type TelemetrySandboxVerdict } from '../utils/telemetry.js';
+export interface ProxyFilterDecision {
+    allowed: boolean;
+    verdict: TelemetrySandboxVerdict;
+}
+export interface HttpProxyServerOptions {
+    filter(port: number, host: string, socket: Socket | Duplex): Promise<ProxyFilterDecision> | ProxyFilterDecision;
+}
+export declare function createHttpProxyServer(options: HttpProxyServerOptions): Server;
+//# sourceMappingURL=http-proxy.d.ts.map

package/dist/sandbox/http-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-proxy.d.ts","sourceRoot":"","sources":["../../src/sandbox/http-proxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAUzC,OAAO,EAIL,KAAK,uBAAuB,EAC7B,MAAM,uBAAuB,CAAA;AAE9B,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,uBAAuB,CAAA;CACjC;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,CACJ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,MAAM,GACtB,OAAO,CAAC,mBAAmB,CAAC,GAAG,mBAAmB,CAAA;CACtD;AAsCD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CA+f7E"}

package/dist/sandbox/http-proxy.js

@@ -0,0 +1,489 @@
+import { createServer } from 'node:http';
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { connect } from 'node:net';
+import { URL } from 'node:url';
+import { performance } from 'node:perf_hooks';
+import { createHash } from 'node:crypto';
+import { logForDebugging } from '../utils/debug.js';
+import { emitTelemetryEvent, isTelemetryEnabled, sanitizeHeaders, } from '../utils/telemetry.js';
+const HTTP_FORBIDDEN_RESPONSE = 'HTTP/1.1 403 Forbidden\r\n' +
+    'Content-Type: text/plain\r\n' +
+    'X-Proxy-Error: blocked-by-allowlist\r\n' +
+    '\r\n' +
+    'Connection blocked by network allowlist';
+function inferEgressType(port, protocol) {
+    if (protocol === 'https:') {
+        return 'https';
+    }
+    if (protocol === 'http:') {
+        return 'http';
+    }
+    if (port === 443) {
+        return 'https';
+    }
+    if (port === 80) {
+        return 'http';
+    }
+    return 'tcp';
+}
+function getCompressionHeader(headers) {
+    const value = headers['content-encoding'];
+    if (!value) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value[0] ?? null;
+    }
+    return String(value);
+}
+export function createHttpProxyServer(options) {
+    const server = createServer();
+    server.on('connect', async (req, socket) => {
+        socket.on('error', err => {
+            logForDebugging(`Client socket error: ${err.message}`, { level: 'error' });
+        });
+        try {
+            const [hostname, portStr] = req.url.split(':');
+            const port = portStr === undefined ? undefined : parseInt(portStr, 10);
+            if (!hostname || !port || Number.isNaN(port)) {
+                logForDebugging(`Invalid CONNECT request: ${req.url}`, {
+                    level: 'error',
+                });
+                socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
+                return;
+            }
+            const telemetryActive = isTelemetryEnabled();
+            const egressType = inferEgressType(port, 'https:');
+            const startTime = telemetryActive ? performance.now() : 0;
+            if (telemetryActive) {
+                emitTelemetryEvent({
+                    stage: 'start',
+                    status: 'success',
+                    attempt: 0,
+                    sandbox_verdict: {
+                        decision: 'pending',
+                        reason: 'connect_request_received',
+                        policy_tag: 'network.allowlist',
+                    },
+                    network: {
+                        resolved_host: hostname,
+                        resolved_ip: null,
+                        tls_outcome: null,
+                        tls_error: null,
+                        dns_source: null,
+                    },
+                    egress_type: egressType,
+                });
+            }
+            let decision;
+            try {
+                decision = await options.filter(port, hostname, socket);
+            }
+            catch (error) {
+                logForDebugging(`Filter threw error: ${error}`, { level: 'error' });
+                decision = {
+                    allowed: false,
+                    verdict: {
+                        decision: 'deny',
+                        reason: 'filter_failure',
+                        policy_tag: 'network.allowlist',
+                    },
+                };
+            }
+            if (!decision.allowed) {
+                if (telemetryActive) {
+                    emitTelemetryEvent({
+                        stage: 'failure',
+                        status: 'failed',
+                        attempt: 0,
+                        status_code: 403,
+                        sandbox_verdict: decision.verdict,
+                        network: {
+                            resolved_host: hostname,
+                            resolved_ip: null,
+                            tls_outcome: null,
+                            tls_error: null,
+                            dns_source: null,
+                        },
+                        latency_ms: performance.now() - startTime,
+                        egress_type: egressType,
+                    });
+                }
+                socket.end(HTTP_FORBIDDEN_RESPONSE);
+                return;
+            }
+            if (telemetryActive) {
+                emitTelemetryEvent({
+                    stage: 'attempt',
+                    status: 'success',
+                    attempt: 0,
+                    sandbox_verdict: decision.verdict,
+                    network: {
+                        resolved_host: hostname,
+                        resolved_ip: null,
+                        tls_outcome: null,
+                        tls_error: null,
+                        dns_source: null,
+                    },
+                    latency_ms: null,
+                    queue_latency_ms: performance.now() - startTime,
+                    egress_type: egressType,
+                });
+            }
+            const attemptStart = telemetryActive ? performance.now() : 0;
+            let resolvedIp = null;
+            let completionEmitted = false;
+            let tlsError = null;
+            const serverSocket = connect(port, hostname, () => {
+                socket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+                serverSocket.pipe(socket);
+                socket.pipe(serverSocket);
+                if (telemetryActive && !completionEmitted) {
+                    completionEmitted = true;
+                    emitTelemetryEvent({
+                        stage: 'completion',
+                        status: 'success',
+                        attempt: 0,
+                        status_code: 200,
+                        sandbox_verdict: decision.verdict,
+                        network: {
+                            resolved_host: hostname,
+                            resolved_ip: resolvedIp ?? serverSocket.remoteAddress ?? null,
+                            tls_outcome: 'tunnel_established',
+                            tls_error: tlsError,
+                            dns_source: resolvedIp ? 'system' : null,
+                        },
+                        latency_ms: performance.now() - attemptStart,
+                        egress_type: egressType,
+                    });
+                }
+            });
+            serverSocket.once('lookup', (err, address) => {
+                if (err) {
+                    tlsError = err.message;
+                    return;
+                }
+                resolvedIp = address;
+            });
+            serverSocket.on('error', err => {
+                logForDebugging(`CONNECT tunnel failed: ${err.message}`, {
+                    level: 'error',
+                });
+                if (telemetryActive && !completionEmitted) {
+                    completionEmitted = true;
+                    emitTelemetryEvent({
+                        stage: 'failure',
+                        status: 'failed',
+                        attempt: 0,
+                        status_code: 502,
+                        sandbox_verdict: decision.verdict,
+                        network: {
+                            resolved_host: hostname,
+                            resolved_ip: resolvedIp,
+                            tls_outcome: 'tunnel_error',
+                            tls_error: err.message,
+                            dns_source: resolvedIp ? 'system' : null,
+                        },
+                        latency_ms: performance.now() - attemptStart,
+                        egress_type: egressType,
+                    });
+                }
+                socket.end('HTTP/1.1 502 Bad Gateway\r\n\r\n');
+            });
+            socket.on('error', err => {
+                logForDebugging(`Client socket error: ${err.message}`, {
+                    level: 'error',
+                });
+                serverSocket.destroy();
+                if (telemetryActive && !completionEmitted) {
+                    completionEmitted = true;
+                    emitTelemetryEvent({
+                        stage: 'failure',
+                        status: 'failed',
+                        attempt: 0,
+                        status_code: null,
+                        sandbox_verdict: decision.verdict,
+                        network: {
+                            resolved_host: hostname,
+                            resolved_ip: resolvedIp,
+                            tls_outcome: 'client_socket_error',
+                            tls_error: err.message,
+                            dns_source: resolvedIp ? 'system' : null,
+                        },
+                        latency_ms: performance.now() - attemptStart,
+                        egress_type: egressType,
+                    });
+                }
+            });
+            socket.on('end', () => serverSocket.end());
+            serverSocket.on('end', () => socket.end());
+        }
+        catch (err) {
+            logForDebugging(`Error handling CONNECT: ${err}`, { level: 'error' });
+            socket.end('HTTP/1.1 500 Internal Server Error\r\n\r\n');
+        }
+    });
+    server.on('request', async (req, res) => {
+        const telemetryActive = isTelemetryEnabled();
+        const startTime = telemetryActive ? performance.now() : 0;
+        try {
+            const url = new URL(req.url);
+            const hostname = url.hostname;
+            const port = url.port && url.port !== ''
+                ? parseInt(url.port, 10)
+                : url.protocol === 'https:'
+                    ? 443
+                    : 80;
+            const egressType = inferEgressType(port, url.protocol);
+            if (telemetryActive) {
+                emitTelemetryEvent({
+                    stage: 'start',
+                    status: 'success',
+                    attempt: 0,
+                    sandbox_verdict: {
+                        decision: 'pending',
+                        reason: 'http_request_received',
+                        policy_tag: 'network.allowlist',
+                    },
+                    network: {
+                        resolved_host: hostname,
+                        resolved_ip: null,
+                        tls_outcome: null,
+                        tls_error: null,
+                        dns_source: null,
+                    },
+                    egress_type: egressType,
+                });
+            }
+            let decision;
+            try {
+                decision = await options.filter(port, hostname, req.socket);
+            }
+            catch (error) {
+                logForDebugging(`Filter threw error: ${error}`, { level: 'error' });
+                decision = {
+                    allowed: false,
+                    verdict: {
+                        decision: 'deny',
+                        reason: 'filter_failure',
+                        policy_tag: 'network.allowlist',
+                    },
+                };
+            }
+            if (!decision.allowed) {
+                if (telemetryActive) {
+                    emitTelemetryEvent({
+                        stage: 'failure',
+                        status: 'failed',
+                        attempt: 0,
+                        status_code: 403,
+                        sandbox_verdict: decision.verdict,
+                        network: {
+                            resolved_host: hostname,
+                            resolved_ip: null,
+                            tls_outcome: null,
+                            tls_error: null,
+                            dns_source: null,
+                        },
+                        latency_ms: performance.now() - startTime,
+                        egress_type: egressType,
+                    });
+                }
+                res.writeHead(403, {
+                    'Content-Type': 'text/plain',
+                    'X-Proxy-Error': 'blocked-by-allowlist',
+                });
+                res.end('Connection blocked by network allowlist');
+                return;
+            }
+            if (telemetryActive) {
+                emitTelemetryEvent({
+                    stage: 'attempt',
+                    status: 'success',
+                    attempt: 0,
+                    sandbox_verdict: decision.verdict,
+                    network: {
+                        resolved_host: hostname,
+                        resolved_ip: null,
+                        tls_outcome: null,
+                        tls_error: null,
+                        dns_source: null,
+                    },
+                    latency_ms: null,
+                    queue_latency_ms: performance.now() - startTime,
+                    egress_type: egressType,
+                });
+            }
+            const attemptStart = telemetryActive ? performance.now() : 0;
+            let resolvedIp = null;
+            let tlsOutcome = url.protocol === 'https:' ? 'handshake_pending' : null;
+            let tlsError = null;
+            let telemetryCompleted = false;
+            const requestHeaders = telemetryActive
+                ? sanitizeHeaders(req.headers)
+                : {};
+            const requestFn = url.protocol === 'https:' ? httpsRequest : httpRequest;
+            const proxyReq = requestFn({
+                hostname,
+                port,
+                path: url.pathname + url.search,
+                method: req.method,
+                headers: {
+                    ...req.headers,
+                    host: url.host,
+                },
+            }, proxyRes => {
+                res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+                const responseHeaders = telemetryActive
+                    ? sanitizeHeaders(proxyRes.headers)
+                    : null;
+                let responseBytes = 0;
+                const hash = telemetryActive ? createHash('sha256') : null;
+                if (telemetryActive && hash) {
+                    proxyRes.on('data', chunk => {
+                        responseBytes += chunk.length;
+                        hash.update(chunk);
+                    });
+                }
+                proxyRes.on('end', () => {
+                    if (telemetryActive && !telemetryCompleted) {
+                        telemetryCompleted = true;
+                        const latency = performance.now() - attemptStart;
+                        const payloadHash = hash && responseBytes > 0 ? hash.digest('hex') : null;
+                        emitTelemetryEvent({
+                            stage: 'completion',
+                            status: proxyRes.statusCode &&
+                                proxyRes.statusCode >= 200 &&
+                                proxyRes.statusCode < 400
+                                ? 'success'
+                                : 'failed',
+                            attempt: 0,
+                            status_code: proxyRes.statusCode ?? null,
+                            sandbox_verdict: decision.verdict,
+                            network: {
+                                resolved_host: hostname,
+                                resolved_ip: resolvedIp ??
+                                    (proxyRes.socket
+                                        ? (proxyRes.socket.remoteAddress ?? null)
+                                        : null),
+                                tls_outcome: tlsOutcome,
+                                tls_error: tlsError,
+                                dns_source: resolvedIp ? 'system' : null,
+                            },
+                            http_metadata: {
+                                req_headers: requestHeaders,
+                                resp_headers: responseHeaders,
+                                payload_bytes: responseBytes,
+                                payload_hash: payloadHash,
+                                compression: responseHeaders
+                                    ? getCompressionHeader(proxyRes.headers)
+                                    : null,
+                            },
+                            latency_ms: latency,
+                            egress_type: egressType,
+                        });
+                    }
+                });
+                proxyRes.on('error', err => {
+                    logForDebugging(`Proxy response error: ${err.message}`, {
+                        level: 'error',
+                    });
+                    if (telemetryActive && !telemetryCompleted) {
+                        telemetryCompleted = true;
+                        emitTelemetryEvent({
+                            stage: 'failure',
+                            status: 'failed',
+                            attempt: 0,
+                            status_code: null,
+                            sandbox_verdict: decision.verdict,
+                            network: {
+                                resolved_host: hostname,
+                                resolved_ip: resolvedIp,
+                                tls_outcome: tlsOutcome,
+                                tls_error: err.message,
+                                dns_source: resolvedIp ? 'system' : null,
+                            },
+                            http_metadata: {
+                                req_headers: requestHeaders,
+                                resp_headers: responseHeaders,
+                                payload_bytes: null,
+                                payload_hash: null,
+                                compression: null,
+                            },
+                            latency_ms: performance.now() - attemptStart,
+                            egress_type: egressType,
+                        });
+                    }
+                });
+                proxyRes.pipe(res);
+            });
+            proxyReq.on('socket', (socket) => {
+                if (!telemetryActive) {
+                    return;
+                }
+                socket.once('lookup', (err, address) => {
+                    if (err) {
+                        tlsError = err.message;
+                        return;
+                    }
+                    resolvedIp = address;
+                });
+                socket.once('error', err => {
+                    tlsError = err.message;
+                });
+                if (url.protocol === 'https:') {
+                    ;
+                    socket.once('secureConnect', () => {
+                        tlsOutcome = 'handshake_success';
+                    });
+                }
+            });
+            proxyReq.on('error', err => {
+                logForDebugging(`Proxy request failed: ${err.message}`, {
+                    level: 'error',
+                });
+                if (telemetryActive && !telemetryCompleted) {
+                    telemetryCompleted = true;
+                    emitTelemetryEvent({
+                        stage: 'failure',
+                        status: 'failed',
+                        attempt: 0,
+                        status_code: null,
+                        sandbox_verdict: decision.verdict,
+                        network: {
+                            resolved_host: hostname,
+                            resolved_ip: resolvedIp,
+                            tls_outcome: url.protocol === 'https:'
+                                ? 'handshake_error'
+                                : 'connection_error',
+                            tls_error: err.message,
+                            dns_source: resolvedIp ? 'system' : null,
+                        },
+                        http_metadata: {
+                            req_headers: requestHeaders,
+                            resp_headers: null,
+                            payload_bytes: null,
+                            payload_hash: null,
+                            compression: null,
+                        },
+                        latency_ms: performance.now() - attemptStart,
+                        egress_type: egressType,
+                    });
+                }
+                if (!res.headersSent) {
+                    res.writeHead(502, { 'Content-Type': 'text/plain' });
+                    res.end('Bad Gateway');
+                }
+            });
+            req.pipe(proxyReq);
+        }
+        catch (err) {
+            logForDebugging(`Error handling HTTP request: ${err}`, { level: 'error' });
+            res.writeHead(500, { 'Content-Type': 'text/plain' });
+            res.end('Internal Server Error');
+        }
+    });
+    return server;
+}
+//# sourceMappingURL=http-proxy.js.map