chrome-devtools-frontend 1.0.1690116 → 1.0.1695017

package/front_end/models/ai_assistance/contexts/PerformanceTraceContext.ts

@@ -2,7 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Common from '../../../core/common/common.js';
 import type * as Platform from '../../../core/platform/platform.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import * as Tracing from '../../../services/tracing/tracing.js';
@@ -15,7 +14,6 @@ import {
   ConversationContext,
   type ConversationSuggestions,
 } from '../agents/AiAgent.js';
-import {extractContextOrigin} from '../AiOrigins.js';
 import {
   PerformanceInsightFormatter,
 } from '../data_formatters/PerformanceInsightFormatter.js';
@@ -88,6 +86,7 @@ export class PerformanceTraceContext extends ConversationContext<AgentFocus> {
   readonly #targetManager: SDK.TargetManager.TargetManager;
   readonly #freshRecordingTracker: Tracing.FreshRecording.Tracker;
   readonly #debuggerWorkspaceBinding: Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding;
+  #origin?: SDK.SecurityOrigin.SecurityOrigin;
 
   constructor(focus: AgentFocus,
               // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
@@ -128,36 +127,64 @@ export class PerformanceTraceContext extends ConversationContext<AgentFocus> {
     return formatter;
   }
 
-  override getURL(): string {
-    const url = this.#focus.parsedTrace.data.Meta.mainFrameURL;
-    try {
-      new URL(url);
-      return url;
-    } catch {
-      const {min, max} = this.#focus.parsedTrace.data.Meta.traceBounds;
-      return `trace-${min}-${max}`;
+  /**
+   * Returns whether this trace was imported rather than recorded live in the current session.
+   */
+  isImported(): boolean {
+    return !this.#freshRecordingTracker.recordingIsFresh(this.#focus.parsedTrace);
+  }
+
+  /**
+   * Checks whether the AI can access the resource at the specified URL.
+   *
+   * Access requires the resource origin to match the trace origin.
+   * Always rejects `file://` URLs to prevent local file leaks (b/523743289).
+   *
+   * @param url The URL of the resource to access.
+   * @returns `true` if the resource is same-origin with the trace and not a `file://` URL; otherwise `false`.
+   */
+  canAccessResource(url: string): boolean {
+    const traceOrigin = this.getOrigin();
+    const targetOrigin = SDK.SecurityOrigin.SecurityOrigin.create(url);
+
+    // We explicitly block all file:// URLs even if same-origin (b/523743289).
+    // Allowing local file access in trace AI risks leaking local system files
+    // (such as /etc/passwd) via prompt injection across filesystem edge cases.
+    if (traceOrigin.isFile() || targetOrigin.isFile()) {
+      return false;
     }
+
+    return traceOrigin.isSameOriginWith(targetOrigin);
   }
 
   /**
-   * Returns the origin for a performance trace in the AI context.
+   * Returns the security origin for the performance trace.
+   *
+   * Live traces use the origin of the main frame URL.
    *
-   * To prevent cross-origin prompt injection attacks, imported traces
-   * are isolated from live pages. We assign them a virtual origin
-   * (`imported-trace://${domain}`) so they do not share the origin of live pages
-   * (e.g., `https://${domain}`). This forces a conversation reset when transitioning
-   * between imported trace data and live pages.
+   * Imported traces use a custom scheme (`imported-trace://${host}`) to isolate
+   * them from live pages (such as `https://${host}`). This isolation prevents
+   * cross-origin prompt injection and requires a new conversation when switching
+   * between imported traces and live pages.
+   *
+   * If an imported trace origin does not contain a host, this method returns a
+   * unique opaque origin.
+   *
+   * @returns The security origin for the trace.
    */
-  override getOrigin(): string {
-    const parsedTrace = this.#focus.parsedTrace;
-    const url = this.getURL();
-    const origin = extractContextOrigin(url);
-    const isFresh = this.#freshRecordingTracker.recordingIsFresh(parsedTrace);
-    if (!isFresh) {
-      const parsed = Common.ParsedURL.ParsedURL.fromString(origin as Platform.DevToolsPath.UrlString);
-      return `imported-trace://${parsed ? parsed.domain() : origin}`;
+  override getOrigin(): SDK.SecurityOrigin.SecurityOrigin {
+    if (!this.#origin) {
+      if (this.isImported()) {
+        this.#origin = SDK.SecurityOrigin.SecurityOrigin.createForImportedTrace(
+            this.#focus.parsedTrace.data.Meta.mainFrameURL,
+        );
+      } else {
+        this.#origin = SDK.SecurityOrigin.SecurityOrigin.create(
+            this.#focus.parsedTrace.data.Meta.mainFrameURL,
+        );
+      }
     }
-    return origin;
+    return this.#origin;
   }
 
   override getItem(): AgentFocus {

package/front_end/models/ai_assistance/contexts/RequestContext.ts

@@ -2,17 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Common from '../../../core/common/common.js';
 import * as i18n from '../../../core/i18n/i18n.js';
-import type * as Platform from '../../../core/platform/platform.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
 import type * as NetworkTimeCalculator from '../../network_time_calculator/network_time_calculator.js';
 import {
   type ContextDetail,
   ConversationContext,
 } from '../agents/AiAgent.js';
-import {extractContextOrigin} from '../AiOrigins.js';
-import {NetworkRequestFormatter} from '../data_formatters/NetworkRequestFormatter.js';
+import {
+  NetworkRequestFormatter,
+} from '../data_formatters/NetworkRequestFormatter.js';
 
 const UIStringsNotTranslate = {
   request: 'Request',
@@ -24,24 +23,6 @@ const UIStringsNotTranslate = {
 
 const lockedString = i18n.i18n.lockedString;
 
-/**
- * Returns the origin for a network request in the AI context.
- *
- * To prevent cross-origin prompt injection attacks, HAR-imported requests
- * are isolated from live pages. We assign them a virtual origin
- * (`imported-har://${domain}`) so they do not share the origin of live pages
- * (e.g., `https://${domain}`). This forces a conversation reset when transitioning
- * between imported HAR data and live pages.
- */
-export function getRequestContextOrigin(request: SDK.NetworkRequest.NetworkRequest): string {
-  const origin = extractContextOrigin(request.documentURL);
-  if (request.isImportedHar()) {
-    const parsed = Common.ParsedURL.ParsedURL.fromString(origin as Platform.DevToolsPath.UrlString);
-    return `imported-har://${parsed ? parsed.domain() : origin}`;
-  }
-  return origin;
-}
-
 export class RequestContext extends ConversationContext<SDK.NetworkRequest.NetworkRequest> {
   #request: SDK.NetworkRequest.NetworkRequest;
   #calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator;
@@ -56,17 +37,14 @@ export class RequestContext extends ConversationContext<SDK.NetworkRequest.Netwo
   }
 
   /**
-   * Note: this is not the literal origin of the network request. This URL
-   * is used to determine when we should force the user to start a new AI
-   * conversation when the context changes. We allow a single AI conversation to
-   * inspect all network requests that were made for that given target URL.
+   * Returns the security origin of the document that initiated the request.
+   *
+   * Network requests to third-party endpoints share the origin of the page
+   * that initiated them. This permits the AI to inspect third-party subresources
+   * without triggering a cross-origin conversation reset.
    */
-  override getURL(): string {
-    return this.#request.documentURL;
-  }
-
-  override getOrigin(): string {
-    return getRequestContextOrigin(this.#request);
+  override getOrigin(): SDK.SecurityOrigin.SecurityOrigin {
+    return this.#request.initiatorSecurityOrigin();
   }
 
   override getItem(): SDK.NetworkRequest.NetworkRequest {
@@ -77,13 +55,19 @@ export class RequestContext extends ConversationContext<SDK.NetworkRequest.Netwo
     return this.#request.name();
   }
 
+  #createFormatter(): NetworkRequestFormatter {
+    return new NetworkRequestFormatter(this.#request, this.#calculator, {
+      accessingSecurityOrigin: this.#request.initiatorSecurityOrigin(),
+    });
+  }
+
   override async getPromptDetails(): Promise<string|null> {
-    const formatter = new NetworkRequestFormatter(this.#request, this.#calculator);
+    const formatter = this.#createFormatter();
     return `# Selected network request\n${await formatter.formatNetworkRequest()}`;
   }
 
   override async getUserFacingDetails(): Promise<[ContextDetail, ...ContextDetail[]]|null> {
-    const formatter = new NetworkRequestFormatter(this.#request, this.#calculator);
+    const formatter = this.#createFormatter();
     const requestContextDetail: ContextDetail = {
       title: lockedString(UIStringsNotTranslate.request),
       text: lockedString(UIStringsNotTranslate.requestUrl) + ': ' + this.#request.url() + '\n\n' +

package/front_end/models/ai_assistance/contexts/StorageContext.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as SDK from '../../../core/sdk/sdk.js';
 import {
   ConversationContext,
   type ConversationSuggestions,
@@ -16,8 +17,18 @@ export class StorageContext extends ConversationContext<StorageItem> {
     this.#item = item;
   }
 
-  override getURL(): string {
-    return this.#item.primaryTargetOrigin;
+  /**
+   * Returns the security origin of the primary inspected page target.
+   *
+   * The storage context binds to `primaryTargetOrigin` rather than the specific
+   * item origin (`this.#item.origin`). This allows generic storage views
+   * (which have an empty origin) and third-party storage items to be inspected
+   * within the current page conversation.
+   *
+   * @returns The security origin of the primary page target.
+   */
+  override getOrigin(): SDK.SecurityOrigin.SecurityOrigin {
+    return SDK.SecurityOrigin.SecurityOrigin.create(this.#item.primaryTargetOrigin);
   }
 
   override getItem(): StorageItem {
@@ -38,7 +49,7 @@ export class StorageContext extends ConversationContext<StorageItem> {
       const prefix = this.#item.type === 'localStorage' ? 'local storage' : 'session storage';
       return `${prefix}${this.#item.isGenericContext ? '' : `: ${this.#item.origin}`}`;
     }
-    return `Storage: ${this.getOrigin()}`;
+    return `Storage: ${this.getOrigin().siteId()}`;
   }
 
   /**

package/front_end/models/ai_assistance/data_formatters/FileFormatter.ts

@@ -4,10 +4,9 @@
 
 import * as Bindings from '../../bindings/bindings.js';
 import * as Logs from '../../logs/logs.js';
-import * as NetworkTimeCalculator from '../../network_time_calculator/network_time_calculator.js';
 import type * as Workspace from '../../workspace/workspace.js';
 
-import {NetworkRequestFormatter} from './NetworkRequestFormatter.js';
+import {formatRequestInitiatorChain} from './NetworkRequestFormatter.js';
 
 const MAX_FILE_SIZE = 10000;
 
@@ -75,10 +74,8 @@ export class FileFormatter {
     ];
     const resource = Bindings.ResourceUtils.resourceForURL(this.#file.url());
     if (resource?.request) {
-      const calculator = new NetworkTimeCalculator.NetworkTransferTimeCalculator();
-      calculator.updateBoundaries(resource.request);
       lines.push(`Request initiator chain:
-${new NetworkRequestFormatter(resource.request, calculator, this.#networkLog).formatRequestInitiatorChain()}`);
+${formatRequestInitiatorChain(resource.request, this.#networkLog)}`);
     }
     lines.push(`File content:
 ${this.#formatFileContent()}`);

package/front_end/models/ai_assistance/data_formatters/NetworkRequestFormatter.ts

@@ -2,9 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Common from '../../../core/common/common.js';
 import type * as Platform from '../../../core/platform/platform.js';
-import type * as SDK from '../../../core/sdk/sdk.js';
+import * as SDK from '../../../core/sdk/sdk.js';
 import * as TextUtils from '../../../core/text_utils/text_utils.js';
 import * as Protocol from '../../../generated/protocol.js';
 import * as Logs from '../../logs/logs.js';
@@ -16,7 +15,10 @@ const MAX_HEADERS_SIZE = 1000;
 const MAX_BODY_SIZE = 10000;
 
 /**
- * Sanitizes the set of headers, removing values that are not on the allow-list and replacing them with '<redacted>'.
+ * Sanitizes headers by replacing unapproved header values with '<redacted>'.
+ *
+ * @param headers List of header name/value pairs to sanitize.
+ * @returns Sanitized list of headers with unapproved values redacted.
  */
 export function sanitizeHeaders(headers: Array<{name: string, value: string}>): Array<{name: string, value: string}> {
   return headers.map(header => {
@@ -27,9 +29,60 @@ export function sanitizeHeaders(headers: Array<{name: string, value: string}>):
   });
 }
 
+/**
+ * Options for configuring {@link NetworkRequestFormatter}.
+ */
+export interface NetworkRequestFormatterOptions {
+  /**
+   * The security origin used to evaluate Same-Origin Policy (SOP) and Cross-Origin
+   * Resource Sharing (CORS) access.
+   *
+   * This is required because evaluating access solely against `request.initiatorSecurityOrigin()`
+   * is unsafe in cross-origin embedded contexts.
+   *
+   * Example:
+   * When debugging a page at `https://example.com` (the active conversation origin), an embedded
+   * `<iframe>` at `https://third-party.com` may fetch `https://third-party.com/api/user.json`.
+   * Relative to the iframe, that request is same-origin (`request.initiatorSecurityOrigin() === https://third-party.com`).
+   * However, from the perspective of the top-level conversation (`https://example.com`), that request
+   * is cross-origin. Its response body and unexposed headers must be redacted to prevent leaking
+   * unauthorized data into the prompt.
+   */
+  accessingSecurityOrigin: SDK.SecurityOrigin.SecurityOrigin;
+  /** Optional network log instance for resolving initiator graphs. */
+  networkLog?: Logs.NetworkLog.NetworkLog;
+}
+
 export class NetworkRequestFormatter {
   #calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator;
   #request: SDK.NetworkRequest.NetworkRequest;
+  readonly #networkLog?: Logs.NetworkLog.NetworkLog;
+  readonly #accessingSecurityOrigin: SDK.SecurityOrigin.SecurityOrigin;
+
+  /**
+   * @param request The network request to format.
+   * @param calculator Calculator for request timing metrics.
+   * @param options Configuration options specifying the accessing security origin.
+   */
+  constructor(
+      request: SDK.NetworkRequest.NetworkRequest,
+      calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator,
+      options: NetworkRequestFormatterOptions,
+  ) {
+    this.#request = request;
+    this.#calculator = calculator;
+    this.#networkLog = options.networkLog;
+    this.#accessingSecurityOrigin = options.accessingSecurityOrigin;
+  }
+
+  /**
+   * Evaluates the response access mode for this network request relative to the accessing security origin.
+   *
+   * @returns The evaluated `ResponseAccessMode`.
+   */
+  responseAccessMode(): SDK.NetworkRequestAccess.ResponseAccessMode {
+    return SDK.NetworkRequestAccess.evaluateResponseAccessMode(this.#request, this.#accessingSecurityOrigin);
+  }
 
   static allowHeader(headerName: string): boolean {
     return allowedHeaders.has(headerName.toLowerCase().trim());
@@ -73,9 +126,9 @@ export class NetworkRequestFormatter {
       initiatorUrl: Platform.DevToolsPath.UrlString,
       allowedOrigin: Platform.DevToolsPath.UrlString,
       ): string {
-    // We extract the origin, and if it is invalid/empty we default to redacting.
-    const initiatorOrigin = Common.ParsedURL.ParsedURL.extractOrigin(initiatorUrl);
-    if (initiatorOrigin && initiatorOrigin === allowedOrigin) {
+    const initiatorOrigin = SDK.SecurityOrigin.SecurityOrigin.create(initiatorUrl);
+    const targetOrigin = SDK.SecurityOrigin.SecurityOrigin.create(allowedOrigin);
+    if (initiatorOrigin.isSameOriginWith(targetOrigin)) {
       return initiatorUrl;
     }
     return '<redacted cross-origin initiator URL>';
@@ -131,28 +184,35 @@ export class NetworkRequestFormatter {
     return lines.length > 0 ? `${lines.join('\n')}\n` : '';
   }
 
-  readonly #networkLog: Logs.NetworkLog.NetworkLog;
-
-  constructor(
-      request: SDK.NetworkRequest.NetworkRequest,
-      calculator: NetworkTimeCalculator.NetworkTransferTimeCalculator,
-      // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
-      networkLog: Logs.NetworkLog.NetworkLog = Logs.NetworkLog.NetworkLog.instance(),
-  ) {
-    this.#request = request;
-    this.#calculator = calculator;
-    this.#networkLog = networkLog;
-  }
-
   formatRequestHeaders(): string {
     return NetworkRequestFormatter.formatHeaders('Request headers:', this.#request.requestHeaders());
   }
 
+  /**
+   * Formats response headers for the AI prompt.
+   *
+   * Headers are filtered based on the request's evaluated ResponseAccessMode:
+   * - Opaque cross-origin requests only include CORS-safelisted response headers.
+   * - CORS-authorized requests include CORS-safelisted and Access-Control-Expose-Headers.
+   * - Same-origin requests include all response headers.
+   * Values of headers not present on the global allowedHeaders list are then redacted.
+   */
   formatResponseHeaders(): string {
-    return NetworkRequestFormatter.formatHeaders('Response headers:', this.#request.responseHeaders);
+    const accessMode = this.responseAccessMode();
+    const headers = SDK.NetworkRequestAccess.getFilterableResponseHeaders(this.#request, accessMode);
+    return NetworkRequestFormatter.formatHeaders('Response headers:', headers);
   }
 
+  /**
+   * Formats the response body for the AI prompt.
+   *
+   * For opaque cross-origin requests, the response body is redacted because the accessing
+   * security origin is forbidden by the Same-Origin Policy from reading it.
+   */
   async formatResponseBody(): Promise<string> {
+    if (this.responseAccessMode() === SDK.NetworkRequestAccess.ResponseAccessMode.OPAQUE_CROSS_ORIGIN) {
+      return SDK.NetworkRequestAccess.REDACTED_RESPONSE_BODY;
+    }
     return await NetworkRequestFormatter.formatBody('Response body:', this.#request, MAX_BODY_SIZE);
   }
 
@@ -203,22 +263,9 @@ Request initiator chain:\n${this.formatRequestInitiatorChain()}`;
    * the request's origin.
    */
   formatRequestInitiatorChain(): string {
-    const allowedOrigin = Common.ParsedURL.ParsedURL.extractOrigin(this.#request.url());
-    let initiatorChain = '';
-    let lineStart = '- URL: ';
-    const graph = this.#networkLog.initiatorGraphForRequest(this.#request);
-
-    for (const initiator of Array.from(graph.initiators).reverse()) {
-      initiatorChain = initiatorChain + lineStart +
-          NetworkRequestFormatter.formatInitiatorUrl(initiator.url(), allowedOrigin) + '\n';
-      lineStart = '\t' + lineStart;
-      if (initiator === this.#request) {
-        initiatorChain =
-            this.#formatRequestInitiated(graph.initiated, this.#request, initiatorChain, lineStart, allowedOrigin);
-      }
-    }
-
-    return initiatorChain.trim();
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    const networkLog = this.#networkLog ?? Logs.NetworkLog.NetworkLog.instance();
+    return formatRequestInitiatorChain(this.#request, networkLog);
   }
 
   formatNetworkRequestTiming(): string {
@@ -269,32 +316,62 @@ Request initiator chain:\n${this.formatRequestInitiatorChain()}`;
 
     return labels.filter(label => !!label.value).map(label => `${label.label}: ${label.value}`).join('\n');
   }
+}
 
-  #formatRequestInitiated(
-      initiated: Map<SDK.NetworkRequest.NetworkRequest, SDK.NetworkRequest.NetworkRequest>,
-      parentRequest: SDK.NetworkRequest.NetworkRequest,
-      initiatorChain: string,
-      lineStart: string,
-      allowedOrigin: Platform.DevToolsPath.UrlString,
-      ): string {
-    const visited = new Set<SDK.NetworkRequest.NetworkRequest>();
-
-    // this.request should be already in the tree when build initiator part
-    visited.add(this.#request);
-    for (const [keyRequest, initiatedRequest] of initiated.entries()) {
-      if (initiatedRequest === parentRequest) {
-        if (!visited.has(keyRequest)) {
-          visited.add(keyRequest);
-          initiatorChain = initiatorChain + lineStart +
-              NetworkRequestFormatter.formatInitiatorUrl(keyRequest.url(), allowedOrigin) + '\n';
-          initiatorChain =
-              this.#formatRequestInitiated(initiated, keyRequest, initiatorChain, '\t' + lineStart, allowedOrigin);
-        }
-      }
+/**
+ * Formats the initiator chain for a given network request into a formatted string.
+ *
+ * @param request The network request to format the initiator chain for.
+ * @param networkLog Network log instance used to build the initiator graph.
+ * @returns Formatted initiator chain.
+ */
+export function formatRequestInitiatorChain(
+    request: SDK.NetworkRequest.NetworkRequest,
+    networkLog: Logs.NetworkLog.NetworkLog,
+    ): string {
+  const allowedOrigin = request.url();
+  let initiatorChain = '';
+  let lineStart = '- URL: ';
+  const graph = networkLog.initiatorGraphForRequest(request);
+
+  for (const initiator of Array.from(graph.initiators).reverse()) {
+    initiatorChain =
+        initiatorChain + lineStart + NetworkRequestFormatter.formatInitiatorUrl(initiator.url(), allowedOrigin) + '\n';
+    lineStart = '\t' + lineStart;
+    if (initiator === request) {
+      initiatorChain =
+          formatRequestInitiated(graph.initiated, request, request, initiatorChain, lineStart, allowedOrigin);
     }
+  }
 
-    return initiatorChain;
+  return initiatorChain.trim();
+}
+
+function formatRequestInitiated(
+    initiated: Map<SDK.NetworkRequest.NetworkRequest, SDK.NetworkRequest.NetworkRequest>,
+    rootRequest: SDK.NetworkRequest.NetworkRequest,
+    parentRequest: SDK.NetworkRequest.NetworkRequest,
+    initiatorChain: string,
+    lineStart: string,
+    allowedOrigin: Platform.DevToolsPath.UrlString,
+    ): string {
+  const visited = new Set<SDK.NetworkRequest.NetworkRequest>();
+
+  // rootRequest should be already in the tree when building initiator part
+  visited.add(rootRequest);
+  for (const [keyRequest, initiatedRequest] of initiated.entries()) {
+    if (initiatedRequest === parentRequest) {
+      if (!visited.has(keyRequest)) {
+        visited.add(keyRequest);
+        initiatorChain = initiatorChain + lineStart +
+            NetworkRequestFormatter.formatInitiatorUrl(keyRequest.url(), allowedOrigin) + '\n';
+        initiatorChain =
+            formatRequestInitiated(initiated, rootRequest, keyRequest, initiatorChain, '\t' + lineStart, allowedOrigin);
+      }
+    }
   }
+
+  return initiatorChain;
 }
 
 // Header names that could be included in the prompt, lowercase.

package/front_end/models/ai_assistance/tools/CookieUtils.ts

@@ -2,10 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import * as Common from '../../../core/common/common.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import type * as Protocol from '../../../generated/protocol.js';
-import {areOriginsEquivalent, extractContextOrigin, isOpaqueOrigin} from '../AiOrigins.js';
 
 import {MAX_TARGET_ORIGINS} from './DOMStorageUtils.js';
 import type {OriginLockCapability} from './Tool.js';
@@ -27,8 +25,16 @@ export interface CookieDetails {
 }
 
 /**
- * Resolves and validates target origins against origin-lock constraints and primary page target.
- * If `requestedOrigins` is omitted or empty, defaults to the established context origin.
+ * Resolves and validates target origins against the established context origin and primary page target.
+ *
+ * When `requestedOrigins` is empty or omitted, defaults to the established context origin.
+ * Rejects opaque origins, mismatches with the primary page origin, and cross-origin targets.
+ * Limits results to at most `MAX_TARGET_ORIGINS` unique origins.
+ *
+ * @param requestedOrigins Optional list of origin URLs to validate.
+ * @param context The origin lock capability containing the established origin.
+ * @param targetManager The target manager used to resolve the primary page target.
+ * @returns An object with validated target origins and the primary page target, or an error object.
  */
 export function resolveAllowedTargetOrigins(
     requestedOrigins: string[]|undefined,
@@ -38,8 +44,8 @@ export function resolveAllowedTargetOrigins(
   error: string,
 }
 {
-  const allowedOrigin = context.getEstablishedOrigin();
-  if (!allowedOrigin || isOpaqueOrigin(allowedOrigin) || isOpaqueOrigin(extractContextOrigin(allowedOrigin))) {
+  const establishedOrigin = context.getEstablishedOrigin();
+  if (!establishedOrigin || establishedOrigin.isOpaque()) {
     return {error: 'No origin available or not allowed.'};
   }
 
@@ -48,15 +54,19 @@ export function resolveAllowedTargetOrigins(
     return {error: 'Primary page target not found.'};
   }
 
-  const pageOrigin = Common.ParsedURL.ParsedURL.extractOrigin(primaryPageTarget.inspectedURL());
-  if (!pageOrigin || !areOriginsEquivalent(pageOrigin, allowedOrigin)) {
+  const pageOrigin = primaryPageTarget.inspectedSecurityOrigin();
+  if (!pageOrigin.isSameOriginWith(establishedOrigin)) {
     return {error: 'Page origin does not match allowed origin.'};
   }
 
-  const rawOrigins =
-      (Array.isArray(requestedOrigins) && requestedOrigins.length > 0) ? requestedOrigins : [allowedOrigin];
-  const validOrigins = rawOrigins.map(origin => extractContextOrigin(origin))
-                           .filter(origin => areOriginsEquivalent(origin, allowedOrigin));
+  const candidateOrigins: SDK.SecurityOrigin.SecurityOrigin[] =
+      (Array.isArray(requestedOrigins) && requestedOrigins.length > 0) ?
+      requestedOrigins.map(origin => SDK.SecurityOrigin.SecurityOrigin.create(origin)) :
+      [establishedOrigin];
+
+  const validOrigins =
+      candidateOrigins.filter(origin => origin.isSameOriginWith(establishedOrigin)).map(origin => origin.siteId());
+
   const targetOrigins = Array.from(new Set(validOrigins)).slice(0, MAX_TARGET_ORIGINS);
   if (targetOrigins.length === 0) {
     return {error: 'No valid origins found.'};
@@ -72,36 +82,16 @@ export type GetCookiesForOriginResult = {
 };
 
 /**
- * Finds the resource tree frame matching the target origin within the primary page's outermost target tree.
- */
-export function findFrameForOrigin(
-    origin: string,
-    targetManager: SDK.TargetManager.TargetManager,
-    primaryPageTarget: SDK.Target.Target,
-    ): SDK.ResourceTreeModel.ResourceTreeFrame|null {
-  const targetOrigin = extractContextOrigin(origin);
-  for (const frame of SDK.ResourceTreeModel.ResourceTreeModel.frames(targetManager)) {
-    if (frame.resourceTreeModel().target().outermostTarget() !== primaryPageTarget) {
-      continue;
-    }
-    if (frame.securityOrigin && areOriginsEquivalent(frame.securityOrigin, targetOrigin)) {
-      return frame;
-    }
-  }
-  return null;
-}
-
-/**
- * Retrieves all cookies accessible to the target origin, strictly excluding HttpOnly cookies.
+ * Retrieves all cookies accessible to the target origin, excluding HttpOnly cookies.
  * Locates the matching frame within the primary page target tree, queries its CookieModel,
  * and filters cookies by security origin.
  */
 export async function getCookiesForOrigin(
     origin: string,
-    targetManager: SDK.TargetManager.TargetManager,
     primaryPageTarget: SDK.Target.Target,
     ): Promise<GetCookiesForOriginResult> {
-  const frame = findFrameForOrigin(origin, targetManager, primaryPageTarget);
+  const targetOrigin = SDK.SecurityOrigin.SecurityOrigin.create(origin);
+  const frame = SDK.ResourceTreeModel.ResourceTreeModel.frameForOrigin(primaryPageTarget, targetOrigin);
   if (!frame) {
     return {error: `Frame not found or origin disallowed for ${origin}`};
   }

package/front_end/models/ai_assistance/tools/DOMStorageUtils.ts

@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 import * as SDK from '../../../core/sdk/sdk.js';
-import {areOriginsEquivalent, extractContextOrigin} from '../AiOrigins.js';
 
 /**
  * Maximum number of target origins allowed in a single batch query to bound
@@ -42,7 +41,10 @@ export function resolveDOMStorages(
   const resolvedStorages: SDK.DOMStorageModel.DOMStorage[] = [];
   const seenStorageKeys = new Set<string>();
   const isLocalStorage = type === 'localStorage';
-  const targetOrigin = extractContextOrigin(origin);
+  const targetOrigin = SDK.SecurityOrigin.SecurityOrigin.create(origin);
+  if (targetOrigin.isOpaque()) {
+    return [];
+  }
 
   const domStorageModels = targetManager.models(SDK.DOMStorageModel.DOMStorageModel);
   for (const domStorageModel of domStorageModels) {
@@ -78,7 +80,8 @@ export function resolveDOMStorages(
       // Parse the serialized StorageKey (e.g. "https://example.com/^0https://top.com") to
       // extract the partition's origin for equivalence comparison.
       const parsedKey = SDK.StorageKeyManager.parseStorageKey(currentStorageKey);
-      if (areOriginsEquivalent(parsedKey.origin, targetOrigin)) {
+      const parsedOrigin = SDK.SecurityOrigin.SecurityOrigin.create(parsedKey.origin);
+      if (parsedOrigin.isSameOriginWith(targetOrigin)) {
         resolvedStorages.push(storage);
       }
     }