sliccy 6.146.2 → 6.147.1

package/dist/node-server/fetch-proxy-gzip.d.ts

@@ -0,0 +1,34 @@
+import { Transform } from 'node:stream';
+/** gzip member magic (`1f 8b`). */
+export declare const GZIP_MAGIC_0 = 31;
+export declare const GZIP_MAGIC_1 = 139;
+/**
+ * True when the upstream `content-encoding` does not claim a compressed
+ * coding. Empty and `identity` both mean "the bytes are the representation"
+ * — which is a lie when an edge returns cached gzip without the header
+ * (#3037, AEM/Fastly).
+ */
+export declare function contentEncodingLooksUncompressed(value: string | null | undefined): boolean;
+export declare function bufferStartsWithGzipMagic(buf: Uint8Array): boolean;
+export interface MaybeGunzipOptions {
+    /**
+     * Fired once the first two bytes have been seen (or on empty EOF), before
+     * any decoded bytes are pushed. `inflating` is true when gzip magic was
+     * present and the rest of the body will go through zlib.
+     */
+    onDecided?: (inflating: boolean) => void;
+}
+/**
+ * Peek-and-maybe-gunzip transform for `/api/fetch-proxy`.
+ *
+ * If the body starts with gzip magic, pipe through `zlib.createGunzip`.
+ * Otherwise pass bytes through. The route only inserts this transform for
+ * text content types so a real `application/gzip` / `.tar.gz` download is
+ * not silently inflated.
+ *
+ * Declared `gzip`/`br` is usually already inflated by undici; sniffing
+ * magic still catches the AEM/Fastly shape (gzip bytes, encoding
+ * absent/`identity`). The inner Gunzip is paused when `push` returns
+ * false so a highly compressible chunk cannot unbounded-buffer here.
+ */
+export declare function createMaybeGunzipStream(options?: MaybeGunzipOptions): Transform;

package/dist/node-server/fetch-proxy-gzip.js

@@ -0,0 +1,123 @@
+import { Transform } from 'node:stream';
+import { createGunzip } from 'node:zlib';
+/** gzip member magic (`1f 8b`). */
+export const GZIP_MAGIC_0 = 0x1f;
+export const GZIP_MAGIC_1 = 0x8b;
+/**
+ * True when the upstream `content-encoding` does not claim a compressed
+ * coding. Empty and `identity` both mean "the bytes are the representation"
+ * — which is a lie when an edge returns cached gzip without the header
+ * (#3037, AEM/Fastly).
+ */
+export function contentEncodingLooksUncompressed(value) {
+    const encoding = (value ?? '').trim().toLowerCase();
+    return encoding === '' || encoding === 'identity';
+}
+export function bufferStartsWithGzipMagic(buf) {
+    return buf.length >= 2 && buf[0] === GZIP_MAGIC_0 && buf[1] === GZIP_MAGIC_1;
+}
+/**
+ * Peek-and-maybe-gunzip transform for `/api/fetch-proxy`.
+ *
+ * If the body starts with gzip magic, pipe through `zlib.createGunzip`.
+ * Otherwise pass bytes through. The route only inserts this transform for
+ * text content types so a real `application/gzip` / `.tar.gz` download is
+ * not silently inflated.
+ *
+ * Declared `gzip`/`br` is usually already inflated by undici; sniffing
+ * magic still catches the AEM/Fastly shape (gzip bytes, encoding
+ * absent/`identity`). The inner Gunzip is paused when `push` returns
+ * false so a highly compressible chunk cannot unbounded-buffer here.
+ */
+export function createMaybeGunzipStream(options = {}) {
+    return new MaybeGunzipTransform(options.onDecided);
+}
+class MaybeGunzipTransform extends Transform {
+    #head = Buffer.alloc(0);
+    #decided = false;
+    #gunzip = null;
+    #onDecided;
+    constructor(onDecided) {
+        super();
+        this.#onDecided = onDecided;
+        // Destination drained — let zlib produce more. Attached once so a
+        // paused Gunzip cannot sit idle after `push` returned false.
+        this.on('resume', () => {
+            this.#gunzip?.resume();
+        });
+    }
+    _transform(chunk, _enc, cb) {
+        if (this.#gunzip) {
+            this.#gunzip.write(chunk, cb);
+            return;
+        }
+        if (this.#decided) {
+            cb(null, chunk);
+            return;
+        }
+        this.#head = Buffer.concat([this.#head, chunk]);
+        if (this.#head.length < 2) {
+            cb();
+            return;
+        }
+        this.#finishDecide(cb);
+    }
+    _flush(cb) {
+        if (!this.#decided) {
+            if (this.#head.length === 0) {
+                this.#onDecided?.(false);
+                cb();
+                return;
+            }
+            this.#finishDecide((err) => {
+                if (err) {
+                    cb(err);
+                    return;
+                }
+                this.#endGunzipOrFinish(cb);
+            });
+            return;
+        }
+        this.#endGunzipOrFinish(cb);
+    }
+    #finishDecide(cb) {
+        this.#decided = true;
+        const head = this.#head;
+        this.#head = Buffer.alloc(0);
+        if (!bufferStartsWithGzipMagic(head)) {
+            this.#onDecided?.(false);
+            cb(null, head);
+            return;
+        }
+        this.#onDecided?.(true);
+        const gunzip = createGunzip();
+        this.#gunzip = gunzip;
+        gunzip.on('data', (decoded) => {
+            if (!this.push(decoded)) {
+                gunzip.pause();
+            }
+        });
+        gunzip.on('error', (err) => {
+            this.destroy(err);
+        });
+        gunzip.write(head, cb);
+    }
+    #endGunzipOrFinish(cb) {
+        const gunzip = this.#gunzip;
+        if (!gunzip) {
+            cb();
+            return;
+        }
+        const onEnd = () => {
+            gunzip.off('error', onError);
+            cb();
+        };
+        const onError = (err) => {
+            gunzip.off('end', onEnd);
+            cb(err);
+        };
+        gunzip.once('end', onEnd);
+        gunzip.once('error', onError);
+        gunzip.end();
+    }
+}

package/dist/node-server/fetch-proxy-headers.js

@@ -35,6 +35,9 @@ export const FETCH_PROXY_SKIP_HEADERS = new Set([
     // @slicc/shared-ts secrets-pipeline.ts) — consumed by the route handler
     // to compute and attach a real signature header; never forwarded as-is.
     'x-slicc-hmac-sign',
+    // Let undici negotiate gzip/br. Forcing `identity` made AEM/Fastly
+    // return cached gzip bytes with no `content-encoding` (#3037).
+    'accept-encoding',
 ]);
 /**
  * Response-side header names the proxy must NOT copy from the upstream
@@ -53,6 +56,10 @@ export const FETCH_PROXY_SKIP_HEADERS = new Set([
  */
 export const FETCH_PROXY_SKIP_RESPONSE_HEADERS = new Set([
     'transfer-encoding',
+    // Stripped because this hop delivers decoded bytes: undici inflates a
+    // declared coding, and `streamUpstreamBody` gunzips a body that still
+    // starts with gzip magic when the coding is absent (#3037). A synthetic
+    // SW `Response` does not inflate `content-encoding`.
     'content-encoding',
     'content-length',
     'www-authenticate',

package/dist/node-server/routes/fetch-proxy.js

@@ -1,6 +1,7 @@
-import { Readable, Transform } from 'node:stream';
+import { PassThrough, Readable, Transform } from 'node:stream';
 import { StringDecoder } from 'node:string_decoder';
 import { HMAC_SIGN_HEADER, isFormContentType, isLoopbackOrigin, isTextContentType, isTextRequestContentType, unmaskFormBody, } from '../_shared/index.js';
+import { createMaybeGunzipStream } from '../fetch-proxy-gzip.js';
 import { buildFetchProxyExposeHeaders, FETCH_PROXY_CONTENT_LENGTH_HEADER, FETCH_PROXY_SKIP_HEADERS, FETCH_PROXY_SKIP_RESPONSE_HEADERS, FETCH_PROXY_SKIP_RESPONSE_PREFIXES, } from '../fetch-proxy-headers.js';
 import { AgentActivityTracker, registerAgentActivityRoute } from './agent-activity.js';
 /** Pick the first value of a possibly-multi-valued request header. */
@@ -24,7 +25,8 @@ async function collectRawBody(req) {
 /**
  * Build the forwarded header set: copy non-hop-by-hop headers, then restore
  * the forbidden-header transports (Cookie/Origin/Referer/Proxy-*) the browser
- * could not send via fetch(), and force an identity encoding.
+ * could not send via fetch(). `accept-encoding` is skipped so undici
+ * negotiates gzip/br and decompresses transparently (#3037).
  */
 function buildForwardHeaders(req, targetUrl) {
     const headers = {};
@@ -72,10 +74,6 @@ function buildForwardHeaders(req, targetUrl) {
             delete headers[key];
         }
     }
-    // Always request uncompressed responses — the proxy doesn't decompress and
-    // the browser→proxy hop is localhost, so compression has no benefit and
-    // would arrive as garbage once Content-Encoding is stripped below.
-    headers['accept-encoding'] = 'identity';
     return headers;
 }
 /**
@@ -246,25 +244,36 @@ function createScrubStream(secretProxy, isText) {
 function streamUpstreamBody(res, upstream, secretProxy, detachClientClose) {
     const isText = isTextContentType(upstream.headers.get('content-type') ?? '');
     const upstreamStream = Readable.fromWeb(upstream.body);
+    // Text only: a real `application/gzip` / `.tar.gz` body is a gzip member
+    // whose bytes ARE the representation. Sniffing it would silently inflate
+    // a download. JS/CSS/HTML (#3037) are all text.
+    const decoded = isText
+        ? createMaybeGunzipStream({
+            onDecided: (inflating) => {
+                if (inflating)
+                    res.removeHeader(FETCH_PROXY_CONTENT_LENGTH_HEADER);
+            },
+        })
+        : new PassThrough();
     const scrubChunk = createScrubStream(secretProxy, isText);
-    upstreamStream.on('error', (err) => {
+    const onStreamError = (err) => {
         detachClientClose();
         if (!res.headersSent) {
             res.setHeader('X-Proxy-Error', '1');
-            res
-                .status(502)
-                .json({ error: `Proxy stream failed: ${err instanceof Error ? err.message : err}` });
+            res.status(502).json({ error: `Proxy stream failed: ${err.message}` });
         }
         else {
             res.destroy(err);
         }
-    });
+    };
+    upstreamStream.on('error', onStreamError);
+    decoded.on('error', onStreamError);
     // Belt-and-braces cleanup: 'finish' fires once the response is fully flushed;
     // 'close' fires regardless of how the response ended. Either way the abort
     // listener should be gone.
     res.on('finish', detachClientClose);
     res.on('close', detachClientClose);
-    upstreamStream.pipe(scrubChunk).pipe(res);
+    upstreamStream.pipe(decoded).pipe(scrubChunk).pipe(res);
 }
 /**
  * Fetch proxy — forwards cross-origin requests from the browser to bypass