chrome-devtools-frontend 1.0.967728 → 1.0.969882

package/front_end/models/issues_manager/FederatedAuthRequestIssue.ts

@@ -0,0 +1,265 @@
+// Copyright 2022 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as i18n from '../../core/i18n/i18n.js';
+import type * as SDK from '../../core/sdk/sdk.js';
+import * as Protocol from '../../generated/protocol.js';
+
+import {Issue, IssueCategory, IssueKind} from './Issue.js';
+import type {MarkdownIssueDescription, LazyMarkdownIssueDescription} from './MarkdownIssueDescription.js';
+import {resolveLazyDescription} from './MarkdownIssueDescription.js';
+
+const UIStrings = {
+  /**
+  *@description Title for Client Hint specification url link
+  */
+  fedCm: 'Federated Credential Management API',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/FederatedAuthRequestIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+
+export class FederatedAuthRequestIssue extends Issue {
+  readonly #issueDetails: Protocol.Audits.FederatedAuthRequestIssueDetails;
+
+  constructor(
+      issueDetails: Protocol.Audits.FederatedAuthRequestIssueDetails, issuesModel: SDK.IssuesModel.IssuesModel) {
+    super(
+        {
+          code: Protocol.Audits.InspectorIssueCode.FederatedAuthRequestIssue,
+          umaCode: [
+            Protocol.Audits.InspectorIssueCode.FederatedAuthRequestIssue,
+            issueDetails.federatedAuthRequestIssueReason,
+          ].join('::'),
+        },
+        issuesModel);
+    this.#issueDetails = issueDetails;
+  }
+
+  getCategory(): IssueCategory {
+    return IssueCategory.Other;
+  }
+
+  details(): Protocol.Audits.FederatedAuthRequestIssueDetails {
+    return this.#issueDetails;
+  }
+
+  getDescription(): MarkdownIssueDescription|null {
+    const description = issueDescriptions.get(this.#issueDetails.federatedAuthRequestIssueReason);
+    if (!description) {
+      return null;
+    }
+    return resolveLazyDescription(description);
+  }
+
+  primaryKey(): string {
+    return JSON.stringify(this.#issueDetails);
+  }
+
+  getKind(): IssueKind {
+    return IssueKind.PageError;
+  }
+
+  static fromInspectorIssue(issuesModel: SDK.IssuesModel.IssuesModel, inspectorIssue: Protocol.Audits.InspectorIssue):
+      FederatedAuthRequestIssue[] {
+    const details = inspectorIssue.details.federatedAuthRequestIssueDetails;
+    if (!details) {
+      console.warn('Federated auth request issue without details received.');
+      return [];
+    }
+    return [new FederatedAuthRequestIssue(details, issuesModel)];
+  }
+}
+
+const issueDescriptions: Map<Protocol.Audits.FederatedAuthRequestIssueReason, LazyMarkdownIssueDescription> = new Map([
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.ApprovalDeclined,
+    {
+      file: 'federatedAuthRequestApprovalDeclined.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.TooManyRequests,
+    {
+      file: 'federatedAuthRequestTooManyRequests.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.WellKnownHttpNotFound,
+    {
+      file: 'federatedAuthRequestWellKnownHttpNotFound.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.WellKnownNoResponse,
+    {
+      file: 'federatedAuthRequestWellKnownNoResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.WellKnownInvalidResponse,
+    {
+      file: 'federatedAuthRequestWellKnownInvalidResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.ClientIdMetadataHttpNotFound,
+    {
+      file: 'federatedAuthRequestClientIdMetadataHttpNotFound.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.ClientIdMetadataNoResponse,
+    {
+      file: 'federatedAuthRequestClientIdMetadataNoResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.ClientIdMetadataInvalidResponse,
+    {
+      file: 'federatedAuthRequestClientIdMetadataInvalidResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.ErrorFetchingSignin,
+    {
+      file: 'federatedAuthRequestErrorFetchingSignin.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.InvalidSigninResponse,
+    {
+      file: 'federatedAuthRequestInvalidSigninResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.AccountsHttpNotFound,
+    {
+      file: 'federatedAuthRequestAccountsHttpNotFound.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.AccountsNoResponse,
+    {
+      file: 'federatedAuthRequestAccountsNoResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.AccountsInvalidResponse,
+    {
+      file: 'federatedAuthRequestAccountsInvalidResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.IdTokenHttpNotFound,
+    {
+      file: 'federatedAuthRequestIdTokenHttpNotFound.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.IdTokenNoResponse,
+    {
+      file: 'federatedAuthRequestIdTokenNoResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.IdTokenInvalidResponse,
+    {
+      file: 'federatedAuthRequestIdTokenInvalidResponse.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.IdTokenInvalidRequest,
+    {
+      file: 'federatedAuthRequestIdTokenInvalidRequest.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.ErrorIdToken,
+    {
+      file: 'federatedAuthRequestErrorIdToken.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+  [
+    Protocol.Audits.FederatedAuthRequestIssueReason.Canceled,
+    {
+      file: 'federatedAuthRequestCanceled.md',
+      links: [{
+        link: 'https://fedidcg.github.io/FedCM/',
+        linkTitle: i18nLazyString(UIStrings.fedCm),
+      }],
+    },
+  ],
+]);

package/front_end/models/issues_manager/IssuesManager.ts

@@ -13,6 +13,7 @@ import {ContentSecurityPolicyIssue} from './ContentSecurityPolicyIssue.js';
 import {CorsIssue} from './CorsIssue.js';
 import {CrossOriginEmbedderPolicyIssue, isCrossOriginEmbedderPolicyIssue} from './CrossOriginEmbedderPolicyIssue.js';
 import {DeprecationIssue} from './DeprecationIssue.js';
+import {FederatedAuthRequestIssue} from './FederatedAuthRequestIssue.js';
 import {GenericIssue} from './GenericIssue.js';
 import {HeavyAdIssue} from './HeavyAdIssue.js';
 import type {Issue, IssueKind} from './Issue.js';
@@ -104,6 +105,10 @@ const issueCodeHandlers = new Map<
     Protocol.Audits.InspectorIssueCode.ClientHintIssue,
     ClientHintIssue.fromInspectorIssue,
   ],
+  [
+    Protocol.Audits.InspectorIssueCode.FederatedAuthRequestIssue,
+    FederatedAuthRequestIssue.fromInspectorIssue,
+  ],
 ]);
 
 /**

package/front_end/models/issues_manager/descriptions/federatedAuthRequestAccountsHttpNotFound.md

@@ -0,0 +1 @@
+# The provider's accounts list endpoint cannot be found.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestAccountsInvalidResponse.md

@@ -0,0 +1 @@
+# Provider's accounts list is invalid.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestAccountsNoResponse.md

@@ -0,0 +1 @@
+# The response body is empty when fetching the provider's accounts list.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestApprovalDeclined.md

@@ -0,0 +1 @@
+# User declined the sign-in attempt.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestCanceled.md

@@ -0,0 +1 @@
+# The request has been aborted.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestClientIdMetadataHttpNotFound.md

@@ -0,0 +1 @@
+# The provider's client metadata endpoint cannot be found.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestClientIdMetadataInvalidResponse.md

@@ -0,0 +1 @@
+# Provider's client metadata is invalid.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestClientIdMetadataNoResponse.md

@@ -0,0 +1 @@
+# The response body is empty when fetching the provider's client metadata.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestErrorFetchingSignin.md

@@ -0,0 +1 @@
+# Error attempting to reach the provider's sign-in endpoint.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestErrorIdToken.md

@@ -0,0 +1 @@
+# Error retrieving an id token.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestIdTokenHttpNotFound.md

@@ -0,0 +1 @@
+# The provider's id token endpoint cannot be found.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestIdTokenInvalidRequest.md

@@ -0,0 +1 @@
+# The id token fetching request is invalid.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestIdTokenInvalidResponse.md

@@ -0,0 +1 @@
+# Provider's id token is invalid.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestIdTokenNoResponse.md

@@ -0,0 +1 @@
+# The response body is empty when fetching the provider's id token.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestInvalidSigninResponse.md

@@ -0,0 +1 @@
+# Provider's sign-in response is invalid.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestTooManyRequests.md

@@ -0,0 +1 @@
+# Only one navigator.credentials.get request may be outstanding at one time.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestWellKnownHttpNotFound.md

@@ -0,0 +1 @@
+# The provider's .well-known configuration cannot be found.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestWellKnownInvalidResponse.md

@@ -0,0 +1 @@
+# Provider's .well-known configuration is invalid.

package/front_end/models/issues_manager/descriptions/federatedAuthRequestWellKnownNoResponse.md

@@ -0,0 +1 @@
+# The response body is empty when fetching the provider's .well-known configuration.

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -4,6 +4,7 @@
 
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 import * as Workspace from '../workspace/workspace.js';
@@ -31,6 +32,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   private activeInternal: boolean;
   private enabled: boolean;
   private eventDescriptors: Common.EventTarget.EventDescriptor[];
+  #headerOverridesMap: Map<string, HeaderOverrideWithRegex[]> = new Map();
 
   private constructor(workspace: Workspace.Workspace.WorkspaceImpl) {
     super();
@@ -363,29 +365,97 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     }
   }
 
-  private updateInterceptionPatterns(): void {
-    void this.updateInterceptionThrottler.schedule(innerUpdateInterceptionPatterns.bind(this));
-
-    function innerUpdateInterceptionPatterns(this: NetworkPersistenceManager): Promise<void> {
-      if (!this.activeInternal || !this.projectInternal) {
-        return SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
-            [], this.interceptionHandlerBound);
+  async generateHeaderPatterns(uiSourceCode: Workspace.UISourceCode.UISourceCode):
+      Promise<{headerPatterns: Set<string>, path: string, overridesWithRegex: HeaderOverrideWithRegex[]}> {
+    const headerPatterns = new Set<string>();
+    const content = (await uiSourceCode.requestContent()).content || '';
+    let headerOverrides: HeaderOverride[] = [];
+    try {
+      headerOverrides = JSON.parse(content) as HeaderOverride[];
+      if (!headerOverrides.every(isHeaderOverride)) {
+        throw 'Type mismatch after parsing';
       }
-      const patterns = new Set<string>();
-      const indexFileName = 'index.html';
-      for (const uiSourceCode of this.projectInternal.uiSourceCodes()) {
-        const pattern = this.patternForFileSystemUISourceCode(uiSourceCode);
-        patterns.add(pattern);
-        if (pattern.endsWith('/' + indexFileName)) {
-          patterns.add(pattern.substr(0, pattern.length - indexFileName.length));
-        }
+    } catch (e) {
+      console.error('Failed to parse', uiSourceCode.url(), 'for locally overriding headers.');
+      return {headerPatterns, path: '', overridesWithRegex: []};
+    }
+    const relativePath = FileSystemWorkspaceBinding.relativePath(uiSourceCode).join('/');
+    const decodedPath = this.decodeLocalPathToUrlPath(relativePath).slice(0, -HEADERS_FILENAME.length);
+
+    const overridesWithRegex: HeaderOverrideWithRegex[] = [];
+    for (const headerOverride of headerOverrides) {
+      headerPatterns.add('http?://' + decodedPath + headerOverride.applyTo);
+
+      // Most servers have the concept of a "directory index", which is a
+      // default resource name for a request targeting a "directory", e. g.
+      // requesting "example.com/path/" would result in the same response as
+      // requesting "example.com/path/index.html". To match this behavior we
+      // generate an additional pattern without "index.html" as the longer
+      // pattern would not match against a shorter request.
+      const {head, tail} = extractDirectoryIndex(headerOverride.applyTo);
+      if (tail) {
+        headerPatterns.add('http?://' + decodedPath + head);
+
+        const pattern = escapeRegex(decodedPath + head) + '(' + escapeRegex(tail) + ')?';
+        const regex = new RegExp('^https?:\/\/' + pattern + '$');
+        overridesWithRegex.push({
+          applyToRegex: regex,
+          headers: headerOverride.headers,
+        });
+      } else {
+        const regex = new RegExp('^https?:\/\/' + escapeRegex(decodedPath + headerOverride.applyTo) + '$');
+        overridesWithRegex.push({
+          applyToRegex: regex,
+          headers: headerOverride.headers,
+        });
       }
+    }
+    return {headerPatterns, path: decodedPath, overridesWithRegex};
+  }
+
+  async updateInterceptionPatternsForTests(): Promise<void> {
+    await this.#innerUpdateInterceptionPatterns();
+  }
+
+  private updateInterceptionPatterns(): void {
+    void this.updateInterceptionThrottler.schedule(this.#innerUpdateInterceptionPatterns.bind(this));
+  }
 
+  async #innerUpdateInterceptionPatterns(): Promise<void> {
+    this.#headerOverridesMap.clear();
+    if (!this.activeInternal || !this.projectInternal) {
       return SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
-          Array.from(patterns).map(
-              pattern => ({urlPattern: pattern, requestStage: Protocol.Fetch.RequestStage.Response})),
-          this.interceptionHandlerBound);
+          [], this.interceptionHandlerBound);
+    }
+    let patterns = new Set<string>();
+    for (const uiSourceCode of this.projectInternal.uiSourceCodes()) {
+      const pattern = this.patternForFileSystemUISourceCode(uiSourceCode);
+      if (Root.Runtime.experiments.isEnabled(Root.Runtime.ExperimentName.HEADER_OVERRIDES) &&
+          uiSourceCode.name() === HEADERS_FILENAME) {
+        const {headerPatterns, path, overridesWithRegex} = await this.generateHeaderPatterns(uiSourceCode);
+        if (headerPatterns.size > 0) {
+          patterns = new Set([...patterns, ...headerPatterns]);
+          this.#headerOverridesMap.set(path, overridesWithRegex);
+        }
+      } else {
+        patterns.add(pattern);
+      }
+      // Most servers have the concept of a "directory index", which is a
+      // default resource name for a request targeting a "directory", e. g.
+      // requesting "example.com/path/" would result in the same response as
+      // requesting "example.com/path/index.html". To match this behavior we
+      // generate an additional pattern without "index.html" as the longer
+      // pattern would not match against a shorter request.
+      const {head, tail} = extractDirectoryIndex(pattern);
+      if (tail) {
+        patterns.add(head);
+      }
     }
+
+    return SDK.NetworkManager.MultitargetNetworkManager.instance().setInterceptionHandlerForPatterns(
+        Array.from(patterns).map(
+            pattern => ({urlPattern: pattern, requestStage: Protocol.Fetch.RequestStage.Response})),
+        this.interceptionHandlerBound);
   }
 
   private async onUISourceCodeRemoved(uiSourceCode: Workspace.UISourceCode.UISourceCode): Promise<void> {
@@ -409,7 +479,7 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     await this.unbind(uiSourceCode);
   }
 
-  private async setProject(project: Workspace.Workspace.Project|null): Promise<void> {
+  async setProject(project: Workspace.Workspace.Project|null): Promise<void> {
     if (project === this.projectInternal) {
       return;
     }
@@ -452,6 +522,49 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     }
   }
 
+  mergeHeaders(baseHeaders: Protocol.Fetch.HeaderEntry[], overrideHeaders: Protocol.Network.Headers):
+      Protocol.Fetch.HeaderEntry[] {
+    const result: Protocol.Fetch.HeaderEntry[] = [];
+    const headerMap = new Map<string, string>();
+    for (const header of baseHeaders) {
+      headerMap.set(header.name, header.value);
+    }
+    for (const [headerName, headerValue] of Object.entries(overrideHeaders)) {
+      headerMap.set(headerName, headerValue);
+    }
+    headerMap.forEach((headerValue, headerName) => {
+      result.push({name: headerName, value: headerValue});
+    });
+    return result;
+  }
+
+  #maybeMergeHeadersForPathSegment(path: string, requestUrl: string, headers: Protocol.Fetch.HeaderEntry[]):
+      Protocol.Fetch.HeaderEntry[] {
+    const headerOverrides = this.#headerOverridesMap.get(path) || [];
+    for (const headerOverride of headerOverrides) {
+      if (headerOverride.applyToRegex.test(requestUrl)) {
+        headers = this.mergeHeaders(headers, headerOverride.headers);
+      }
+    }
+    return headers;
+  }
+
+  handleHeaderInterception(interceptedRequest: SDK.NetworkManager.InterceptedRequest): Protocol.Fetch.HeaderEntry[] {
+    let result: Protocol.Fetch.HeaderEntry[] = interceptedRequest.responseHeaders || [];
+    const urlSegments = this.encodedPathFromUrl(interceptedRequest.request.url).split('/');
+    // Traverse the hierarchy of overrides from the most general to the most
+    // specific. Check with empty string first to match overrides applying to
+    // all domains.
+    // e.g. '', 'www.example.com/', 'www.example.com/path/', ...
+    let path = '';
+    result = this.#maybeMergeHeadersForPathSegment(path, interceptedRequest.request.url, result);
+    for (const segment of urlSegments) {
+      path += segment + '/';
+      result = this.#maybeMergeHeadersForPathSegment(path, interceptedRequest.request.url, result);
+    }
+    return result;
+  }
+
   private async interceptionHandler(interceptedRequest: SDK.NetworkManager.InterceptedRequest): Promise<void> {
     const method = interceptedRequest.request.method;
     if (!this.activeInternal || (method !== 'GET' && method !== 'POST')) {
@@ -460,9 +573,16 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     const proj = this.projectInternal as FileSystem;
     const path = proj.fileSystemPath() + '/' + this.encodedPathFromUrl(interceptedRequest.request.url);
     const fileSystemUISourceCode = proj.uiSourceCodeForURL(path);
-    if (!fileSystemUISourceCode) {
+    let responseHeaders: Protocol.Fetch.HeaderEntry[] = [];
+    if (Root.Runtime.experiments.isEnabled(Root.Runtime.ExperimentName.HEADER_OVERRIDES)) {
+      responseHeaders = this.handleHeaderInterception(interceptedRequest);
+    }
+    if (!fileSystemUISourceCode && !responseHeaders.length) {
       return;
     }
+    if (!responseHeaders.length) {
+      responseHeaders = interceptedRequest.responseHeaders || [];
+    }
 
     let mimeType = '';
     if (interceptedRequest.responseHeaders) {
@@ -477,32 +597,41 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     if (!mimeType) {
       const expectedResourceType =
           Common.ResourceType.resourceTypes[interceptedRequest.resourceType] || Common.ResourceType.resourceTypes.Other;
-      mimeType = fileSystemUISourceCode.mimeType();
+      mimeType = fileSystemUISourceCode?.mimeType() || '';
       if (Common.ResourceType.ResourceType.fromMimeType(mimeType) !== expectedResourceType) {
         mimeType = expectedResourceType.canonicalMimeType();
       }
     }
-    const project = fileSystemUISourceCode.project() as FileSystem;
-
-    this.originalResponseContentPromises.set(
-        fileSystemUISourceCode, interceptedRequest.responseBody().then(response => {
-          if (response.error || response.content === null) {
-            return null;
-          }
-          if (response.encoded) {
-            const text = atob(response.content);
-            const data = new Uint8Array(text.length);
-            for (let i = 0; i < text.length; ++i) {
-              data[i] = text.charCodeAt(i);
-            }
-            return new TextDecoder('utf-8').decode(data);
-          }
-          return response.content;
-        }));
 
-    const blob = await project.requestFileBlob(fileSystemUISourceCode);
-    if (blob) {
-      void interceptedRequest.continueRequestWithContent(new Blob([blob], {type: mimeType}));
+    if (fileSystemUISourceCode) {
+      this.originalResponseContentPromises.set(
+          fileSystemUISourceCode, interceptedRequest.responseBody().then(response => {
+            if (response.error || response.content === null) {
+              return null;
+            }
+            if (response.encoded) {
+              const text = atob(response.content);
+              const data = new Uint8Array(text.length);
+              for (let i = 0; i < text.length; ++i) {
+                data[i] = text.charCodeAt(i);
+              }
+              return new TextDecoder('utf-8').decode(data);
+            }
+            return response.content;
+          }));
+
+      const project = fileSystemUISourceCode.project() as FileSystem;
+      const blob = await project.requestFileBlob(fileSystemUISourceCode);
+      if (blob) {
+        void interceptedRequest.continueRequestWithContent(
+            new Blob([blob], {type: mimeType}), /* encoded */ false, responseHeaders);
+      }
+    } else {
+      const responseBody = await interceptedRequest.responseBody();
+      if (!responseBody.error && responseBody.content) {
+        void interceptedRequest.continueRequestWithContent(
+            new Blob([responseBody.content], {type: mimeType}), /* encoded */ true, responseHeaders);
+      }
     }
   }
 }
@@ -512,6 +641,8 @@ const RESERVED_FILENAMES = new Set<string>([
   'com8', 'com9', 'lpt1', 'lpt2', 'lpt3', 'lpt4', 'lpt5', 'lpt6', 'lpt7', 'lpt8', 'lpt9',
 ]);
 
+const HEADERS_FILENAME = '.headers';
+
 // TODO(crbug.com/1167717): Make this a const enum again
 // eslint-disable-next-line rulesdir/const_enum
 export enum Events {
@@ -521,3 +652,36 @@ export enum Events {
 export type EventTypes = {
   [Events.ProjectChanged]: Workspace.Workspace.Project|null,
 };
+
+interface HeaderOverride {
+  applyTo: string;
+  headers: Protocol.Network.Headers;
+}
+
+interface HeaderOverrideWithRegex {
+  applyToRegex: RegExp;
+  headers: Protocol.Network.Headers;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isHeaderOverride(arg: any): arg is HeaderOverride {
+  if (!(arg && arg.applyTo && typeof (arg.applyTo === 'string') && arg.headers && Object.keys(arg.headers).length)) {
+    return false;
+  }
+  return Object.values(arg.headers).every(value => typeof value === 'string');
+}
+
+export function escapeRegex(pattern: string): string {
+  return Platform.StringUtilities.escapeCharacters(pattern, '[]{}()\\.^$+|-,?').replaceAll('*', '.*');
+}
+
+export function extractDirectoryIndex(pattern: string): {head: string, tail?: string} {
+  const lastSlash = pattern.lastIndexOf('/');
+  const tail = lastSlash >= 0 ? pattern.slice(lastSlash + 1) : pattern;
+  const head = lastSlash >= 0 ? pattern.slice(0, lastSlash + 1) : '';
+  const regex = new RegExp('^' + escapeRegex(tail) + '$');
+  if (regex.test('index.html') || regex.test('index.htm') || regex.test('index.php')) {
+    return {head, tail};
+  }
+  return {head: pattern};
+}