pi-codex-auto-review 0.1.0

package/node_modules/@anthropic-ai/sandbox-runtime/dist/sandbox/socks-proxy.js.map

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

package/node_modules/@anthropic-ai/sandbox-runtime/dist/sandbox/tls-terminate-proxy.d.ts

@@ -0,0 +1,100 @@
+/**
+ * In-process TLS termination for HTTPS traffic through the forward proxy.
+ *
+ * When a MitmCA is configured, the forward proxy hands CONNECT requests here
+ * instead of opening an opaque byte tunnel. We terminate the client's TLS
+ * with a per-host leaf cert (see mitm-leaf.ts), parse the decrypted stream
+ * as HTTP/1.1, and re-issue each request upstream over a real TLS
+ * connection. The optional `filterRequest` callback runs on each parsed
+ * request before it is forwarded.
+ */
+import type { LookupFunction } from 'node:net';
+import type { Duplex } from 'node:stream';
+import type { MitmCA } from './mitm-ca.js';
+import { type FilterRequestCallback, type MutateForwardedHeaders } from './request-filter.js';
+import { type GetBodySubstitutions } from './body-substitution.js';
+import type { PlanSigv4 } from './credential-aws-pairs.js';
+/**
+ * Upper bound on the request body the proxy will buffer to recompute a
+ * literal SigV4 body hash. The signature must cover the exact bytes sent
+ * upstream, so buffering is unavoidable for that shape — but without a
+ * cap a sandboxed client could pin arbitrary host memory with one large
+ * signed upload (awslabs/aws-sigv4-proxy buffers with no limit; we fail
+ * closed instead). Bodies over the cap are denied with a 403; clients
+ * with larger payloads should sign UNSIGNED-PAYLOAD, which streams.
+ */
+export declare const MAX_SIGV4_RESIGN_BODY_BYTES: number;
+/**
+ * True if `buf` starts with a TLS Handshake record header.
+ *
+ * Three bytes: content type 0x16 (Handshake) + legacy_record_version
+ * 0x03,0x00–0x03. RFC 8446 §5.1 froze the record-layer version (TLS 1.3+
+ * negotiate via the supported_versions extension, the wire header stays
+ * ≤0x0303), so this holds for current and future TLS. Same predicate as
+ * mitmproxy `starts_like_tls_record`; nginx `ssl_preread` routes on byte 0
+ * alone and HAProxy `req.ssl_hello_type` reads 9 bytes to also extract the
+ * handshake type — 3 is the established middle ground for "is this TLS".
+ *
+ * Routing heuristic, not a security check: a non-TLS stream that happens to
+ * start 16 03 0x is handed to the TLS server, which then rejects it properly.
+ */
+export declare function looksLikeClientHello(buf: Buffer): boolean;
+/**
+ * Wait for the client's first post-CONNECT bytes and report whether they look
+ * like a TLS ClientHello. The caller must already have written the
+ * `200 Connection Established` line — clients don't send until they see it.
+ *
+ * Any bytes consumed here are returned in `.head` so the caller can forward
+ * them to whichever downstream (terminate or opaque tunnel) it picks. The
+ * socket is left paused so further bytes buffer until the downstream
+ * `pipe()` resumes it.
+ */
+export declare function peekForClientHello(socket: Duplex, head: Buffer): Promise<{
+    isTLS: boolean;
+    head: Buffer;
+}>;
+export type TerminateTarget = {
+    /**
+     * Canonical (see canonicalizeHost) CONNECT target: what the allowlist
+     * evaluated. Used verbatim for the minted leaf, the filterRequest URL,
+     * the credential hooks' destHost, and the upstream host/SNI, so all of
+     * them agree with the policy decision regardless of how the client
+     * spelled the name.
+     */
+    hostname: string;
+    port: number;
+    /**
+     * Additional trusted CA(s) for the proxy's outbound TLS leg. Unset → system
+     * roots + NODE_EXTRA_CA_CERTS. Primarily a test seam (NODE_EXTRA_CA_CERTS
+     * is read at process start, so tests can't set it from inside the suite).
+     */
+    upstreamCA?: string | Buffer | Array<string | Buffer>;
+    /** Upstream-leg name resolution, already bound for this target (see HttpProxyServerOptions.lookupFor). */
+    lookup?: LookupFunction;
+    /**
+     * Called when filterRequest denies a parsed request, with the verified
+     * method/URL and the decision reason. Carried on the target so the
+     * per-connection request handler (which closes over `target`) can reach
+     * it without an extra parameter on every layer.
+     */
+    onFilterRequestDeny?: (method: string, url: string, reason: string) => void;
+};
+/**
+ * Terminate the client's TLS on `socket`, parse the decrypted HTTP/1.1
+ * stream, and forward each request to `target` over an upstream TLS
+ * connection kept alive for the life of the client's connection (see
+ * {@link createUpstreamLeg}).
+ *
+ * Preconditions: the caller has already validated `target` against the
+ * domain allowlist; this function does not re-check it.
+ *
+ * Implementation: we stand up a short-lived https.Server on a unix socket
+ * and pipe the client socket through it. The Node-idiomatic alternative —
+ * feeding the raw socket to a non-listening server via
+ * `emit('connection', socket)` — is not implemented by Bun's https.Server,
+ * and SRT runs under both runtimes. A per-connection server lets the
+ * request handler close over `target` (which carries the originally-
+ * requested host:port) without socket-keyed lookups.
+ */
+export declare function terminateAndForward(ca: MitmCA, filterRequest: FilterRequestCallback | undefined, mutateHeaders: MutateForwardedHeaders | undefined, getBodySubstitutions: GetBodySubstitutions | undefined, socket: Duplex, head: Buffer, target: TerminateTarget, planSigv4?: PlanSigv4, maxSigv4BodyBytes?: number): void;
+//# sourceMappingURL=tls-terminate-proxy.d.ts.map

package/node_modules/@anthropic-ai/sandbox-runtime/dist/sandbox/tls-terminate-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tls-terminate-proxy.d.ts","sourceRoot":"","sources":["../../src/sandbox/tls-terminate-proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AASH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAK9C,OAAO,KAAK,EAAE,MAAM,EAAY,MAAM,aAAa,CAAA;AAEnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAC1C,OAAO,EAIL,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAEL,KAAK,oBAAoB,EAC1B,MAAM,wBAAwB,CAAA;AAS/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAE1D;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,QAAmB,CAAA;AAK3D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAIzD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAsB3C;AAgCD,MAAM,MAAM,eAAe,GAAG;IAC5B;;;;;;OAMG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IACrD,0GAA0G;IAC1G,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CAC5E,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,aAAa,EAAE,qBAAqB,GAAG,SAAS,EAChD,aAAa,EAAE,sBAAsB,GAAG,SAAS,EACjD,oBAAoB,EAAE,oBAAoB,GAAG,SAAS,EACtD,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,SAAS,CAAC,EAAE,SAAS,EACrB,iBAAiB,GAAE,MAAoC,GACtD,IAAI,CA6GN"}

package/node_modules/@anthropic-ai/sandbox-runtime/dist/sandbox/tls-terminate-proxy.js

@@ -0,0 +1,546 @@
+/**
+ * In-process TLS termination for HTTPS traffic through the forward proxy.
+ *
+ * When a MitmCA is configured, the forward proxy hands CONNECT requests here
+ * instead of opening an opaque byte tunnel. We terminate the client's TLS
+ * with a per-host leaf cert (see mitm-leaf.ts), parse the decrypted stream
+ * as HTTP/1.1, and re-issue each request upstream over a real TLS
+ * connection. The optional `filterRequest` callback runs on each parsed
+ * request before it is forwarded.
+ */
+import { Agent as HttpsAgent, createServer as createHttpsServer, request as httpsRequest, } from 'node:https';
+import { connect } from 'node:net';
+import { checkServerIdentity } from 'node:tls';
+import { unlink } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { logForDebugging } from '../utils/debug.js';
+import { decideAndRespond, respondDenied, respondUpstreamError, } from './request-filter.js';
+import { prepareBodySubstitution, } from './body-substitution.js';
+import { mintLeafCert, secureContextFor } from './mitm-leaf.js';
+import { directRequestOptions, formatAuthority, stripHopByHop, } from './parent-proxy.js';
+import { sha256Hex } from './aws-sigv4.js';
+/**
+ * Upper bound on the request body the proxy will buffer to recompute a
+ * literal SigV4 body hash. The signature must cover the exact bytes sent
+ * upstream, so buffering is unavoidable for that shape — but without a
+ * cap a sandboxed client could pin arbitrary host memory with one large
+ * signed upload (awslabs/aws-sigv4-proxy buffers with no limit; we fail
+ * closed instead). Bodies over the cap are denied with a 403; clients
+ * with larger payloads should sign UNSIGNED-PAYLOAD, which streams.
+ */
+export const MAX_SIGV4_RESIGN_BODY_BYTES = 64 * 1024 * 1024;
+/** Rejection cause when a body exceeds {@link MAX_SIGV4_RESIGN_BODY_BYTES}. */
+class BodyTooLargeError extends Error {
+}
+/**
+ * True if `buf` starts with a TLS Handshake record header.
+ *
+ * Three bytes: content type 0x16 (Handshake) + legacy_record_version
+ * 0x03,0x00–0x03. RFC 8446 §5.1 froze the record-layer version (TLS 1.3+
+ * negotiate via the supported_versions extension, the wire header stays
+ * ≤0x0303), so this holds for current and future TLS. Same predicate as
+ * mitmproxy `starts_like_tls_record`; nginx `ssl_preread` routes on byte 0
+ * alone and HAProxy `req.ssl_hello_type` reads 9 bytes to also extract the
+ * handshake type — 3 is the established middle ground for "is this TLS".
+ *
+ * Routing heuristic, not a security check: a non-TLS stream that happens to
+ * start 16 03 0x is handed to the TLS server, which then rejects it properly.
+ */
+export function looksLikeClientHello(buf) {
+    return (buf.length >= 3 && buf[0] === 0x16 && buf[1] === 0x03 && buf[2] <= 0x03);
+}
+/**
+ * Wait for the client's first post-CONNECT bytes and report whether they look
+ * like a TLS ClientHello. The caller must already have written the
+ * `200 Connection Established` line — clients don't send until they see it.
+ *
+ * Any bytes consumed here are returned in `.head` so the caller can forward
+ * them to whichever downstream (terminate or opaque tunnel) it picks. The
+ * socket is left paused so further bytes buffer until the downstream
+ * `pipe()` resumes it.
+ */
+export function peekForClientHello(socket, head) {
+    if (head.length >= 3) {
+        return Promise.resolve({ isTLS: looksLikeClientHello(head), head });
+    }
+    return new Promise(resolve => {
+        let buf = head;
+        const done = () => {
+            socket.removeListener('data', onData);
+            socket.removeListener('close', done);
+            resolve({ isTLS: looksLikeClientHello(buf), head: buf });
+        };
+        const onData = (chunk) => {
+            // Pause synchronously so anything after this chunk buffers for the
+            // downstream pipe() rather than being dropped in flowing mode.
+            socket.pause();
+            buf = buf.length ? Buffer.concat([buf, chunk]) : chunk;
+            if (buf.length >= 3)
+                return done();
+            socket.resume();
+        };
+        socket.on('data', onData);
+        socket.once('close', done);
+    });
+}
+/**
+ * Relay `src` into `dst` with paused-mode reads (`'readable'` + `read()`)
+ * instead of `src.pipe(dst)`.
+ *
+ * `pipe()` throttles a flowing source with `pause()`/`resume()`, and under
+ * Bun a socket delivered by an http server's `'connect'` event corrupts its
+ * byte stream across those pause/resume cycles once writes queue (reliably
+ * reproducible with multi-megabyte uploads; the TLS server behind the relay
+ * then fails record MAC verification and the client sees `bad_record_mac` /
+ * a mid-upload reset). Pull-mode reads never call `pause()` and provide the
+ * same flow control: `read()` is only called while `dst` has buffer space,
+ * so the kernel backpressures the peer identically. Do not replace this
+ * with `pipe()` — under Node both are equivalent, but under Bun only this
+ * form is safe for CONNECT-upgraded sockets.
+ */
+function relayPullMode(src, dst) {
+    const pump = () => {
+        let chunk;
+        while ((chunk = src.read()) !== null) {
+            if (!dst.write(chunk)) {
+                dst.once('drain', pump);
+                return;
+            }
+        }
+        src.once('readable', pump);
+    };
+    pump();
+    src.once('end', () => dst.end());
+}
+/**
+ * Terminate the client's TLS on `socket`, parse the decrypted HTTP/1.1
+ * stream, and forward each request to `target` over an upstream TLS
+ * connection kept alive for the life of the client's connection (see
+ * {@link createUpstreamLeg}).
+ *
+ * Preconditions: the caller has already validated `target` against the
+ * domain allowlist; this function does not re-check it.
+ *
+ * Implementation: we stand up a short-lived https.Server on a unix socket
+ * and pipe the client socket through it. The Node-idiomatic alternative —
+ * feeding the raw socket to a non-listening server via
+ * `emit('connection', socket)` — is not implemented by Bun's https.Server,
+ * and SRT runs under both runtimes. A per-connection server lets the
+ * request handler close over `target` (which carries the originally-
+ * requested host:port) without socket-keyed lookups.
+ */
+export function terminateAndForward(ca, filterRequest, mutateHeaders, getBodySubstitutions, socket, head, target, planSigv4, maxSigv4BodyBytes = MAX_SIGV4_RESIGN_BODY_BYTES) {
+    // ALPN advertises HTTP/1.1 only — terminating HTTP/2 would require a frame
+    // parser; clients negotiate down. The base secureContext covers clients
+    // that don't send SNI; SNICallback covers everyone else.
+    const baseLeaf = mintLeafCert(ca, target.hostname);
+    const inner = createHttpsServer({
+        ALPNProtocols: ['http/1.1'],
+        cert: baseLeaf.certPem,
+        key: baseLeaf.keyPem,
+        SNICallback: (servername, cb) => {
+            try {
+                cb(null, secureContextFor(ca, servername || target.hostname));
+            }
+            catch (err) {
+                cb(err);
+            }
+        },
+    });
+    const leg = createUpstreamLeg(target);
+    inner.on('request', (req, res) => {
+        // A client abort mid-request destroys req/res with an error; with no
+        // listener it escapes as an uncaughtException (the runtime emits it
+        // from node:_http_server).
+        req.on('error', err => {
+            logForDebugging(`[tls-terminate] client request error: ${err.message}`, {
+                level: 'error',
+            });
+        });
+        res.on('error', err => {
+            logForDebugging(`[tls-terminate] client response error: ${err.message}`, {
+                level: 'error',
+            });
+        });
+        forwardUpstreamGuarded(filterRequest, mutateHeaders, getBodySubstitutions, req, res, target, leg, planSigv4, maxSigv4BodyBytes);
+    });
+    inner.on('clientError', (err, sock) => {
+        // Post-handshake parse errors / resets on the loopback leg would
+        // otherwise escalate to an uncaughtException, same class as the
+        // request-stream errors handled above.
+        logForDebugging(`[tls-terminate] client connection error for ${target.hostname}: ${err.message}`, { level: 'error' });
+        sock.destroy();
+    });
+    inner.on('tlsClientError', (err, sock) => {
+        logForDebugging(`[tls-terminate] client TLS error for ${target.hostname}: ${err.message}`, { level: 'error' });
+        sock.destroy();
+    });
+    inner.on('upgrade', (_req, sock) => {
+        // WebSocket / non-HTTP over TLS — out of scope for now.
+        logForDebugging('[tls-terminate] upgrade request refused', {
+            level: 'warn',
+        });
+        sock.destroy();
+    });
+    const sockPath = innerSocketPath();
+    const cleanup = () => {
+        inner.close();
+        leg.agent.destroy();
+        unlink(sockPath, () => { });
+    };
+    inner.on('error', err => {
+        logForDebugging(`[tls-terminate] inner server listen failed: ${err.message}`, { level: 'error' });
+        socket.destroy();
+        cleanup();
+    });
+    inner.listen(sockPath, () => {
+        const loop = connect({ path: sockPath });
+        loop.on('error', err => {
+            logForDebugging(`[tls-terminate] inner loopback failed: ${err.message}`, {
+                level: 'error',
+            });
+            socket.destroy();
+            cleanup();
+        });
+        loop.once('connect', () => {
+            // The caller wrote `200 Connection Established` before sniffing for the
+            // ClientHello; `head` holds whatever the sniff consumed.
+            if (head.length)
+                loop.write(head);
+            relayPullMode(socket, loop);
+            loop.pipe(socket);
+        });
+        socket.on('error', () => loop.destroy());
+        socket.once('close', () => {
+            loop.destroy();
+            cleanup();
+        });
+        loop.once('close', () => socket.destroy());
+    });
+    inner.unref();
+}
+function createUpstreamLeg(target) {
+    const agent = new HttpsAgent({
+        keepAlive: true,
+        maxSockets: 1,
+        // We're a TLS-terminating proxy, not a trust boundary for the upstream
+        // server's identity — the runtime verifies it normally (system roots and
+        // NODE_EXTRA_CA_CERTS). Pin the identity to the tunnel's target so the
+        // check does not depend on how a runtime derives it from the Host header
+        // (some verify against `Host` verbatim, so a non-default port would
+        // never match a SAN); `servername` still carries the name for SNI.
+        checkServerIdentity: (_host, cert) => checkServerIdentity(target.hostname, cert),
+        ...(target.upstreamCA ? { ca: target.upstreamCA } : {}),
+    });
+    let vetted;
+    return {
+        agent,
+        address() {
+            if (!vetted) {
+                const probe = directRequestOptions(target.hostname, target.port, target.lookup, true);
+                vetted = probe;
+                probe.catch(() => {
+                    if (vetted === probe)
+                        vetted = undefined;
+                });
+            }
+            return vetted;
+        },
+        forgetAddress() {
+            vetted = undefined;
+        },
+    };
+}
+/**
+ * True for the failure a reused keep-alive socket produces when the upstream
+ * closed it while the request was on its way.
+ */
+function isStaleSocketError(err) {
+    const code = err.code;
+    return code === 'ECONNRESET' || code === 'EPIPE';
+}
+/**
+ * Destroy a denied client's request only after the 403 has flushed —
+ * destroying the shared socket in the same tick can RST the response away.
+ */
+function destroyAfterDenial(req, res) {
+    if (res.writableFinished || res.destroyed) {
+        req.destroy();
+        return;
+    }
+    res.once('finish', () => req.destroy());
+    res.once('close', () => req.destroy());
+}
+function forwardUpstreamGuarded(...args) {
+    // Fire-and-forget from the request handler: a rejection (e.g. a
+    // synchronous throw writing a denial to a client that already reset)
+    // must not become an unhandledRejection.
+    forwardUpstream(...args).catch(err => {
+        logForDebugging(`[tls-terminate] forwardUpstream failed: ${err.message}`, { level: 'error' });
+    });
+}
+async function forwardUpstream(filterRequest, mutateHeaders, getBodySubstitutions, req, res, target, leg, planSigv4, maxSigv4BodyBytes = MAX_SIGV4_RESIGN_BODY_BYTES) {
+    // req.url is the request-target verbatim. Inside a CONNECT tunnel almost
+    // every client sends origin-form (`/path?q`), but RFC 7230 §5.3.2 also
+    // permits absolute-form (`https://host/path`) and servers MUST accept it.
+    // Normalize to origin-form so concatenating onto `https://${host}` below
+    // yields a well-formed URL, and discard any client-supplied authority so
+    // the CONNECT-verified target stays authoritative (same rationale as the
+    // Host-header note below).
+    const path = originFormPath(req.url);
+    // The tunnel target as it goes on the wire: filterRequest URL, Host, SigV4.
+    const authority = formatAuthority(target.hostname, target.port, 443);
+    let body = req;
+    if (filterRequest) {
+        const ac = new AbortController();
+        res.once('close', () => ac.abort());
+        // Build the URL passed to filterRequest from the CONNECT target,
+        // NOT from `req.headers.host`. The Host header is supplied by the
+        // sandboxed client and can be spoofed: a sandboxed process can
+        // CONNECT to allowlisted host A and then send a decrypted request
+        // with `Host: B` (where B is some other allowlisted host). If we
+        // built the filterRequest URL from req.headers.host the callback
+        // would see "host=B" while the request is actually delivered to A.
+        // A consumer using filterRequest for per-host method gating (e.g.
+        // "POST allowed only to inference endpoints") would be bypassed —
+        // the agent could spoof Host: api.example.com on a CONNECT to a
+        // different allowlisted host, get the POST allowed, and have it
+        // delivered to the CONNECT target instead.
+        //
+        // Always derive the URL from the verified CONNECT target so
+        // filterRequest sees the actual upstream destination.
+        const out = await decideAndRespond(filterRequest, req, res, `https://${authority}${path}`, ac.signal, target.onFilterRequestDeny);
+        if (out === null)
+            return;
+        body = out;
+        // The client may have aborted during the filterRequest await — the tee
+        // branch is already destroyed and res 'close' already fired, so the
+        // teardown listeners attached below would never run. Don't dial an
+        // upstream for a dead client. A COMPLETED request is also
+        // destroyed=true (normal stream lifecycle after 'end'); only a
+        // destroy without a clean end is an abort.
+        if ((req.destroyed && !req.readableEnded) ||
+            res.destroyed ||
+            req.socket.destroyed ||
+            body.destroyed) {
+            body.destroy();
+            return;
+        }
+    }
+    // The upstream is dialed by vetted address (below), so Host and SNI are
+    // what carry the name: rebuild Host from the tunnel's target — the name the
+    // allowlist saw — rather than forwarding the client's spelling.
+    const fwdHeaders = stripHopByHop(req.headers);
+    fwdHeaders.host = authority;
+    // SigV4 planning runs on the PRE-substitution headers (the trigger is
+    // the fake access key id in the credential scope, which the header
+    // substitution below replaces) but on the POST-strip view: the plan's
+    // signed-header presence check must see exactly the set that will be
+    // signed and forwarded, or a signed hop-by-hop header would pass the
+    // check and then blow up inside the signer.
+    const sigv4Plan = planSigv4?.(req.method ?? 'GET', path, fwdHeaders, target.hostname);
+    // Header mutation runs after the allow decision and before httpsRequest.
+    // The upstream TLS handshake (rejectUnauthorized defaults to true)
+    // completes before any HTTP bytes are written, so mutated headers never
+    // reach an unverified server.
+    mutateHeaders?.(fwdHeaders, target.hostname);
+    // Masked-credential substitution in the request body, mirroring the
+    // header substitution above. undefined → the bare pipe below, exactly as
+    // before. May delete content-length from fwdHeaders (chunked fallback).
+    const bodyTransform = prepareBodySubstitution(getBodySubstitutions, req, fwdHeaders, target.hostname);
+    // SigV4 re-signing runs after substitution so the new signature covers
+    // the headers as they actually go upstream (real access key id, real
+    // session token). Same denial surface as filterRequest.
+    let bufferedBody;
+    if (sigv4Plan?.action === 'deny') {
+        respondDenied(res, sigv4Plan.reason);
+        body.destroy();
+        if (body !== req)
+            destroyAfterDenial(req, res);
+        return;
+    }
+    if (sigv4Plan?.action === 'resign') {
+        let payloadHash = sigv4Plan.payloadHash;
+        if (payloadHash === undefined) {
+            // The client signed a literal body hash: buffer the body and
+            // recompute so the signature covers the bytes actually sent. Body
+            // substitution runs FIRST — the buffered bytes (and therefore the
+            // hash and signature) must be the substituted body, not the
+            // sentinel-bearing one the client wrote.
+            const bodySource = bodyTransform ? body.pipe(bodyTransform) : body;
+            if (bodyTransform) {
+                body.on('error', err => bodyTransform.destroy(err));
+            }
+            try {
+                bufferedBody = await collectBody(bodySource, maxSigv4BodyBytes);
+            }
+            catch (err) {
+                if (err instanceof BodyTooLargeError) {
+                    respondDenied(res, `AWS SigV4 request uses a masked credential and signs a ` +
+                        `literal body hash, so the proxy must buffer the body to ` +
+                        `re-sign it, but the body exceeds the ` +
+                        `${maxSigv4BodyBytes}-byte buffering limit; denied. Sign ` +
+                        `the payload as UNSIGNED-PAYLOAD to stream it without ` +
+                        `buffering, or use an unmasked credential to have the ` +
+                        `request forwarded untouched.`);
+                    // Drain (discarding) whatever the client is still sending so it
+                    // can read the 403 instead of seeing a reset mid-upload.
+                    bodySource.resume();
+                    return;
+                }
+                logForDebugging(`[tls-terminate] failed to buffer body for SigV4 re-sign: ${err.message}`, { level: 'error' });
+                res.destroy();
+                return;
+            }
+            payloadHash = sha256Hex(bufferedBody);
+            // The body is fully buffered so its exact length is known — set the
+            // header unconditionally. end(Buffer) only auto-computes a
+            // content-length for methods that default to chunked encoding; on
+            // bodyless-default methods it would raw-append the buffer unframed.
+            fwdHeaders['content-length'] = String(bufferedBody.length);
+        }
+        try {
+            sigv4Plan.apply(fwdHeaders, authority, payloadHash);
+        }
+        catch (err) {
+            // Fail closed on any signer error — a request the proxy claimed to
+            // handle must not go upstream half-rewritten, and a client-crafted
+            // header set must not become an unhandled rejection.
+            respondDenied(res, `AWS SigV4 re-signing failed: ${err.message}`);
+            body.destroy();
+            if (body !== req)
+                destroyAfterDenial(req, res);
+            return;
+        }
+    }
+    // When the client declared a body but the forwarded headers carry no
+    // framing (chunked TE stripped as hop-by-hop, or a body transform
+    // deleted content-length), the upstream leg must re-frame explicitly:
+    // for bodyless-method requests the runtime would otherwise write the
+    // piped body bytes raw after complete-framed headers — a
+    // request-smuggling primitive. The SigV4 buffered path is exempt:
+    // end(bufferedBody) computes its own content-length.
+    const clientDeclaredBody = Boolean(req.headers['content-length'] || req.headers['transfer-encoding']);
+    if (clientDeclaredBody &&
+        bufferedBody === undefined &&
+        fwdHeaders['content-length'] === undefined &&
+        fwdHeaders['transfer-encoding'] === undefined) {
+        fwdHeaders['transfer-encoding'] = 'chunked';
+    }
+    const failUpstream = (err, sent) => {
+        logForDebugging(`[tls-terminate] upstream ${target.hostname}:${target.port} failed: ${err.message}`, { level: 'error' });
+        leg.forgetAddress();
+        if (sent?.reusedSocket && !res.headersSent && isStaleSocketError(err)) {
+            // The upstream closed the kept-alive socket as this request went out.
+            // Close the client's connection rather than answer 502: that is what
+            // the client would see on a direct keep-alive connection, and what its
+            // own retry policy is written for. Destroy the socket, not `res`: with
+            // no headers sent yet, Bun's res.destroy() answers `200 OK` with an
+            // empty body before closing, which would hand the client a fabricated
+            // success.
+            req.socket.destroy();
+            return;
+        }
+        respondUpstreamError(res, err);
+    };
+    // Vet and pick the upstream address first (see createUpstreamLeg); the
+    // name stays in Host and SNI.
+    let direct;
+    try {
+        direct = await leg.address();
+    }
+    catch (err) {
+        failUpstream(err);
+        return;
+    }
+    if (res.destroyed || req.socket.destroyed) {
+        // Client went away during the dial.
+        body.destroy();
+        return;
+    }
+    // TODO(terminating-tls): honour parentProxy for the upstream leg.
+    const upstream = httpsRequest({
+        ...direct,
+        agent: leg.agent,
+        path,
+        method: req.method,
+        headers: fwdHeaders,
+    }, upRes => {
+        // The response stream errors independently of the ClientRequest;
+        // pipe() does not handle source errors.
+        upRes.on('error', err => {
+            logForDebugging(`[tls-terminate] upstream response error: ${err.message}`, { level: 'error' });
+            res.destroy();
+        });
+        res.writeHead(upRes.statusCode ?? 502, stripHopByHop(upRes.headers));
+        upRes.pipe(res);
+    });
+    upstream.on('error', err => failUpstream(err, upstream));
+    res.on('close', () => upstream.destroy());
+    if (bufferedBody !== undefined) {
+        // SigV4 literal-hash path: the buffered body already went through
+        // bodyTransform above (when one applied), so send it verbatim.
+        upstream.end(bufferedBody);
+    }
+    else if (bodyTransform) {
+        // Errors on either side of the extra pipe stage tear the chain down —
+        // a stalled half-open upstream would otherwise wait for the client.
+        bodyTransform.on('error', err => upstream.destroy(err));
+        body.on('error', err => bodyTransform.destroy(err));
+        res.on('close', () => bodyTransform.destroy());
+        body.pipe(bodyTransform).pipe(upstream);
+    }
+    else {
+        // pipe() does not handle source errors. `body` may be a tee branch
+        // from decideAndRespond (not `req` itself), so a client abort surfaces
+        // here as an 'error' that would otherwise escape as an
+        // uncaughtException.
+        body.on('error', err => upstream.destroy(err));
+        body.pipe(upstream);
+    }
+}
+/**
+ * Read a request body fully into memory (for SigV4 body-hash re-signing).
+ * Rejects with {@link BodyTooLargeError} once more than `maxBytes` have
+ * arrived, discarding everything buffered so far — the caller denies the
+ * request, so holding the partial body would defeat the cap.
+ */
+function collectBody(body, maxBytes) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let total = 0;
+        const onData = (c) => {
+            total += c.length;
+            if (total > maxBytes) {
+                chunks.length = 0;
+                body.removeListener('data', onData);
+                reject(new BodyTooLargeError(`request body exceeds ${maxBytes} bytes`));
+                return;
+            }
+            chunks.push(c);
+        };
+        body.on('data', onData);
+        body.once('end', () => resolve(Buffer.concat(chunks)));
+        body.once('error', reject);
+    });
+}
+function originFormPath(reqUrl) {
+    const raw = reqUrl ?? '/';
+    if (raw.startsWith('/'))
+        return raw;
+    try {
+        const u = new URL(raw);
+        return `${u.pathname}${u.search}` || '/';
+    }
+    catch {
+        // asterisk-form (`OPTIONS *`) or anything else non-absolute — pass through.
+        return raw;
+    }
+}
+let sockSeq = 0;
+function innerSocketPath() {
+    // Keep it short — macOS sun_path is 104 bytes.
+    return join(tmpdir(), `srt-tt-${process.pid}-${(sockSeq++).toString(36)}.sock`);
+}
+//# sourceMappingURL=tls-terminate-proxy.js.map