Skip to content

Chrome DevTools for coding agents

feat: support upstream network mock responses (#3420)

Marco Pronterac4bf342b0854
diff --git a/docs/tool-reference.md b/docs/tool-reference.md
index dc71b0c6..e3bdea0d 100644
--- a/docs/tool-reference.md
+++ b/docs/tool-reference.md
@@ -726,14 +726,15 @@ in the DevTools Elements panel (if any).
### `mock_network`
-**Description:** Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use [`remove_network_mock`](#remove_network_mock) to remove mocks. (requires flag: --categoryNetworkMocks=true)
+**Description:** Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body or upstream updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Upstream responses use server-side GET/HEAD fetches. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use [`remove_network_mock`](#remove_network_mock) to remove mocks. (requires flag: --categoryNetworkMocks=true)
**Parameters:**
- **pageId** (number) **(required)**: Targets a specific page by ID.
-- **body** (string) _(optional)_: Local response body file, revalidated and reread for every request. Content-Type follows its extension.
+- **body** (string) _(optional)_: Local response body file, revalidated and reread for every request. Content-Type follows its extension. Mutually exclusive with upstream.
- **resourceType** (enum: "document", "stylesheet", "image", "media", "font", "script", "texttrack", "xhr", "fetch", "prefetch", "eventsource", "manifest", "signedexchange", "ping", "cspviolationreport", "preflight", "fedcm", "other") _(optional)_: Restrict requests and stored mock filters to this resource type. Omit to inspect/remove all types or configure a mock for any type.
- **route** (string) _(optional)_: Absolute URLPattern, e.g. https://example.com/app.js or `*://*:*/app.js`. Use `*` for wildcards; omitted query strings match any query. Regex and `:name` groups are rejected. Inspection and removal compare the stored pattern exactly. Omit to inspect/remove all routes or match any URL.
+- **upstream** (string) _(optional)_: Absolute HTTP(S) replacement URL for GET/HEAD requests. URL allowlists and blocklists apply to this URL and every redirect. Mutually exclusive with body.
---
diff --git a/scripts/eval_scenarios/network_override_redirect_test.ts b/scripts/eval_scenarios/network_override_redirect_test.ts
new file mode 100644
index 00000000..6a2539e1
--- /dev/null
+++ b/scripts/eval_scenarios/network_override_redirect_test.ts
@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert';
+
+import {URLPattern} from '../../src/third_party/cli.ts';
+import type {TestScenario} from '../eval_gemini.ts';
+
+export const scenario: TestScenario = {
+ serverArgs: ['--categoryNetworkMocks'],
+ prompt:
+ 'Open the website at <TEST_URL> and replace the script named my-third-party.js with the script hosted at https://www.examplescripts.agi/another.js.',
+ maxTurns: 4,
+ htmlRoute: {
+ path: '/network_override_redirect_test.html',
+ htmlContent: `
+ <h1>Upstream network mock test</h1>
+ <script src="/my-third-party.js"></script>
+ `,
+ },
+ expectations: result => {
+ const pageId = result.consumePageNavigation();
+ const overrideCall = result.remainingCalls.find(
+ call => call.name === 'mock_network',
+ );
+ assert.ok(
+ overrideCall,
+ `Expected mock_network after navigation, got: ${result.remainingCalls.map(call => call.name).join(', ')}`,
+ );
+ const navigation = result.calls.find(
+ call => call.name === 'new_page' || call.name === 'navigate_page',
+ );
+ assert.ok(typeof navigation?.args.url === 'string');
+ assert.ok(typeof overrideCall.args.route === 'string');
+ const scriptUrl = new URL('/my-third-party.js', navigation.args.url);
+ assert.ok(new URLPattern(overrideCall.args.route).test(scriptUrl.href));
+ assert.ok(
+ overrideCall.args.resourceType === undefined ||
+ overrideCall.args.resourceType === 'script',
+ );
+ assert.strictEqual(
+ overrideCall.args.upstream,
+ 'https://www.examplescripts.agi/another.js',
+ );
+ if (result.hasPageIdRouting) {
+ assert.strictEqual(overrideCall.args.pageId, pageId);
+ }
+ },
+};
diff --git a/skills/chrome-devtools-cli/SKILL.md b/skills/chrome-devtools-cli/SKILL.md
index e4d5aa2f..0e028ba7 100644
--- a/skills/chrome-devtools-cli/SKILL.md
+++ b/skills/chrome-devtools-cli/SKILL.md
@@ -134,6 +134,8 @@ chrome-devtools list_network_requests 1 --resourceTypes fetch # Filter requests
chrome-devtools list_network_requests 1 --includePreservedRequests true # Include preserved requests
chrome-devtools mock_network 1 --route 'https://example.com/app.js*' \
--body /tmp/app.js # Replace a response with a local file
+chrome-devtools mock_network 1 --route 'https://example.com/app.js*' \
+ --upstream https://example.com/dev.js # Use an upstream URL instead
chrome-devtools mock_network 1 # Inspect all mocks
chrome-devtools mock_network 1 --resourceType script # Inspect script mocks
chrome-devtools remove_network_mock 1 --route 'https://example.com/app.js*'
diff --git a/src/BUILD.gn b/src/BUILD.gn
index 44489852..3c2070e5 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -255,6 +255,7 @@ ts_library("mcp_lib") {
"utils/id.ts",
"utils/keyboard.ts",
"utils/logger.ts",
+ "utils/network.ts",
"utils/pagination.ts",
"utils/polyfill.ts",
"utils/raceWithSignal.ts",
diff --git a/src/McpContext.ts b/src/McpContext.ts
index 8a67d0cb..e6162204 100644
--- a/src/McpContext.ts
+++ b/src/McpContext.ts
@@ -58,7 +58,11 @@ import type {TraceResult} from './processors/PerformanceTrace.js';
import type {Logger} from './types.js';
import {McpWorker} from './McpWorker.js';
import {getTempFilePath, resolveCanonicalPath} from './utils/files.js';
-import {escapeForLog} from './utils/logger.js';
+import {escapeForLog, redactUrlForLogging} from './utils/logger.js';
+import {
+ fetchWithValidatedRedirects,
+ validateUrlNotBlocked,
+} from './utils/network.js';
import type {TaskQueue, TaskRunner} from './utils/TaskRunner.js';
import {isAllowedUrl} from './utils/url.js';
@@ -1215,70 +1219,23 @@ export class McpContext implements Context, BrowserlessContext {
return await this.#heapSnapshotManager.getDominatorsOf(filePath, nodeId);
}
- #validateUrlNotBlocked(url: URL): void {
- const blocklist = this.#config.resolved.blockedUrlPattern;
- if (!blocklist) {
- return;
- }
- for (const block of blocklist) {
- const pattern = new URLPattern(block);
- if (pattern.test(url)) {
- throw new Error(`Blocked by blocklist: ${url}`);
- }
- }
- }
-
- #validateUrlAllowed(url: URL): void {
- const allowlist = this.#config.resolved.allowedUrlPattern;
- if (!allowlist) {
- return;
- }
- for (const allow of allowlist) {
- const pattern = new URLPattern(allow);
- if (pattern.test(url)) {
- return;
- }
- }
- throw new Error(`Not allowed by allowlist: ${url}`);
- }
-
async #loadNetworkResource(url: URL): Promise<string> {
- const redirectStatuses = new Set([301, 302, 303, 307, 308]);
- const maxRedirects = 20;
- let currentUrl = url;
-
- for (let redirectCount = 0; ; redirectCount++) {
- this.#validateUrlNotBlocked(currentUrl);
- this.#validateUrlAllowed(currentUrl);
-
- const response = await fetch(currentUrl, {redirect: 'manual'});
- if (!redirectStatuses.has(response.status)) {
- if (!response.ok) {
- throw new Error(`Failed to load resource: ${currentUrl}`);
- }
- return await response.text();
- }
-
- const location = response.headers.get('location');
- if (!location) {
- throw new Error(`Failed to load resource: ${currentUrl}`);
- }
- if (redirectCount >= maxRedirects) {
- throw new Error(`Too many redirects loading resource: ${url}`);
- }
-
- await response.body?.cancel();
- currentUrl = new URL(location, currentUrl);
- if (currentUrl.protocol !== 'https:' && currentUrl.protocol !== 'http:') {
- throw new Error(`Unsupported protocol for: ${currentUrl}`);
- }
+ const response = await fetchWithValidatedRedirects(url, {
+ policy: this.#config.resolved,
+ });
+ if (!response.ok) {
+ throw new Error(
+ 'Failed to load resource: ' +
+ redactUrlForLogging(response.url || url.href),
+ );
}
+ return await response.text();
}
async loadResource(path: string): Promise<string> {
const url = new URL(path);
- this.#validateUrlNotBlocked(url);
+ validateUrlNotBlocked(url, this.#config.resolved.blockedUrlPattern);
switch (url.protocol) {
case 'https:':
diff --git a/src/McpPage.ts b/src/McpPage.ts
index 011abb40..08ab96d1 100644
--- a/src/McpPage.ts
+++ b/src/McpPage.ts
@@ -375,7 +375,10 @@ export class McpPage implements ContextPage {
return;
}
this.#pptrPage = page;
- this.#networkOverrideManager = new NetworkOverrideManager(page);
+ this.#networkOverrideManager = new NetworkOverrideManager(
+ page,
+ this.#config,
+ );
page.on('dialog', this.#dialogHandler);
this.#networkCollector = new NetworkCollector(page, {
maxNavigationSaved: this.#config.resolved.maxNavigationSaved,
diff --git a/src/NetworkOverrideManager.ts b/src/NetworkOverrideManager.ts
index 6d874534..0db2b1b1 100644
--- a/src/NetworkOverrideManager.ts
+++ b/src/NetworkOverrideManager.ts
@@ -7,13 +7,20 @@
import path from 'node:path';
import {URLPattern} from './third_party/cli.js';
+import type {ReadonlyServerConfig} from './config/ServerConfig.js';
+import {
+ fetchWithValidatedRedirects,
+ getRedirectHeaders,
+ validateNetworkUrl,
+} from './utils/network.js';
+
import {
type HTTPRequest,
Mutex,
type Page,
type ResourceType,
} from './third_party/index.js';
-import {logger} from './utils/logger.js';
+import {logger, redactUrlForLogging} from './utils/logger.js';
interface BaseNetworkOverride {
urlPattern: string;
@@ -25,6 +32,11 @@ export interface NetworkMockFilter {
resourceType?: ResourceType;
}
+export interface UpstreamNetworkOverrideInput extends NetworkMockFilter {
+ kind: 'upstream';
+ upstreamUrl: string;
+}
+
export interface FileNetworkOverrideInput extends NetworkMockFilter {
kind: 'file';
responseFilePath: string;
@@ -32,7 +44,8 @@ export interface FileNetworkOverrideInput extends NetworkMockFilter {
loadResponseFile: () => Promise<Uint8Array<ArrayBufferLike>>;
}
-export type NetworkMockInput = FileNetworkOverrideInput;
+export type NetworkMockInput =
+ UpstreamNetworkOverrideInput | FileNetworkOverrideInput;
interface NetworkOverrideBase extends BaseNetworkOverride {
id: number;
@@ -44,18 +57,28 @@ interface NetworkOverrideBase extends BaseNetworkOverride {
};
}
+export interface UpstreamNetworkOverride extends NetworkOverrideBase {
+ kind: 'upstream';
+ upstreamUrl: string;
+}
+
export interface FileNetworkOverride extends NetworkOverrideBase {
kind: 'file';
responseFilePath: string;
contentType: string;
}
-export type NetworkOverride = FileNetworkOverride;
+export type NetworkOverride = UpstreamNetworkOverride | FileNetworkOverride;
interface StoredNetworkOverrideBase extends NetworkOverrideBase {
matcher: URLPattern;
}
+interface StoredUpstreamNetworkOverride extends StoredNetworkOverrideBase {
+ kind: 'upstream';
+ upstreamUrl: string;
+}
+
interface StoredFileNetworkOverride extends StoredNetworkOverrideBase {
kind: 'file';
responseFilePath: string;
@@ -63,7 +86,8 @@ interface StoredFileNetworkOverride extends StoredNetworkOverrideBase {
loadResponseFile: () => Promise<Uint8Array<ArrayBufferLike>>;
}
-type StoredNetworkOverride = StoredFileNetworkOverride;
+type StoredNetworkOverride =
+ StoredUpstreamNetworkOverride | StoredFileNetworkOverride;
const DEFAULT_URL_PATTERN = '*://*:*/*';
@@ -100,6 +124,13 @@ function toNetworkOverride(override: StoredNetworkOverride): NetworkOverride {
resourceType: override.resourceType,
diagnostics: {...override.diagnostics},
};
+ if (override.kind === 'upstream') {
+ return {
+ ...base,
+ kind: override.kind,
+ upstreamUrl: override.upstreamUrl,
+ };
+ }
return {
...base,
kind: override.kind,
@@ -133,7 +164,10 @@ export class NetworkOverrideManager {
return this.#handleRequest(request);
};
- constructor(page: Page) {
+ constructor(
+ page: Page,
+ private readonly config: ReadonlyServerConfig,
+ ) {
this.#page = page;
}
@@ -181,6 +215,14 @@ export class NetworkOverrideManager {
matcher: new URLPattern(urlPattern),
diagnostics: {hits: 0, errors: 0, navigations: 0},
};
+ if (input.kind === 'upstream') {
+ validateNetworkUrl(new URL(input.upstreamUrl), this.config.resolved);
+ return {
+ ...base,
+ kind: input.kind,
+ upstreamUrl: input.upstreamUrl,
+ };
+ }
await input.loadResponseFile();
return {
@@ -349,6 +391,11 @@ export class NetworkOverrideManager {
override.diagnostics.hits++;
try {
+ if (override.kind === 'upstream') {
+ await this.#fulfillUpstream(request, override.upstreamUrl);
+ return;
+ }
+
const body = await override.loadResponseFile();
await request.respond({
status: 200,
@@ -359,22 +406,70 @@ export class NetworkOverrideManager {
body,
});
} catch (error) {
- const message =
+ const message: string =
typeof error === 'object' &&
error !== null &&
'message' in error &&
typeof error.message === 'string'
? error.message
: String(error);
- const source = override.responseFilePath;
+ const source =
+ override.kind === 'file'
+ ? override.responseFilePath
+ : redactUrlForLogging(override.upstreamUrl);
+ const detail =
+ override.kind === 'file'
+ ? message
+ : message.replace(/https?:\/\/[^\s"'<>]+/gi, url =>
+ redactUrlForLogging(url),
+ );
override.diagnostics.errors++;
override.diagnostics.lastError =
- 'Failed to load ' + source + ': ' + message;
+ 'Failed to load ' + source + ': ' + detail;
logger?.('Failed to apply network mock ' + override.id);
await this.#abortRequest(request);
}
}
+ async #fulfillUpstream(
+ request: HTTPRequest,
+ upstreamUrl: string,
+ ): Promise<void> {
+ const method = request.method();
+ if (method !== 'GET' && method !== 'HEAD') {
+ throw new Error('Upstream mocks only support GET and HEAD requests.');
+ }
+ const headers = getRedirectHeaders(
+ new URL(request.url()),
+ new URL(upstreamUrl),
+ request.headers(),
+ );
+ const response = await fetchWithValidatedRedirects(new URL(upstreamUrl), {
+ policy: this.config.resolved,
+ method,
+ headers,
+ });
+ const responseHeaders: Record<string, string | string[]> = {};
+ for (const [name, value] of response.headers) {
+ if (
+ name !== 'content-encoding' &&
+ name !== 'content-length' &&
+ name !== 'set-cookie'
+ ) {
+ responseHeaders[name] = value;
+ }
+ }
+ const cookies = response.headers.getSetCookie();
+ if (cookies.length > 0) {
+ responseHeaders['set-cookie'] = cookies;
+ }
+ await request.respond({
+ status: response.status,
+ headers: responseHeaders,
+ body: new Uint8Array(await response.arrayBuffer()),
+ });
+ }
+
async #continueRequest(request: HTTPRequest): Promise<void> {
if (request.isInterceptResolutionHandled()) {
return;
diff --git a/src/config/cli-options.ts b/src/config/cli-options.ts
index 95ada697..20f92265 100644
--- a/src/config/cli-options.ts
+++ b/src/config/cli-options.ts
@@ -1479,7 +1479,7 @@ export const commands: Commands = {
},
mock_network: {
description:
- 'Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use remove_network_mock to remove mocks. (requires flag: --categoryNetworkMocks=true)',
+ 'Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body or upstream updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Upstream responses use server-side GET/HEAD fetches. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use remove_network_mock to remove mocks. (requires flag: --categoryNetworkMocks=true)',
category: 'Network mocks',
args: {
pageId: {
@@ -1529,7 +1529,15 @@ export const commands: Commands = {
name: 'body',
type: 'string',
description:
- 'Local response body file, revalidated and reread for every request. Content-Type follows its extension.',
+ 'Local response body file, revalidated and reread for every request. Content-Type follows its extension. Mutually exclusive with upstream.',
+ required: false,
+ positional: false,
+ },
+ upstream: {
+ name: 'upstream',
+ type: 'string',
+ description:
+ 'Absolute HTTP(S) replacement URL for GET/HEAD requests. URL allowlists and blocklists apply to this URL and every redirect. Mutually exclusive with body.',
required: false,
positional: false,
},
diff --git a/src/formatters/NetworkOverridesFormatter.ts b/src/formatters/NetworkOverridesFormatter.ts
index 1eab724f..ba4a7351 100644
--- a/src/formatters/NetworkOverridesFormatter.ts
+++ b/src/formatters/NetworkOverridesFormatter.ts
@@ -30,7 +30,9 @@ export class NetworkOverridesFormatter {
const lines = [warning];
for (const override of overrides) {
const source =
- override.responseFilePath + ' (' + override.contentType + ')';
+ override.kind === 'file'
+ ? override.responseFilePath + ' (' + override.contentType + ')'
+ : override.upstreamUrl;
const resourceType = override.resourceType
? ' [' + override.resourceType + ']'
: '';
diff --git a/src/telemetry/tool_call_metrics.json b/src/telemetry/tool_call_metrics.json
index 5e7ecd9c..5863cf8e 100644
--- a/src/telemetry/tool_call_metrics.json
+++ b/src/telemetry/tool_call_metrics.json
@@ -1428,6 +1428,10 @@
{
"name": "body_length",
"argType": "number"
+ },
+ {
+ "name": "upstream_length",
+ "argType": "number"
}
]
},
diff --git a/src/third_party/zod.ts b/src/third_party/zod.ts
index c985f086..d0045868 100644
--- a/src/third_party/zod.ts
+++ b/src/third_party/zod.ts
@@ -19,5 +19,6 @@ export {
string,
toJSONSchema,
unknown,
+ url,
ZodError,
} from 'zod';
diff --git a/src/tools/network.ts b/src/tools/network.ts
index daa5d593..e1b60e5d 100644
--- a/src/tools/network.ts
+++ b/src/tools/network.ts
@@ -204,20 +204,34 @@ const mockNetworkSchema = zod
.min(1)
.optional()
.describe(
- 'Local response body file, revalidated and reread for every request. Content-Type follows its extension.',
+ 'Local response body file, revalidated and reread for every request. Content-Type follows its extension. Mutually exclusive with upstream.',
),
- });
+ upstream: zod
+ .url({protocol: /^https?$/})
+ .optional()
+ .describe(
+ 'Absolute HTTP(S) replacement URL for GET/HEAD requests. URL allowlists and blocklists apply to this URL and every redirect. Mutually exclusive with body.',
+ ),
+ })
+ .refine(
+ params => params.body === undefined || params.upstream === undefined,
+ {
+ message: 'body and upstream are mutually exclusive.',
+ path: ['upstream'],
+ },
+ );
export const mockNetwork: PageToolFactory = definePageTool(() => ({
name: 'mock_network',
description:
'Inspect or update network mocks for a page. With no actions, list mocks ' +
'matching the supplied filters, or all mocks when no filters are given. ' +
- 'Providing body updates the exact route/resourceType pair. ' +
+ 'Providing body or upstream updates the exact route/resourceType pair. ' +
'An omitted route matches any URL. Other mocks are preserved. ' +
'The most recently updated matching mock wins and persists across ' +
'navigations. Configure before navigating or reloading; inspection shows ' +
- 'hit counts and replacement errors. Changes are rejected during ' +
+ 'hit counts and replacement errors. Upstream responses use server-side ' +
+ 'GET/HEAD fetches. Changes are rejected during ' +
'a performance trace. Mocks disable the page HTTP cache and intercept ' +
'every request, affecting measurements. Service workers can bypass mocks. ' +
'Use remove_network_mock to remove mocks.',
@@ -236,7 +250,9 @@ export const mockNetwork: PageToolFactory = definePageTool(() => ({
resourceType: params.resourceType,
};
let input: NetworkMockInput | undefined;
- if (params.body !== undefined) {
+ if (params.upstream !== undefined) {
+ input = {...filter, kind: 'upstream', upstreamUrl: params.upstream};
+ } else if (params.body !== undefined) {
const responseFilePath = params.body;
input = {
...filter,
diff --git a/src/utils/network.ts b/src/utils/network.ts
new file mode 100644
index 00000000..ae7828fc
--- /dev/null
+++ b/src/utils/network.ts
@@ -0,0 +1,113 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {URLPattern} from '../third_party/cli.js';
+import {redactUrlForLogging} from './logger.js';
+
+interface UrlAccessPolicy {
+ blockedUrlPattern?: readonly string[];
+ allowedUrlPattern?: readonly string[];
+}
+
+const CROSS_ORIGIN_REDIRECT_HEADERS = new Set([
+ 'accept',
+ 'accept-language',
+ 'cache-control',
+ 'origin',
+ 'pragma',
+ 'range',
+ 'user-agent',
+]);
+
+export function getRedirectHeaders(
+ sourceUrl: URL,
+ targetUrl: URL,
+ originalHeaders: Record<string, string>,
+): Record<string, string> {
+ const sameOrigin = sourceUrl.origin === targetUrl.origin;
+ const headers: Record<string, string> = {};
+ for (const [name, value] of Object.entries(originalHeaders)) {
+ const lowerName = name.toLowerCase();
+ if (lowerName === 'accept-encoding') {
+ continue;
+ }
+ if (sameOrigin || CROSS_ORIGIN_REDIRECT_HEADERS.has(lowerName)) {
+ headers[name] = value;
+ }
+ }
+ return headers;
+}
+
+export function validateUrlNotBlocked(
+ url: URL,
+ blocklist?: readonly string[],
+): void {
+ for (const block of blocklist ?? []) {
+ if (new URLPattern(block).test(url)) {
+ throw new Error('Blocked by blocklist: ' + redactUrlForLogging(url.href));
+ }
+ }
+}
+
+export function validateNetworkUrl(url: URL, policy: UrlAccessPolicy): void {
+ if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+ throw new Error('Unsupported URL protocol: ' + url.protocol);
+ }
+ validateUrlNotBlocked(url, policy.blockedUrlPattern);
+ if (
+ policy.allowedUrlPattern &&
+ !policy.allowedUrlPattern.some(allow => new URLPattern(allow).test(url))
+ ) {
+ throw new Error(
+ 'Not allowed by allowlist: ' + redactUrlForLogging(url.href),
+ );
+ }
+}
+
+export async function fetchWithValidatedRedirects(
+ url: URL,
+ options: {
+ policy: UrlAccessPolicy;
+ method?: 'GET' | 'HEAD';
+ headers?: Record<string, string>;
+ },
+): Promise<Response> {
+ const redirectStatuses = new Set([301, 302, 303, 307, 308]);
+ const maxRedirects = 20;
+ let currentUrl = url;
+ let headers = options.headers
+ ? Object.fromEntries(new Headers(options.headers))
+ : undefined;
+ for (let redirectCount = 0; ; redirectCount++) {
+ validateNetworkUrl(currentUrl, options.policy);
+ const response = await fetch(currentUrl, {
+ redirect: 'manual',
+ ...(options.method ? {method: options.method} : {}),
+ ...(headers ? {headers} : {}),
+ });
+ if (!redirectStatuses.has(response.status)) {
+ return response;
+ }
+ const location = response.headers.get('location');
+ await response.body?.cancel();
+ if (!location) {
+ throw new Error(
+ 'Redirect has no Location header: ' +
+ redactUrlForLogging(currentUrl.href),
+ );
+ }
+ if (redirectCount >= maxRedirects) {
+ throw new Error(
+ 'Too many redirects loading resource: ' + redactUrlForLogging(url.href),
+ );
+ }
+ const nextUrl = new URL(location, currentUrl);
+ if (headers) {
+ headers = getRedirectHeaders(currentUrl, nextUrl, headers);
+ }
+ currentUrl = nextUrl;
+ }
+}
diff --git a/tests/BUILD.gn b/tests/BUILD.gn
index 1af6b478..efa6e1ae 100644
--- a/tests/BUILD.gn
+++ b/tests/BUILD.gn
@@ -114,6 +114,7 @@ ts_library("tests") {
"utils/id.test.ts",
"utils/keyboard.test.ts",
"utils/logger.test.ts",
+ "utils/network.test.ts",
"utils/pagination.test.ts",
"utils/raceWithSignal.test.ts",
"utils/resourceType.test.ts",
diff --git a/tests/McpContext.test.ts b/tests/McpContext.test.ts
index 3acf51e7..2f91889d 100644
--- a/tests/McpContext.test.ts
+++ b/tests/McpContext.test.ts
@@ -1347,6 +1347,22 @@ describe('McpContext', () => {
describe('loadResource', () => {
describe('file protocol', () => {
+ it('rejects blocked file URLs before accessing the filesystem', async () => {
+ const context = await createMockContext({
+ config: createMockServerConfig({blockedUrlPattern: ['file:///*']}),
+ });
+ const validatePath = sinon.stub(context, 'validatePath');
+ try {
+ await assert.rejects(
+ context.loadResource('file:///tmp/blocked.map'),
+ /Blocked by blocklist/,
+ );
+ sinon.assert.notCalled(validatePath);
+ } finally {
+ context.dispose();
+ }
+ });
+
it('calls validatePath', async () => {
using testFile = createTempFile(
'test content',
@@ -1380,6 +1396,27 @@ describe('McpContext', () => {
});
describe('https protocol', () => {
+ it('rejects non-success responses and redacts the resource URL', async () => {
+ const context = await createMockContext();
+ const response = new Response('not found', {status: 404});
+ const text = sinon.spy(response, 'text');
+ sinon.stub(globalThis, 'fetch').resolves(response);
+ try {
+ await assert.rejects(
+ context.loadResource(
+ 'https://example.com/missing.map?token=secret',
+ ),
+ {
+ message:
+ 'Failed to load resource: https://example.com/missing.map?REDACTED',
+ },
+ );
+ sinon.assert.notCalled(text);
+ } finally {
+ context.dispose();
+ }
+ });
+
async function createNetworkPolicyContext(options: {
allowlist?: string[];
blocklist?: string[];
diff --git a/tests/NetworkOverrideManager.test.ts b/tests/NetworkOverrideManager.test.ts
index f4f8667c..1a58d946 100644
--- a/tests/NetworkOverrideManager.test.ts
+++ b/tests/NetworkOverrideManager.test.ts
@@ -11,13 +11,174 @@ import sinon from 'sinon';
import {NetworkOverrideManager} from '../src/NetworkOverrideManager.js';
import {CdpFrame} from '../src/third_party/index.js';
-import {createMockHTTPRequest, createMockPuppeteerPage} from './mocks.js';
+import {
+ createMockHTTPRequest,
+ createMockPuppeteerPage,
+ createMockServerConfig,
+} from './mocks.js';
import {NetworkOverridesFormatter} from '../src/formatters/NetworkOverridesFormatter.js';
describe('NetworkOverrideManager', () => {
+ it('retains existing rules when a replacement URL is blocked', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig({
+ blockedUrlPattern: ['https://blocked.example/*'],
+ }),
+ );
+ const previous = await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://example.com/replacement.js',
+ });
+ await assert.rejects(
+ manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://blocked.example/replacement.js',
+ }),
+ /Blocked by blocklist/,
+ );
+ assert.deepEqual(manager.list(), [previous]);
+ sinon.assert.calledOnceWithExactly(pptrPage.setRequestInterception, true);
+ await manager.dispose();
+ });
+ it('blocks cross-origin redirects to a host on blocked-url-pattern before contacting it', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig({
+ blockedUrlPattern: ['https://blocked.example/*'],
+ }),
+ );
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://allowed.example/replacement.js',
+ });
+ const fetch = sinon.stub(globalThis, 'fetch').resolves(
+ new Response('upstream', {
+ status: 302,
+ headers: {location: 'https://blocked.example/secret'},
+ }),
+ );
+ const request = createMockHTTPRequest();
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledOnceWithExactly(
+ fetch,
+ new URL('https://allowed.example/replacement.js'),
+ {redirect: 'manual', method: 'GET', headers: {}},
+ );
+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');
+ sinon.assert.notCalled(request.respond);
+ assert.match(
+ manager.list()[0]?.diagnostics.lastError ?? '',
+ /Blocked by blocklist: https:\/\/blocked.example\/secret/,
+ );
+ await manager.dispose();
+ });
+
+ it('uses updated access policies for already configured overrides', async () => {
+ const config = createMockServerConfig();
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(pptrPage, config);
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://example.com/replacement.js',
+ });
+ config.commit(
+ createMockServerConfig({
+ blockedUrlPattern: ['https://example.com/replacement.js'],
+ }),
+ );
+ const request = createMockHTTPRequest();
+ const fetch = sinon.stub(globalThis, 'fetch');
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');
+ sinon.assert.notCalled(request.continue);
+ sinon.assert.notCalled(fetch);
+ await manager.dispose();
+ });
+
+ it('fulfills an allowed redirect chain with the final response', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://cdn.example/start',
+ });
+ const fetch = sinon.stub(globalThis, 'fetch');
+ fetch
+ .onFirstCall()
+ .resolves(
+ new Response(null, {status: 302, headers: {location: '/final'}}),
+ );
+ fetch.onSecondCall().resolves(
+ new Response('replacement', {
+ status: 200,
+ headers: {'content-type': 'text/javascript'},
+ }),
+ );
+ const request = createMockHTTPRequest();
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledWithExactly(
+ fetch.secondCall,
+ new URL('https://cdn.example/final'),
+ {redirect: 'manual', method: 'GET', headers: {}},
+ );
+ sinon.assert.calledOnceWithExactly(request.respond, {
+ status: 200,
+ headers: {'content-type': 'text/javascript'},
+ body: new TextEncoder().encode('replacement'),
+ });
+ sinon.assert.notCalled(request.abort);
+ await manager.dispose();
+ });
+
+ it('redacts userinfo and query strings in upstream replacement errors', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
+ const upstream = 'https://user:[email protected]/app.js?token=secret';
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: 'https://example.com/app.js',
+ upstreamUrl: upstream,
+ });
+ const fetch = sinon
+ .stub(globalThis, 'fetch')
+ .rejects(new Error('Failed to fetch ' + upstream));
+ const request = createMockHTTPRequest();
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledOnceWithExactly(fetch, new URL(upstream), {
+ redirect: 'manual',
+ method: 'GET',
+ headers: {},
+ });
+ assert.equal(
+ manager.list()[0]?.diagnostics.lastError,
+ 'Failed to load https://example.com/app.js?REDACTED: ' +
+ 'Failed to fetch https://example.com/app.js?REDACTED',
+ );
+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');
+ sinon.assert.notCalled(request.respond);
+ await manager.dispose();
+ });
+
it('counts only matching requests and returns independent diagnostic snapshots', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const initial = await manager.mock({
kind: 'file',
urlPattern: '*://*:*/*app.js',
@@ -49,7 +210,10 @@ describe('NetworkOverrideManager', () => {
it('warns after a main-frame document request but not a hash change or subframe navigation', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
await manager.mock({
kind: 'file',
urlPattern: '*://*:*/*missing.js',
@@ -99,7 +263,10 @@ describe('NetworkOverrideManager', () => {
]) {
it('matches query strings using URLPattern: ' + route, async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
await manager.mock({
kind: 'file',
urlPattern: route,
@@ -130,7 +297,10 @@ describe('NetworkOverrideManager', () => {
it('reports the local file and error when a previously readable file fails', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const loadResponseFile = sinon
.stub()
.onFirstCall()
@@ -161,7 +331,10 @@ describe('NetworkOverrideManager', () => {
});
it('updates one rule without replacing unrelated rules or restarting interception', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const unrelated = await manager.mock({
kind: 'file',
urlPattern: '*://*:*/*old.js',
@@ -189,7 +362,10 @@ describe('NetworkOverrideManager', () => {
it('validates a local file before updating an existing rule', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const previous = await manager.mock({
kind: 'file',
urlPattern: '*://*:*/*app.js',
@@ -214,7 +390,10 @@ describe('NetworkOverrideManager', () => {
it('infers local file content types after validating the file', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const loadResponseFile = sinon.stub().resolves(new Uint8Array());
assert.deepEqual(
await manager.mock({
@@ -239,7 +418,10 @@ describe('NetworkOverrideManager', () => {
it('rolls back the rule set when activation fails', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
pptrPage.setRequestInterception
.withArgs(true)
.rejects(new Error('Target closed'));
@@ -263,7 +445,10 @@ describe('NetworkOverrideManager', () => {
it('retains the rules when clearing interception fails', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const previous = await manager.mock({
kind: 'file',
urlPattern: '*://*:*/*app.js',
@@ -282,7 +467,10 @@ describe('NetworkOverrideManager', () => {
it('filters and removes exact routes and resource types while preserving other mocks', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const script = await manager.mock({
urlPattern: '*://*:*/*app.js',
resourceType: 'script',
@@ -330,7 +518,10 @@ describe('NetworkOverrideManager', () => {
it('restores interception and retains mocks when restoring the cache fails during removal', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const previous = await manager.mock({
urlPattern: '*://*:*/*app.js',
kind: 'file',
@@ -366,7 +557,10 @@ describe('NetworkOverrideManager', () => {
it('uses all URLs when route is omitted and updates only the exact filter pair', async () => {
const pptrPage = createMockPuppeteerPage();
- const manager = new NetworkOverrideManager(pptrPage);
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
const scripts = await manager.mock({
resourceType: 'script',
kind: 'file',
@@ -405,4 +599,170 @@ describe('NetworkOverrideManager', () => {
assert.equal(manager.list()[0]?.diagnostics.hits, 0);
await manager.dispose();
});
+
+ it('checks same-origin upstream redirects against blocked-url-pattern before contacting the target', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig({
+ blockedUrlPattern: ['https://blocked.example/*'],
+ }),
+ );
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://example.com/start',
+ });
+ const fetch = sinon.stub(globalThis, 'fetch').resolves(
+ new Response(null, {
+ status: 302,
+ headers: {location: 'https://blocked.example/private'},
+ }),
+ );
+ const request = createMockHTTPRequest();
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledOnceWithExactly(
+ fetch,
+ new URL('https://example.com/start'),
+ {redirect: 'manual', method: 'GET', headers: {}},
+ );
+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');
+ sinon.assert.notCalled(request.continue);
+ sinon.assert.notCalled(request.respond);
+ await manager.dispose();
+ });
+
+ for (const {upstream, headers} of [
+ {
+ upstream: 'https://example.com/replacement.js',
+ headers: {accept: 'text/javascript', authorization: 'secret'},
+ },
+ {
+ upstream: 'https://cdn.example/replacement.js',
+ headers: {accept: 'text/javascript'},
+ },
+ ]) {
+ it('does not forward Accept-Encoding to ' + upstream, async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: upstream,
+ });
+ const fetch = sinon
+ .stub(globalThis, 'fetch')
+ .resolves(new Response('js'));
+ const request = createMockHTTPRequest();
+ request.headers.returns(
+ Object.freeze({
+ Accept: 'text/javascript',
+ 'Accept-Encoding': 'gzip, deflate, br, zstd',
+ Authorization: 'secret',
+ }),
+ );
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledOnceWithExactly(fetch, new URL(upstream), {
+ redirect: 'manual',
+ method: 'GET',
+ headers,
+ });
+ sinon.assert.notCalled(request.abort);
+ await manager.dispose();
+ });
+ }
+
+ it('preserves multiple Set-Cookie headers in upstream responses', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://example.com/replacement.js',
+ });
+ const cookies = [
+ 'session=abc; Path=/; HttpOnly',
+ 'theme=dark; Expires=Wed, 21 Oct 2037 07:28:00 GMT; Path=/',
+ ];
+ const headers = new Headers({'content-type': 'text/javascript'});
+ for (const cookie of cookies) {
+ headers.append('set-cookie', cookie);
+ }
+ sinon.stub(globalThis, 'fetch').resolves(new Response('js', {headers}));
+ const request = createMockHTTPRequest();
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledOnceWithExactly(request.respond, {
+ status: 200,
+ headers: {
+ 'content-type': 'text/javascript',
+ 'set-cookie': cookies,
+ },
+ body: new TextEncoder().encode('js'),
+ });
+ sinon.assert.notCalled(request.abort);
+ await manager.dispose();
+ });
+
+ it('fulfills decoded upstream bodies without stale compression headers', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://example.com/replacement.js',
+ });
+ sinon.stub(globalThis, 'fetch').resolves(
+ new Response('decoded', {
+ headers: {
+ 'content-encoding': 'gzip',
+ 'content-length': '123',
+ 'content-type': 'text/javascript',
+ },
+ }),
+ );
+ const request = createMockHTTPRequest();
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.calledOnceWithExactly(request.respond, {
+ status: 200,
+ headers: {
+ 'content-type': 'text/javascript',
+ },
+ body: new TextEncoder().encode('decoded'),
+ });
+ sinon.assert.notCalled(request.continue);
+ await manager.dispose();
+ });
+
+ it('rejects unsupported upstream methods before fetching', async () => {
+ const pptrPage = createMockPuppeteerPage();
+ const manager = new NetworkOverrideManager(
+ pptrPage,
+ createMockServerConfig(),
+ );
+ await manager.mock({
+ kind: 'upstream',
+ urlPattern: '*://*:*/*app.js',
+ upstreamUrl: 'https://example.com/replacement.js',
+ });
+ const fetch = sinon.stub(globalThis, 'fetch');
+ const request = createMockHTTPRequest();
+ request.method.returns('POST');
+ await pptrPage.on.firstCall.args[1](request);
+ sinon.assert.notCalled(fetch);
+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');
+ assert.match(
+ manager.list()[0]?.diagnostics.lastError ?? '',
+ /only support GET and HEAD/,
+ );
+ await manager.dispose();
+ });
});
diff --git a/tests/network_overrides.test.ts b/tests/network_overrides.test.ts
index 95dc9e83..acd498ae 100644
--- a/tests/network_overrides.test.ts
+++ b/tests/network_overrides.test.ts
@@ -6,9 +6,11 @@
import assert from 'node:assert';
import {rm, writeFile} from 'node:fs/promises';
+import type {IncomingHttpHeaders} from 'node:http';
import {join} from 'node:path';
import {describe, it} from 'node:test';
+import {NetworkOverridesFormatter} from '../src/formatters/NetworkOverridesFormatter.js';
import {mockNetwork, removeNetworkMock} from '../src/tools/network.js';
import {serverHooks} from './server.js';
import {createTempDir, html, withMcpContext} from './utils.js';
@@ -29,6 +31,160 @@ describe('network overrides integration', () => {
});
}
+ it('redirects matching requests across reloads until removed', async () => {
+ let originalRequests = 0;
+ let replacementRequests = 0;
+ addJavaScriptRoute(
+ '/redirect-original.js?v=42',
+ "document.documentElement.dataset.overrideSource = 'original';",
+ () => {
+ originalRequests++;
+ },
+ );
+ addJavaScriptRoute(
+ '/redirect-replacement.js',
+ "document.documentElement.dataset.overrideSource = 'replacement';",
+ () => {
+ replacementRequests++;
+ },
+ );
+ server.addHtmlRoute(
+ '/redirect-page',
+ html`<script src="${server.getRoute('/redirect-original.js?v=42')}"></script>`,
+ );
+
+ await withMcpContext(async (response, context, args) => {
+ const mcpPage = context.getSelectedMcpPage();
+ const page = mcpPage.pptrPage;
+ await mockNetwork(args).handler(
+ {
+ params: {
+ route: server.baseUrl + '/redirect-original.js*',
+ upstream: server.getRoute('/redirect-replacement.js'),
+ },
+ page: mcpPage,
+ },
+ response,
+ context,
+ );
+ assert.deepStrictEqual(response.responseLines, [
+ 'Network mock configured. Reload or navigate the page to apply it.',
+ new NetworkOverridesFormatter(mcpPage.listNetworkMocks()).toString(),
+ ]);
+
+ await page.goto(server.getRoute('/redirect-page'));
+ assert.strictEqual(
+ await page.evaluate(
+ () => document.documentElement.dataset.overrideSource,
+ ),
+ 'replacement',
+ );
+
+ await page.reload();
+ assert.strictEqual(
+ await page.evaluate(
+ () => document.documentElement.dataset.overrideSource,
+ ),
+ 'replacement',
+ );
+ assert.strictEqual(originalRequests, 0);
+ assert.strictEqual(replacementRequests, 2);
+
+ response.resetResponseLineForTesting();
+ await removeNetworkMock(args).handler(
+ {params: {}, page: mcpPage},
+ response,
+ context,
+ );
+ await page.reload();
+ assert.strictEqual(
+ await page.evaluate(
+ () => document.documentElement.dataset.overrideSource,
+ ),
+ 'original',
+ );
+ assert.strictEqual(originalRequests, 1);
+ });
+ });
+
+ it('sanitizes cross-origin headers while preserving Origin', async t => {
+ let replacementHeaders: IncomingHttpHeaders = {};
+ server.addHtmlRoute('/cross-origin-setup', html`<main>Setup</main>`);
+ addJavaScriptRoute(
+ '/cross-origin-original.js',
+ "document.documentElement.dataset.overrideSource = 'original';",
+ );
+ server.addHtmlRoute(
+ '/cross-origin-page',
+ html`<script src="${server.getRoute('/cross-origin-original.js')}"></script>`,
+ );
+ server.addRoute('/cross-origin-replacement.js', (req, res) => {
+ replacementHeaders = req.headers;
+ res.setHeader('Content-Type', 'application/javascript; charset=utf-8');
+ res.statusCode = 200;
+ res.end(
+ "document.documentElement.dataset.overrideSource = 'replacement';",
+ );
+ });
+
+ await withMcpContext(async (response, context, args) => {
+ const mcpPage = context.getSelectedMcpPage();
+ const page = mcpPage.pptrPage;
+ const browserContext = page.browserContext();
+ t.after(async () => {
+ await browserContext.deleteMatchingCookies({
+ name: 'override_secret',
+ domain: new URL(server.baseUrl).hostname,
+ });
+ });
+ await page.goto(server.getRoute('/cross-origin-setup'));
+ await page.evaluate(() => {
+ document.cookie = 'override_secret=cookie; path=/';
+ });
+ await page.setExtraHTTPHeaders({
+ Authorization: 'Bearer secret',
+ Origin: server.baseUrl,
+ 'X-Api-Key': 'secret',
+ });
+
+ const replacementUrl =
+ server.baseUrl.replace('127.0.0.1', 'localhost') +
+ '/cross-origin-replacement.js';
+ await mockNetwork(args).handler(
+ {
+ params: {
+ route: server.getRoute('/cross-origin-original.js'),
+ resourceType: 'script',
+ upstream: replacementUrl,
+ },
+ page: mcpPage,
+ },
+ response,
+ context,
+ );
+
+ await page.goto(server.getRoute('/cross-origin-page'));
+ assert.strictEqual(
+ await page.evaluate(
+ () => document.documentElement.dataset.overrideSource,
+ ),
+ 'replacement',
+ );
+ assert.strictEqual(replacementHeaders.origin, server.baseUrl);
+ assert.strictEqual(replacementHeaders.authorization, undefined);
+ assert.strictEqual(replacementHeaders.cookie, undefined);
+ assert.strictEqual(replacementHeaders.referer, undefined);
+ assert.strictEqual(replacementHeaders['x-api-key'], undefined);
+
+ response.resetResponseLineForTesting();
+ await removeNetworkMock(args).handler(
+ {params: {}, page: mcpPage},
+ response,
+ context,
+ );
+ });
+ });
+
it('serves the latest contents of a local file when the URL has a query string', async () => {
using directory = createTempDir('network-override-');
const filePath = join(directory.path, 'local-override.js');
diff --git a/tests/tools/network.test.ts b/tests/tools/network.test.ts
index c10f2083..4e9e1f95 100644
--- a/tests/tools/network.test.ts
+++ b/tests/tools/network.test.ts
@@ -10,6 +10,7 @@ import {describe, it} from 'node:test';
import sinon from 'sinon';
+import type {NetworkOverride} from '../../src/NetworkOverrideManager.js';
import {NetworkOverridesFormatter} from '../../src/formatters/NetworkOverridesFormatter.js';
import {
mockNetwork,
@@ -45,7 +46,9 @@ describe('network', () => {
});
for (const params of [
+ {body: './script.js', upstream: 'https://example.com/script.js'},
{body: ' '},
+ {upstream: 'file:///tmp/script.js'},
{route: '/app.js*', body: './app.js'},
{route: '*app.js*', body: './app.js'},
{route: 'https://example.com/:file', body: './app.js'},
@@ -68,6 +71,67 @@ describe('network', () => {
);
}
+ it('updates an upstream mock with the exact supplied actions', async () => {
+ const {page, context, response, args} = createHandlerMocks();
+ const override = {
+ id: 7,
+ kind: 'upstream',
+ urlPattern: 'https://example.com/script.js*',
+ resourceType: 'script',
+ upstreamUrl: 'https://example.com/replacement.js',
+ diagnostics: {hits: 0, errors: 0, navigations: 0},
+ } satisfies NetworkOverride;
+ page.mockNetwork.resolves(override);
+ await mockNetwork(args).handler(
+ {
+ params: {
+ route: override.urlPattern,
+ resourceType: 'script',
+ upstream: override.upstreamUrl,
+ },
+ page,
+ },
+ response,
+ context,
+ );
+ sinon.assert.calledOnceWithExactly(page.mockNetwork, {
+ kind: 'upstream',
+ urlPattern: override.urlPattern,
+ resourceType: 'script',
+ upstreamUrl: override.upstreamUrl,
+ });
+ sinon.assert.notCalled(page.listNetworkMocks);
+ sinon.assert.notCalled(context.validatePath);
+ sinon.assert.calledWithExactly(
+ response.appendResponseLine.firstCall,
+ 'Network mock configured. Reload or navigate the page to apply it.',
+ );
+ sinon.assert.calledWithExactly(
+ response.appendResponseLine.secondCall,
+ new NetworkOverridesFormatter([override]).toString(),
+ );
+ });
+
+ it('propagates upstream policy failures without reporting success', async () => {
+ const {page, context, response, args} = createHandlerMocks();
+ page.mockNetwork.rejects(new Error('Blocked by blocklist'));
+ await assert.rejects(
+ mockNetwork(args).handler(
+ {params: {upstream: 'https://blocked.example/script.js'}, page},
+ response,
+ context,
+ ),
+ /Blocked by blocklist/,
+ );
+ sinon.assert.calledOnceWithExactly(page.mockNetwork, {
+ kind: 'upstream',
+ urlPattern: undefined,
+ resourceType: undefined,
+ upstreamUrl: 'https://blocked.example/script.js',
+ });
+ sinon.assert.notCalled(response.appendResponseLine);
+ });
+
it('revalidates the canonical body file before each read', async () => {
const {page, context, response, args} = createHandlerMocks();
context.validatePath.resolves('/tmp/script.js');
@@ -162,10 +226,9 @@ describe('network', () => {
{
id: 2,
diagnostics: {hits: 0, errors: 0, navigations: 1},
- kind: 'file',
+ kind: 'upstream',
urlPattern: 'https://example.com/missing.js',
- responseFilePath: '/tmp/replacement.js',
- contentType: 'text/javascript',
+ upstreamUrl: 'https://example.com/replacement.js',
},
]);
await mockNetwork(args).handler({params: {}, page}, response, context);
diff --git a/tests/utils/network.test.ts b/tests/utils/network.test.ts
new file mode 100644
index 00000000..117a9756
--- /dev/null
+++ b/tests/utils/network.test.ts
@@ -0,0 +1,177 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'node:assert/strict';
+import {describe, it} from 'node:test';
+
+import sinon from 'sinon';
+
+import {
+ fetchWithValidatedRedirects,
+ validateNetworkUrl,
+} from '../../src/utils/network.js';
+
+describe('network access policy', () => {
+ it('redacts userinfo and query strings in URL policy errors', () => {
+ assert.throws(
+ () =>
+ validateNetworkUrl(
+ new URL('https://user:[email protected]/private?token=secret'),
+ {
+ blockedUrlPattern: ['https://example.com/*'],
+ },
+ ),
+ {message: 'Blocked by blocklist: https://example.com/private?REDACTED'},
+ );
+ });
+});
+
+describe('fetchWithValidatedRedirects', () => {
+ for (const policy of [
+ {blockedUrlPattern: ['https://blocked.example/*']},
+ {allowedUrlPattern: ['https://allowed.example/*']},
+ ]) {
+ it('checks every redirect against ' + JSON.stringify(policy), async () => {
+ const redirect = new Response('redirect body', {
+ status: 302,
+ headers: {location: 'https://blocked.example/private'},
+ });
+ assert.ok(redirect.body);
+ const cancel = sinon.spy(redirect.body, 'cancel');
+ const fetch = sinon.stub(globalThis, 'fetch').resolves(redirect);
+ await assert.rejects(
+ fetchWithValidatedRedirects(new URL('https://allowed.example/start'), {
+ policy,
+ }),
+ /blocklist|allowlist/,
+ );
+ sinon.assert.calledOnceWithExactly(
+ fetch,
+ new URL('https://allowed.example/start'),
+ {redirect: 'manual'},
+ );
+ sinon.assert.calledOnceWithExactly(cancel);
+ });
+ }
+
+ it('rejects a blocked initial URL before sending a request', async () => {
+ const fetch = sinon.stub(globalThis, 'fetch');
+ await assert.rejects(
+ fetchWithValidatedRedirects(new URL('https://blocked.example/start'), {
+ policy: {blockedUrlPattern: ['https://blocked.example/*']},
+ }),
+ /Blocked by blocklist/,
+ );
+ sinon.assert.notCalled(fetch);
+ });
+
+ it('preserves same-origin credentials and strips private headers on cross-origin redirects', async () => {
+ const final = new Response('content');
+ const fetch = sinon.stub(globalThis, 'fetch');
+ fetch
+ .onFirstCall()
+ .resolves(
+ new Response(null, {status: 301, headers: {location: '/next'}}),
+ );
+ fetch.onSecondCall().resolves(
+ new Response(null, {
+ status: 307,
+ headers: {location: 'https://other.example/final'},
+ }),
+ );
+ fetch.onThirdCall().resolves(final);
+ const headers = {
+ authorization: 'secret',
+ cookie: 'session=secret',
+ 'proxy-authorization': 'secret',
+ 'x-api-key': 'secret',
+ referer: 'https://example.com/private?token=secret',
+ accept: 'text/javascript',
+ };
+ const response = await fetchWithValidatedRedirects(
+ new URL('https://example.com/start'),
+ {
+ policy: {},
+ method: 'HEAD',
+ headers,
+ },
+ );
+ assert.equal(response, final);
+ sinon.assert.calledWithExactly(
+ fetch.firstCall,
+ new URL('https://example.com/start'),
+ {redirect: 'manual', method: 'HEAD', headers},
+ );
+ sinon.assert.calledWithExactly(
+ fetch.secondCall,
+ new URL('https://example.com/next'),
+ {redirect: 'manual', method: 'HEAD', headers},
+ );
+ sinon.assert.calledWithExactly(
+ fetch.thirdCall,
+ new URL('https://other.example/final'),
+ {
+ redirect: 'manual',
+ method: 'HEAD',
+ headers: {accept: 'text/javascript'},
+ },
+ );
+ });
+
+ it('rejects a redirect to an unsupported protocol before fetching it', async () => {
+ const fetch = sinon.stub(globalThis, 'fetch').resolves(
+ new Response(null, {
+ status: 303,
+ headers: {location: 'file:///tmp/secret'},
+ }),
+ );
+ await assert.rejects(
+ fetchWithValidatedRedirects(new URL('https://example.com/start'), {
+ policy: {},
+ }),
+ /Unsupported URL protocol: file:/,
+ );
+ sinon.assert.calledOnceWithExactly(
+ fetch,
+ new URL('https://example.com/start'),
+ {redirect: 'manual'},
+ );
+ });
+
+ it('cancels a redirect body when Location is missing', async () => {
+ const response = new Response('body', {status: 302});
+ assert.ok(response.body);
+ const cancel = sinon.spy(response.body, 'cancel');
+ sinon.stub(globalThis, 'fetch').resolves(response);
+ await assert.rejects(
+ fetchWithValidatedRedirects(new URL('https://example.com/start'), {
+ policy: {},
+ }),
+ /Redirect has no Location header/,
+ );
+ sinon.assert.calledOnceWithExactly(cancel);
+ });
+
+ it('bounds redirect loops and cancels the last response body', async () => {
+ const responses: Response[] = [];
+ const fetch = sinon.stub(globalThis, 'fetch').callsFake(async () => {
+ const response = new Response('body', {
+ status: 308,
+ headers: {location: '/loop'},
+ });
+ responses.push(response);
+ return response;
+ });
+ await assert.rejects(
+ fetchWithValidatedRedirects(new URL('https://example.com/loop'), {
+ policy: {},
+ }),
+ /Too many redirects/,
+ );
+ sinon.assert.callCount(fetch, 21);
+ assert.ok(responses.every(response => response.bodyUsed));
+ });
+});