AG-31672 Fix 'trusted-replace-xhr-response' — modifying XHR response without changes causes breakage. #419

Squashed commit of the following:

commit eab794b
Author: Adam Wróblewski <adam@adguard.com>
Date:   Thu Jun 18 15:30:28 2026 +0200

    Fix empty response headers on intercepted XHR in trusted-replace-xhr-response

Author: AdamWr

CHANGELOG.md

@@ -28,6 +28,8 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
 
 ### Fixed
 
+- `trusted-replace-xhr-response` response headers (`getResponseHeader`, `getAllResponseHeaders`)
+  now return the correct values on intercepted XHR objects [#419].
 - Issue with `Maximum call stack size exceeded` error when
   `trusted-json-set` or `trusted-replace-argument` is called with method used inside scriptlet [#565].
 - Infinite loop in `getRecursiveCandidates` in `json-path-utils` [#563].
@@ -41,6 +43,7 @@ The format is based on [Keep a Changelog], and this project adheres to [Semantic
 [#560]: https://github.com/AdguardTeam/Scriptlets/issues/560
 [#529]: https://github.com/AdguardTeam/Scriptlets/issues/529
 [#467]: https://github.com/AdguardTeam/Scriptlets/issues/467
+[#419]: https://github.com/AdguardTeam/Scriptlets/issues/419
 [#292]: https://github.com/AdguardTeam/Scriptlets/issues/292
 
 ## [2.4.2] - 2026-04-24

src/scriptlets/trusted-replace-xhr-response.js

@@ -129,6 +129,10 @@ export function trustedReplaceXhrResponse(source, pattern = '', replacement = ''
     // https://github.com/AdguardTeam/Scriptlets/issues/386
     const matchedXhrRequests = new Set();
     const xhrRequestHeaders = new Map();
+    // Maps a matched XHR object to its forged request, which holds the real
+    // response headers — needed because the original XHR is never sent.
+    // https://github.com/AdguardTeam/Scriptlets/issues/419
+    const forgedRequests = new WeakMap();
 
     let xhrData;
 
@@ -167,6 +171,25 @@ export function trustedReplaceXhrResponse(source, pattern = '', replacement = ''
             // setRequestHeader can only be called on open xhr object,
             // so we can safely proxy it here
             thisArg.setRequestHeader = new Proxy(thisArg.setRequestHeader, setRequestHeaderHandler);
+
+            // The original XHR object is never actually sent — the forged request is —
+            // so its response headers would be empty. Proxy the header getters of the
+            // target xhr object to return the real headers from the forged request.
+            // Proxying (instead of reassigning) keeps `toString()` reporting native code.
+            const responseHeaderWrapper = (target, thisArg, args) => {
+                const forgedRequest = forgedRequests.get(thisArg);
+                if (forgedRequest) {
+                    return Reflect.apply(target, forgedRequest, args);
+                }
+                return Reflect.apply(target, thisArg, args);
+            };
+
+            const responseHeaderHandler = {
+                apply: responseHeaderWrapper,
+            };
+
+            thisArg.getResponseHeader = new Proxy(thisArg.getResponseHeader, responseHeaderHandler);
+            thisArg.getAllResponseHeaders = new Proxy(thisArg.getAllResponseHeaders, responseHeaderHandler);
         }
 
         return Reflect.apply(target, thisArg, args);
@@ -236,6 +259,11 @@ export function trustedReplaceXhrResponse(source, pattern = '', replacement = ''
                 responseText: { value: responseContent, writable: false },
             });
 
+            // The original XHR object is never actually sent — the forged request is —
+            // so its response headers would be empty. Keep a reference to the forged
+            // request so the proxied header getters can return the real headers.
+            forgedRequests.set(thisArg, forgedRequest);
+
             // Mock events
             setTimeout(() => {
                 const stateEvent = new Event('readystatechange');

tests/scriptlets/trusted-replace-xhr-response.test.js

@@ -418,6 +418,45 @@ if (isSupported) {
         xhr.send();
     });
 
+    test('Matched, response headers are available on modified XHR', async (assert) => {
+        const METHOD = 'GET';
+        const URL = `${FETCH_OBJECTS_PATH}/test01.json`;
+        const PATTERN = 'a1';
+        const REPLACEMENT = 'z9';
+        const MATCH_DATA = [PATTERN, REPLACEMENT, `${URL} method:${METHOD}`];
+
+        runScriptlet(name, MATCH_DATA);
+
+        const done = assert.async();
+
+        const xhr = new XMLHttpRequest();
+        xhr.open(METHOD, URL);
+        xhr.onload = () => {
+            assert.strictEqual(xhr.readyState, 4, 'Response done');
+            assert.notOk(xhr.response.includes(PATTERN), 'Response has been modified');
+
+            const allHeaders = xhr.getAllResponseHeaders();
+            assert.ok(typeof allHeaders === 'string' && allHeaders.length > 0, 'getAllResponseHeaders is not empty');
+            assert.ok(
+                allHeaders.toLowerCase().includes('content-type'),
+                'getAllResponseHeaders contains content-type header',
+            );
+            assert.ok(
+                xhr.getResponseHeader('Content-Type')?.includes('application/json'),
+                'getResponseHeader returns the correct content-type value',
+            );
+            assert.strictEqual(
+                xhr.getResponseHeader('non-existent-header'),
+                null,
+                'getResponseHeader returns null for missing header',
+            );
+
+            assert.strictEqual(window.hit, 'FIRED', 'hit function fired');
+            done();
+        };
+        xhr.send();
+    });
+
     // bypass prevention: https://github.com/AdguardTeam/Scriptlets/issues/386
     test('Cannot be bypassed by setting shouldBePrevented = false on XHR object', async (assert) => {
         const METHOD = 'GET';