chrome-devtools-frontend 1.0.1696961 → 1.0.1697998

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

@@ -14,6 +14,7 @@ import {
   type DataTool,
   isOriginAllowedByLock,
   type OriginLockCapability,
+  resolveOriginFromLock,
   ToolName,
 } from './Tool.js';
 
@@ -76,12 +77,12 @@ export class ListNetworkRequestsTool implements
     const requests: NetworkRequestSummary[] = [];
     // A conversation is locked to an origin once the first query is made.
     // We only allow inspecting requests matching the conversation's established origin.
-    const establishedOrigin = context.getEstablishedOrigin();
-    if (!establishedOrigin || establishedOrigin.isOpaque()) {
-      return {
-        error: 'Opaque origin not allowed',
-      };
+    const originLock = context.getOriginLock();
+    const originResult = resolveOriginFromLock(originLock);
+    if ('error' in originResult) {
+      return originResult;
     }
+    const establishedOrigin = originResult.origin;
 
     // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     const networkLog = this.#networkLog ?? Logs.NetworkLog.NetworkLog.instance();
@@ -89,7 +90,7 @@ export class ListNetworkRequestsTool implements
     const requestsToShow: SDK.NetworkRequest.NetworkRequest[] = [];
     for (const request of networkLog.requests()) {
       // If the request's initiator origin does not match the locked origin, skip it.
-      if (!isOriginAllowedByLock(establishedOrigin, request.initiatorSecurityOrigin())) {
+      if (!isOriginAllowedByLock(originLock, request.initiatorSecurityOrigin())) {
         hasCrossOriginRequest = true;
         continue;
       }

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

@@ -10,7 +10,9 @@ import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  isOriginAllowedByLock,
   type OriginLockCapability,
+  resolveOriginFromLock,
   ToolName,
 } from './Tool.js';
 
@@ -57,14 +59,15 @@ export class ListPageOriginsTool implements
     const targetManager = SDK.TargetManager.TargetManager.instance();
     const primaryPageTarget = targetManager.primaryPageTarget();
 
-    const establishedOrigin = context.getEstablishedOrigin();
-    if (!establishedOrigin || establishedOrigin.isOpaque()) {
-      return {error: 'No origin available or not allowed.'};
+    const originLock = context.getOriginLock();
+    const originResult = resolveOriginFromLock(originLock);
+    if ('error' in originResult) {
+      return originResult;
     }
 
     const pageOrigin =
         primaryPageTarget ? SDK.SecurityOrigin.SecurityOrigin.create(primaryPageTarget.inspectedURL()) : null;
-    if (!pageOrigin || !pageOrigin.isSameOriginWith(establishedOrigin)) {
+    if (!pageOrigin || !isOriginAllowedByLock(originLock, pageOrigin)) {
       return {error: 'No origin available or not allowed.'};
     }
 
@@ -77,7 +80,7 @@ export class ListPageOriginsTool implements
       // Filter out frames that are not same-origin to the page's allowed origin.
       // Under site isolation, frames can be hosted on different targets/processes,
       // so we check the security origin of the frame directly instead of the target.
-      if (!frameOrigin.isSameOriginWith(establishedOrigin)) {
+      if (!isOriginAllowedByLock(originLock, frameOrigin)) {
         continue;
       }
       if (!origins.some(existing => existing.isSameOriginWith(frameOrigin))) {

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

@@ -14,6 +14,8 @@ import {
   type DataTool,
   isOriginAllowedByLock,
   type OriginLockCapability,
+  type OriginLockState,
+  resolveOriginFromLock,
   ToolName,
 } from './Tool.js';
 
@@ -75,8 +77,9 @@ export class ListSourcesTool implements
       }
     }
 
+    const originLock: OriginLockState = {status: 'ESTABLISHED_ORIGIN', origin: establishedOrigin};
     return [...uiSourceCodes.values()].filter(
-        file => isOriginAllowedByLock(establishedOrigin, FileContext.originForUISourceCode(file)));
+        file => isOriginAllowedByLock(originLock, FileContext.originForUISourceCode(file)));
   }
 
   static getSourceById(
@@ -85,9 +88,6 @@ export class ListSourcesTool implements
       // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       workspace: Workspace.Workspace.WorkspaceImpl = Workspace.Workspace.WorkspaceImpl.instance(),
       ): Workspace.UISourceCode.UISourceCode|undefined {
-    if (establishedOrigin.isOpaque()) {
-      return undefined;
-    }
     return ListSourcesTool.getUISourceCodes(establishedOrigin, workspace)
         .find(file => ListSourcesTool.uiSourceCodeId.get(file) === id);
   }
@@ -114,14 +114,12 @@ export class ListSourcesTool implements
       _params: Record<string, never>,
       context: BaseToolCapability&OriginLockCapability,
       ): Promise<DataHandlerResult<{files: SourceSummary[]}>> {
-    const establishedOrigin = context.getEstablishedOrigin();
-    if (!establishedOrigin || establishedOrigin.isOpaque()) {
-      return {
-        error: 'Opaque origin not allowed',
-      };
+    const originResult = resolveOriginFromLock(context.getOriginLock());
+    if ('error' in originResult) {
+      return originResult;
     }
 
-    const files = ListSourcesTool.getUISourceCodes(establishedOrigin);
+    const files = ListSourcesTool.getUISourceCodes(originResult.origin);
 
     return {
       result: {

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

@@ -7,7 +7,8 @@ import * as i18n from '../../../core/i18n/i18n.js';
 import * as Platform from '../../../core/platform/platform.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 
-import {MAX_TARGET_ORIGINS, resolveDOMStorages} from './DOMStorageUtils.js';
+import {resolveAllowedTargetOrigins} from './CookieUtils.js';
+import {resolveDOMStorages} from './DOMStorageUtils.js';
 import {
   type BaseToolCapability,
   type DataHandlerResult,
@@ -98,31 +99,11 @@ export class ListStorageKeysTool implements DataTool<ListStorageKeysArgs, ListSt
 
     // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     const targetManager = SDK.TargetManager.TargetManager.instance();
-    const primaryPageTarget = targetManager.primaryPageTarget();
-
-    const establishedOrigin = context.getEstablishedOrigin();
-    if (!establishedOrigin || establishedOrigin.isOpaque()) {
-      return {error: 'No origin available or not allowed.'};
-    }
-
-    if (!primaryPageTarget) {
-      return {error: 'No origin available or not allowed.'};
-    }
-
-    const pageOrigin = primaryPageTarget.inspectedSecurityOrigin();
-    if (!pageOrigin.isSameOriginWith(establishedOrigin)) {
-      return {error: 'No origin available or not allowed.'};
-    }
-
-    const candidateOrigins: SDK.SecurityOrigin.SecurityOrigin[] = (args.origins && args.origins.length > 0) ?
-        args.origins.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.'};
+    const targetOriginsResult = resolveAllowedTargetOrigins(args.origins, context, targetManager);
+    if ('error' in targetOriginsResult) {
+      return {error: targetOriginsResult.error};
     }
+    const {targetOrigins, primaryPageTarget} = targetOriginsResult;
 
     const storageKey = (targetOrigins.length === 1 && args.storageKey) ? args.storageKey : undefined;
     const storageKeysByOrigin: ListStorageKeysResult['storageKeysByOrigin'] = {};

package/front_end/models/ai_assistance/tools/README.md

@@ -16,10 +16,12 @@ Instead of passing a monolithic "grab-bag" context object to all tool handlers,
 - `BaseToolCapability`: Base interface providing access to the top-level conversation context step.
 - `PageExecutionCapability`: For tools executing JavaScript code on the inspected page.
 - `StyleMutationCapability`: For tools managing and applying style mutations via a `ChangeManager`.
-- `OriginLockCapability`: Enforces origin boundaries for tools that access inspected page state or resources. Tools verify targets against the established origin before reading data to prevent unauthorized cross-origin access.
-  - For DOM nodes and source files: wrap the target in a context helper (such as `DOMNodeContext` or `FileContext`) and call `isOriginAllowed(establishedOrigin)`.
+- `OriginLockCapability`: Enforces origin boundaries for tools that access inspected page state or resources via `getOriginLock(): OriginLockState` (`ESTABLISHED_ORIGIN`, `BLOCKED_BY_NAVIGATION`, or `UNINITIALIZED`).
+  - Tools check for `BLOCKED_BY_NAVIGATION` (cross-origin navigation during the run) and `UNINITIALIZED` (no lock established yet) states and return appropriate errors.
+  - For DOM nodes, source files, and execution contexts: validate target origins using `isOriginAllowedByLock(originLock, targetOrigin)`.
   - For cookies and DOM storage: validate target origins using `resolveAllowedTargetOrigins()`.
-  - For network requests: compare `request.initiatorSecurityOrigin()` to the established origin.
+  - For network requests: compare request initiators using `isOriginAllowedByLock(originLock, request.initiatorSecurityOrigin())`.
+  - Transition from legacy V1: Tools no longer inspect context wrappers (such as `DOMNodeContext.isOriginAllowed()`). Tools validate `SecurityOrigin` instances directly against `OriginLockState`. Legacy V1 agents provide an adapter callback in their tool invocation contexts to satisfy `OriginLockCapability`.
 
 ### Unified Context
 

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

@@ -108,10 +108,9 @@ export class ResolveDevtoolsNodePathTool implements DataTool<ResolveDevtoolsNode
       return {error: 'Error: Could not retrieve resolved node.'};
     }
 
-    const establishedOrigin = context.getEstablishedOrigin();
     // Security check: Ensure the resolved node belongs to the same origin
     // that this AI assistance session is locked to, preventing cross-origin access.
-    if (!isOriginAllowedByLock(establishedOrigin, node.securityOrigin())) {
+    if (!isOriginAllowedByLock(context.getOriginLock(), node.securityOrigin())) {
       return {error: 'Error: Node does not belong to the current origin.'};
     }
 

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

@@ -113,43 +113,81 @@ export interface TargetCapability {
    * so tools can resolve DOM nodes and frame hierarchies across frames.
    *
    * Tools that consume this target must independently validate the security origin of
-   * any resolved entities (e.g. via `node.securityOrigin()`) against `getEstablishedOrigin()`.
+   * any resolved entities (e.g. via `node.securityOrigin()`) against `getOriginLock()`.
    */
   getTarget(): SDK.Target.Target|null;
 }
 
+/**
+ * Origin-locking state for AI Assistance:
+ * - `ESTABLISHED_ORIGIN`: The conversation is bound to a specific origin. Operations are
+ *   limited to this origin.
+ * - `BLOCKED_BY_NAVIGATION`: An unapproved cross-origin navigation occurred during the
+ *   active run. Origin-restricted operations are blocked and must return an error.
+ * - `UNINITIALIZED`: No origin lock has been established yet. Operations requiring a locked
+ *   origin must return an error.
+ */
+export type OriginLockState = {
+  status: 'ESTABLISHED_ORIGIN',
+  origin: SDK.SecurityOrigin.SecurityOrigin,
+}|{
+  status: 'BLOCKED_BY_NAVIGATION',
+}|{
+  status: 'UNINITIALIZED',
+};
+
 /**
  * Capability for tools that enforce conversation origin boundaries.
  */
 export interface OriginLockCapability {
   /**
-   * Returns the security origin locked for the current conversation.
-   *
-   * TODO: When V1 agents (StylingAgent, AccessibilityAgent) are removed,
-   * simplify getEstablishedOrigin() to return SDK.SecurityOrigin.SecurityOrigin
-   * non-optionally.
-   *
-   * @returns The established {@link SDK.SecurityOrigin.SecurityOrigin}, or `undefined`
-   * if the conversation is not yet locked to an origin (e.g. before the first query).
+   * Returns the current origin-locking state for the active conversation.
    */
-  getEstablishedOrigin(): SDK.SecurityOrigin.SecurityOrigin|undefined;
+  getOriginLock(): OriginLockState;
 }
 
 /**
  * Checks whether a target origin matches the established conversation origin lock.
- * Fails closed (returns false) if established origin is missing/opaque or target is cross-origin.
+ * Returns `false` if the lock is not established, either origin is opaque, or the
+ * target origin does not match the established origin.
  */
 export function isOriginAllowedByLock(
-    establishedOrigin: SDK.SecurityOrigin.SecurityOrigin|undefined,
+    originLock: OriginLockState,
     targetOrigin: SDK.SecurityOrigin.SecurityOrigin|null|undefined,
     ): boolean {
-  if (!establishedOrigin || establishedOrigin.isOpaque()) {
+  if (originLock.status !== 'ESTABLISHED_ORIGIN') {
+    return false;
+  }
+  if (originLock.origin.isOpaque()) {
     return false;
   }
   if (!targetOrigin || targetOrigin.isOpaque()) {
     return false;
   }
-  return targetOrigin.isSameOriginWith(establishedOrigin);
+  return targetOrigin.isSameOriginWith(originLock.origin);
+}
+
+/**
+ * Resolves the conversation's established origin from the origin lock state.
+ * Returns an error object if origin access is blocked by navigation, the lock
+ * is uninitialized, or the established origin is opaque.
+ */
+export function resolveOriginFromLock(
+    originLock: OriginLockState,
+    ): {origin: SDK.SecurityOrigin.SecurityOrigin}|{
+  error: string,
+}
+{
+  if (originLock.status === 'BLOCKED_BY_NAVIGATION') {
+    return {error: 'Cross-origin access blocked due to navigation.'};
+  }
+  if (originLock.status === 'UNINITIALIZED') {
+    return {error: 'No origin established for this conversation.'};
+  }
+  if (originLock.origin.isOpaque()) {
+    return {error: 'No origin available or not allowed.'};
+  }
+  return {origin: originLock.origin};
 }
 
 /**
@@ -220,8 +258,8 @@ export const enum ToolName {
   GET_TRACE_NETWORK_SUMMARY = 'getTraceNetworkSummary',
   RUN_LIGHTHOUSE = 'runLighthouse',
   GET_DETAILED_CALL_TREE = 'getDetailedCallTree',
-  GET_FUNCTION_CODE = 'getFunctionCode',
-  GET_RESOURCE_CONTENT = 'getResourceContent',
+  GET_TRACE_FUNCTION_CODE = 'getTraceFunctionCode',
+  GET_TRACE_RESOURCE_CONTENT = 'getTraceResourceContent',
   GET_INSIGHT_DETAILS = 'getInsightDetails',
   GET_STORAGE_BREAKDOWN = 'getStorageBreakdown',
 }

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

@@ -6,18 +6,18 @@ import {ExecuteJavaScriptTool} from './ExecuteJavaScript.js';
 import {GetCookieValuesTool} from './GetCookieValues.js';
 import {GetDetailedCallTreeTool} from './GetDetailedCallTree.js';
 import {GetElementAccessibilityDetailsTool} from './GetElementAccessibilityDetails.js';
-import {GetFunctionCodeTool} from './GetFunctionCode.js';
 import {GetInsightDetailsTool} from './GetInsightDetails.js';
 import {GetLighthouseAuditsTool} from './GetLighthouseAudits.js';
 import {GetNetworkRequestDetailsTool} from './GetNetworkRequestDetails.js';
-import {GetResourceContentTool} from './GetResourceContent.js';
 import {GetSourceContentTool} from './GetSourceContent.js';
 import {GetStorageBreakdownTool} from './GetStorageBreakdown.js';
 import {GetStorageValuesTool} from './GetStorageValues.js';
 import {GetStylesTool} from './GetStyles.js';
 import {GetTraceEventByKeyTool} from './GetTraceEventByKey.js';
+import {GetTraceFunctionCodeTool} from './GetTraceFunctionCode.js';
 import {GetTraceMainThreadSummaryTool} from './GetTraceMainThreadSummary.js';
 import {GetTraceNetworkSummaryTool} from './GetTraceNetworkSummary.js';
+import {GetTraceResourceContentTool} from './GetTraceResourceContent.js';
 import {ListCookiesTool} from './ListCookies.js';
 import {ListNetworkRequestsTool} from './ListNetworkRequests.js';
 import {ListPageOriginsTool} from './ListPageOrigins.js';
@@ -51,8 +51,8 @@ export interface BaseToolsRegistryMap {
   [ToolName.GET_TRACE_NETWORK_SUMMARY]: GetTraceNetworkSummaryTool;
   [ToolName.RUN_LIGHTHOUSE]: RunLighthouseTool;
   [ToolName.GET_DETAILED_CALL_TREE]: GetDetailedCallTreeTool;
-  [ToolName.GET_FUNCTION_CODE]: GetFunctionCodeTool;
-  [ToolName.GET_RESOURCE_CONTENT]: GetResourceContentTool;
+  [ToolName.GET_TRACE_FUNCTION_CODE]: GetTraceFunctionCodeTool;
+  [ToolName.GET_TRACE_RESOURCE_CONTENT]: GetTraceResourceContentTool;
   [ToolName.GET_INSIGHT_DETAILS]: GetInsightDetailsTool;
   [ToolName.GET_STORAGE_BREAKDOWN]: GetStorageBreakdownTool;
 }
@@ -86,8 +86,8 @@ export const TOOLS: BaseToolsRegistryMap = {
   [ToolName.GET_TRACE_NETWORK_SUMMARY]: new GetTraceNetworkSummaryTool(),
   [ToolName.RUN_LIGHTHOUSE]: new RunLighthouseTool(),
   [ToolName.GET_DETAILED_CALL_TREE]: new GetDetailedCallTreeTool(),
-  [ToolName.GET_FUNCTION_CODE]: new GetFunctionCodeTool(),
-  [ToolName.GET_RESOURCE_CONTENT]: new GetResourceContentTool(),
+  [ToolName.GET_TRACE_FUNCTION_CODE]: new GetTraceFunctionCodeTool(),
+  [ToolName.GET_TRACE_RESOURCE_CONTENT]: new GetTraceResourceContentTool(),
   [ToolName.GET_INSIGHT_DETAILS]: new GetInsightDetailsTool(),
   [ToolName.GET_STORAGE_BREAKDOWN]: new GetStorageBreakdownTool(),
 };

package/front_end/models/change_tracker/ChangeTracker.ts

@@ -0,0 +1,89 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Root from '../../core/root/root.js';
+import type * as CommentManager from '../comment_manager/comment_manager.js';
+
+export type ChangeRecord = CommentManager.CommentManager.ChangeRecord;
+
+export const MAX_RECORDS = 1000;
+
+export class ChangeTracker {
+  readonly #records = new Map<string, ChangeRecord>();
+  readonly #commentManager: CommentManager.CommentManager.CommentManager;
+  readonly #maxRecords: number;
+  #lastRecord?: ChangeRecord;
+
+  constructor(commentManager: CommentManager.CommentManager.CommentManager, maxRecords: number = MAX_RECORDS) {
+    this.#commentManager = commentManager;
+    this.#maxRecords = Math.max(1, maxRecords);
+  }
+
+  get maxRecords(): number {
+    return this.#maxRecords;
+  }
+
+  get isTracking(): boolean {
+    return Boolean(Root.Runtime.hostConfig.devToolsComments?.enabled);
+  }
+
+  trackChange(
+      description: string,
+      anchor: CommentManager.CommentManager.CommentAnchorSignature,
+      ): ChangeRecord|null {
+    if (!this.isTracking) {
+      return null;
+    }
+    const record: ChangeRecord = {
+      id: crypto.randomUUID(),
+      description,
+      timestamp: Date.now(),
+    };
+    while (this.#records.size >= this.#maxRecords) {
+      this.#evictOldestRecord();
+    }
+
+    const thread = this.#commentManager.createCommentThread(anchor, undefined, undefined, [record]);
+    this.#records.set(thread.id, record);
+    this.#lastRecord = record;
+    return record;
+  }
+
+  #evictOldestRecord(): void {
+    // Delete the oldest record for which the comment thread has no user comments.
+    // If all comment threads have user comments, delete the oldest record.
+    for (const threadId of this.#records.keys()) {
+      const thread = this.#commentManager.getCommentThread(threadId);
+      if (!thread || thread.comments.length === 0) {
+        this.#commentManager.removeCommentThread(threadId);
+        this.#records.delete(threadId);
+        return;
+      }
+    }
+
+    const oldestThreadId = this.#records.keys().next().value;
+    if (oldestThreadId) {
+      this.#records.delete(oldestThreadId);
+    }
+  }
+
+  getChanges(): ChangeRecord[] {
+    return Array.from(this.#records.values());
+  }
+
+  getLastChange(): ChangeRecord|undefined {
+    return this.#lastRecord;
+  }
+
+  clear(): void {
+    for (const threadId of this.#records.keys()) {
+      const thread = this.#commentManager.getCommentThread(threadId);
+      if (!thread || thread.comments.length === 0) {
+        this.#commentManager.removeCommentThread(threadId);
+      }
+    }
+    this.#records.clear();
+    this.#lastRecord = undefined;
+  }
+}

package/front_end/models/change_tracker/change_tracker.ts

@@ -0,0 +1,9 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as ChangeTracker from './ChangeTracker.js';
+
+export {
+  ChangeTracker,
+};