chrome-devtools-mcp 0.0.2 → 0.2.0

package/build/node_modules/chrome-devtools-frontend/front_end/models/workspace/WorkspaceImpl.js

@@ -0,0 +1,204 @@
+// Copyright 2012 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 Common from '../../core/common/common.js';
+import { UISourceCode } from './UISourceCode.js';
+/* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
+export var projectTypes;
+(function (projectTypes) {
+    projectTypes["Debugger"] = "debugger";
+    projectTypes["Formatter"] = "formatter";
+    projectTypes["Network"] = "network";
+    projectTypes["FileSystem"] = "filesystem";
+    projectTypes["ConnectableFileSystem"] = "connectablefilesystem";
+    projectTypes["ContentScripts"] = "contentscripts";
+    projectTypes["Service"] = "service";
+})(projectTypes || (projectTypes = {}));
+/* eslint-enable @typescript-eslint/naming-convention */
+export class ProjectStore {
+    #workspace;
+    #id;
+    #type;
+    #displayName;
+    #uiSourceCodes = new Map();
+    constructor(workspace, id, type, displayName) {
+        this.#workspace = workspace;
+        this.#id = id;
+        this.#type = type;
+        this.#displayName = displayName;
+    }
+    id() {
+        return this.#id;
+    }
+    type() {
+        return this.#type;
+    }
+    displayName() {
+        return this.#displayName;
+    }
+    workspace() {
+        return this.#workspace;
+    }
+    createUISourceCode(url, contentType) {
+        return new UISourceCode(this, url, contentType);
+    }
+    addUISourceCode(uiSourceCode) {
+        const url = uiSourceCode.url();
+        if (this.uiSourceCodeForURL(url)) {
+            return false;
+        }
+        this.#uiSourceCodes.set(url, uiSourceCode);
+        this.#workspace.dispatchEventToListeners(Events.UISourceCodeAdded, uiSourceCode);
+        return true;
+    }
+    removeUISourceCode(url) {
+        const uiSourceCode = this.#uiSourceCodes.get(url);
+        if (uiSourceCode === undefined) {
+            return;
+        }
+        this.#uiSourceCodes.delete(url);
+        this.#workspace.dispatchEventToListeners(Events.UISourceCodeRemoved, uiSourceCode);
+    }
+    removeProject() {
+        this.#workspace.removeProject(this);
+        this.#uiSourceCodes.clear();
+    }
+    uiSourceCodeForURL(url) {
+        return this.#uiSourceCodes.get(url) ?? null;
+    }
+    uiSourceCodes() {
+        return this.#uiSourceCodes.values();
+    }
+    renameUISourceCode(uiSourceCode, newName) {
+        const oldPath = uiSourceCode.url();
+        const newPath = uiSourceCode.parentURL() ?
+            Common.ParsedURL.ParsedURL.urlFromParentUrlAndName(uiSourceCode.parentURL(), newName) :
+            Common.ParsedURL.ParsedURL.preEncodeSpecialCharactersInPath(newName);
+        this.#uiSourceCodes.set(newPath, uiSourceCode);
+        this.#uiSourceCodes.delete(oldPath);
+    }
+    // No-op implementation for a handful of interface methods.
+    rename(_uiSourceCode, _newName, _callback) {
+    }
+    excludeFolder(_path) {
+    }
+    deleteFile(_uiSourceCode) {
+    }
+    deleteDirectoryRecursively(_path) {
+        return Promise.resolve(false);
+    }
+    remove() {
+    }
+    indexContent(_progress) {
+    }
+}
+let workspaceInstance;
+export class WorkspaceImpl extends Common.ObjectWrapper.ObjectWrapper {
+    #projects = new Map();
+    #hasResourceContentTrackingExtensions = false;
+    constructor() {
+        super();
+    }
+    static instance(opts = { forceNew: null }) {
+        const { forceNew } = opts;
+        if (!workspaceInstance || forceNew) {
+            workspaceInstance = new WorkspaceImpl();
+        }
+        return workspaceInstance;
+    }
+    static removeInstance() {
+        workspaceInstance = undefined;
+    }
+    uiSourceCode(projectId, url) {
+        const project = this.#projects.get(projectId);
+        return project ? project.uiSourceCodeForURL(url) : null;
+    }
+    uiSourceCodeForURL(url) {
+        for (const project of this.#projects.values()) {
+            const uiSourceCode = project.uiSourceCodeForURL(url);
+            if (uiSourceCode) {
+                return uiSourceCode;
+            }
+        }
+        return null;
+    }
+    findCompatibleUISourceCodes(uiSourceCode) {
+        const url = uiSourceCode.url();
+        const contentType = uiSourceCode.contentType();
+        const result = [];
+        for (const project of this.#projects.values()) {
+            if (uiSourceCode.project().type() !== project.type()) {
+                continue;
+            }
+            const candidate = project.uiSourceCodeForURL(url);
+            if (candidate && candidate.url() === url && candidate.contentType() === contentType) {
+                result.push(candidate);
+            }
+        }
+        return result;
+    }
+    uiSourceCodesForProjectType(type) {
+        const result = [];
+        for (const project of this.#projects.values()) {
+            if (project.type() === type) {
+                for (const uiSourceCode of project.uiSourceCodes()) {
+                    result.push(uiSourceCode);
+                }
+            }
+        }
+        return result;
+    }
+    addProject(project) {
+        console.assert(!this.#projects.has(project.id()), `A project with id ${project.id()} already exists!`);
+        this.#projects.set(project.id(), project);
+        this.dispatchEventToListeners(Events.ProjectAdded, project);
+    }
+    removeProject(project) {
+        this.#projects.delete(project.id());
+        this.dispatchEventToListeners(Events.ProjectRemoved, project);
+    }
+    project(projectId) {
+        return this.#projects.get(projectId) || null;
+    }
+    projectForFileSystemRoot(root) {
+        const projectId = Common.ParsedURL.ParsedURL.rawPathToUrlString(root);
+        return this.project(projectId);
+    }
+    projects() {
+        return [...this.#projects.values()];
+    }
+    projectsForType(type) {
+        function filterByType(project) {
+            return project.type() === type;
+        }
+        return this.projects().filter(filterByType);
+    }
+    uiSourceCodes() {
+        const result = [];
+        for (const project of this.#projects.values()) {
+            for (const uiSourceCode of project.uiSourceCodes()) {
+                result.push(uiSourceCode);
+            }
+        }
+        return result;
+    }
+    setHasResourceContentTrackingExtensions(hasExtensions) {
+        this.#hasResourceContentTrackingExtensions = hasExtensions;
+    }
+    hasResourceContentTrackingExtensions() {
+        return this.#hasResourceContentTrackingExtensions;
+    }
+}
+export var Events;
+(function (Events) {
+    /* eslint-disable @typescript-eslint/naming-convention -- Used by web_tests. */
+    Events["UISourceCodeAdded"] = "UISourceCodeAdded";
+    Events["UISourceCodeRemoved"] = "UISourceCodeRemoved";
+    Events["UISourceCodeRenamed"] = "UISourceCodeRenamed";
+    Events["WorkingCopyChanged"] = "WorkingCopyChanged";
+    Events["WorkingCopyCommitted"] = "WorkingCopyCommitted";
+    Events["WorkingCopyCommittedByUser"] = "WorkingCopyCommittedByUser";
+    Events["ProjectAdded"] = "ProjectAdded";
+    Events["ProjectRemoved"] = "ProjectRemoved";
+    /* eslint-enable @typescript-eslint/naming-convention */
+})(Events || (Events = {}));

package/build/node_modules/chrome-devtools-frontend/front_end/models/workspace/workspace.js

@@ -0,0 +1,9 @@
+// Copyright 2019 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 FileManager from './FileManager.js';
+import * as IgnoreListManager from './IgnoreListManager.js';
+import * as SearchConfig from './SearchConfig.js';
+import * as UISourceCode from './UISourceCode.js';
+import * as Workspace from './WorkspaceImpl.js';
+export { FileManager, IgnoreListManager, SearchConfig, UISourceCode, Workspace, };

package/build/src/McpContext.js

@@ -11,13 +11,14 @@ export class McpContext {
     #selectedPageIdx = 0;
     // The most recent snapshot.
     #textSnapshot = null;
-    #idToNodeMap = new Map();
     #networkCollector;
     #consoleCollector;
     #isRunningTrace = false;
     #networkConditions = null;
     #cpuThrottlingRate = 1;
     #dialog;
+    #nextSnapshotId = 1;
+    #traceResults = [];
     constructor(browser, logger) {
         this.browser = browser;
         this.logger = logger;
@@ -135,10 +136,14 @@ export class McpContext {
         newPage.setDefaultNavigationTimeout(10_000);
     }
     async getElementByUid(uid) {
-        if (!this.#idToNodeMap.size) {
+        if (!this.#textSnapshot?.idToNode.size) {
             throw new Error('No snapshot found. Use browser_snapshot to capture one');
         }
-        const node = this.#idToNodeMap.get(uid);
+        const [snapshotId] = uid.split('_');
+        if (this.#textSnapshot.snapshotId !== snapshotId) {
+            throw new Error('This uid is coming from a stale snapshot. Call take_snapshot to get a fresh snapshot.');
+        }
+        const node = this.#textSnapshot?.idToNode.get(uid);
         if (!node) {
             throw new Error('No such element found in the snapshot');
         }
@@ -165,26 +170,30 @@ export class McpContext {
         const page = this.getSelectedPage();
         const rootNode = await page.accessibility.snapshot();
         if (!rootNode) {
-            return null;
+            return;
         }
+        const snapshotId = this.#nextSnapshotId++;
         // Iterate through the whole accessibility node tree and assign node ids that
         // will be used for the tree serialization and mapping ids back to nodes.
         let idCounter = 0;
-        this.#idToNodeMap.clear();
+        const idToNode = new Map();
         const assignIds = (node) => {
             const nodeWithId = {
                 ...node,
-                id: idCounter++,
+                id: `${snapshotId}_${idCounter++}`,
                 children: node.children
                     ? node.children.map(child => assignIds(child))
                     : [],
             };
-            this.#idToNodeMap.set(nodeWithId.id, nodeWithId);
+            idToNode.set(nodeWithId.id, nodeWithId);
             return nodeWithId;
         };
         const rootNodeWithId = assignIds(rootNode);
-        this.#textSnapshot = rootNodeWithId;
-        return rootNodeWithId;
+        this.#textSnapshot = {
+            root: rootNodeWithId,
+            snapshotId: String(snapshotId),
+            idToNode,
+        };
     }
     getTextSnapshot() {
         return this.#textSnapshot;
@@ -201,4 +210,10 @@ export class McpContext {
             throw new Error('Could not save a screenshot to a file');
         }
     }
+    storeTraceRecording(result) {
+        this.#traceResults.push(result);
+    }
+    recordedTraces() {
+        return this.#traceResults;
+    }
 }

package/build/src/McpResponse.js

@@ -100,9 +100,9 @@ Call browser_handle_dialog to handle it before continuing.`);
             response.push(...parts);
         }
         if (this.#includeSnapshot) {
-            const rootNode = context.getTextSnapshot();
-            if (rootNode) {
-                const formattedSnapshot = formatA11ySnapshot(rootNode);
+            const snapshot = context.getTextSnapshot();
+            if (snapshot) {
+                const formattedSnapshot = formatA11ySnapshot(snapshot.root);
                 response.push('## Page content');
                 response.push(formattedSnapshot);
             }

package/build/src/browser.js

@@ -43,7 +43,9 @@ async function ensureBrowserConnected(browserURL) {
 }
 export async function launch(options) {
     const { channel, executablePath, customDevTools, headless, isolated } = options;
-    const profileDirName = channel && channel !== 'stable' ? `mcp-profile-${channel}` : 'mcp-profile';
+    const profileDirName = channel && channel !== 'stable'
+        ? `chrome-profile-${channel}`
+        : 'chrome-profile';
     let userDataDir = options.userDataDir;
     if (!isolated && !userDataDir) {
         userDataDir = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', profileDirName);

package/build/src/index.js

@@ -137,7 +137,7 @@ async function getContext() {
         channel: args.channel,
         isolated: args.isolated,
     });
-    if (!context) {
+    if (context?.browser !== browser) {
         context = await McpContext.from(browser, logger);
     }
     return context;

package/build/src/tools/input.js

@@ -16,7 +16,7 @@ export const click = defineTool({
     },
     schema: {
         uid: z
-            .number()
+            .string()
             .describe('The uid of an element on the page from the page content snapshot'),
         dblClick: z
             .boolean()
@@ -51,7 +51,7 @@ export const hover = defineTool({
     },
     schema: {
         uid: z
-            .number()
+            .string()
             .describe('The uid of an element on the page from the page content snapshot'),
     },
     handler: async (request, response, context) => {
@@ -78,7 +78,7 @@ export const fill = defineTool({
     },
     schema: {
         uid: z
-            .number()
+            .string()
             .describe('The uid of an element on the page from the page content snapshot'),
         value: z.string().describe('The value to fill in'),
     },
@@ -104,8 +104,8 @@ export const drag = defineTool({
         readOnlyHint: false,
     },
     schema: {
-        from_uid: z.number().describe('The uid of the element to drag'),
-        to_uid: z.number().describe('The uid of the element to drop into'),
+        from_uid: z.string().describe('The uid of the element to drag'),
+        to_uid: z.string().describe('The uid of the element to drop into'),
     },
     handler: async (request, response, context) => {
         const fromHandle = await context.getElementByUid(request.params.from_uid);
@@ -135,7 +135,7 @@ export const fillForm = defineTool({
     schema: {
         elements: z
             .array(z.object({
-            uid: z.number().describe('The uid of the element to fill out'),
+            uid: z.string().describe('The uid of the element to fill out'),
             value: z.string().describe('Value for the element'),
         }))
             .describe('Elements from snapshot to fill out.'),
@@ -165,7 +165,7 @@ export const uploadFile = defineTool({
     },
     schema: {
         uid: z
-            .number()
+            .string()
             .describe('The uid of the file input element or an element that will open file chooser on the page from the page content snapshot'),
         filePath: z.string().describe('The local path of the file to upload'),
     },

package/build/src/tools/performance.js

@@ -5,7 +5,7 @@
  */
 import z from 'zod';
 import { defineTool } from './ToolDefinition.js';
-import { insightOutput, parseRawTraceBuffer } from '../trace-processing/parse.js';
+import { getInsightOutput, getTraceSummary, parseRawTraceBuffer, } from '../trace-processing/parse.js';
 import { logger } from '../logger.js';
 import { ToolCategories } from './categories.js';
 export const startTrace = defineTool({
@@ -91,13 +91,40 @@ export const stopTrace = defineTool({
         await stopTracingAndAppendOutput(page, response, context);
     },
 });
+export const analyzeInsight = defineTool({
+    name: 'performance_analyze_insight',
+    description: 'Provides more detailed information on a specific Performance Insight that was highlighed in the results of a trace recording',
+    annotations: {
+        category: ToolCategories.PERFORMANCE,
+        readOnlyHint: true,
+    },
+    schema: {
+        insightName: z
+            .string()
+            .describe('The name of the Insight you want more information on. For example: "DocumentLatency" or "LCPBreakdown"'),
+    },
+    handler: async (request, response, context) => {
+        const lastRecording = context.recordedTraces().at(-1);
+        if (!lastRecording) {
+            response.appendResponseLine('No recorded traces found. Record a performance trace so you have Insights to analyze.');
+            return;
+        }
+        const insightOutput = getInsightOutput(lastRecording, request.params.insightName);
+        if ('error' in insightOutput) {
+            response.appendResponseLine(insightOutput.error);
+            return;
+        }
+        response.appendResponseLine(insightOutput.output);
+    },
+});
 async function stopTracingAndAppendOutput(page, response, context) {
     try {
         const traceEventsBuffer = await page.tracing.stop();
         const result = await parseRawTraceBuffer(traceEventsBuffer);
         response.appendResponseLine('The performance trace has been stopped.');
         if (result) {
-            const insightText = insightOutput(result);
+            context.storeTraceRecording(result);
+            const insightText = getTraceSummary(result);
             if (insightText) {
                 response.appendResponseLine('Insights with performance opportunities:');
                 response.appendResponseLine(insightText);

package/build/src/tools/screenshot.js

@@ -19,7 +19,7 @@ export const screenshot = defineTool({
             .default('png')
             .describe('Type of format to save the screenshot as. Default is "png"'),
         uid: z
-            .number()
+            .string()
             .optional()
             .describe('The uid of an element on the page from the page content snapshot. If omitted takes a pages screenshot.'),
         fullPage: z

package/build/src/tools/script.js

@@ -9,27 +9,53 @@ import { ToolCategories } from './categories.js';
 import { waitForEventsAfterAction } from '../waitForHelpers.js';
 export const evaluateScript = defineTool({
     name: 'evaluate_script',
-    description: `Evaluate a JavaScript function inside the currently selected page. Returns the response as JSON.`,
+    description: `Evaluate a JavaScript function inside the currently selected page. Returns the response as JSON
+so returned values have to JSON-serializable.`,
     annotations: {
         category: ToolCategories.DEBUGGING,
         readOnlyHint: false,
     },
     schema: {
-        function: z
-            .string()
-            .describe('A JavaScript function to run in the currently selected page. Example: `() => {return document.title}` or `async () => {return await fetch("example.com")}`'),
+        function: z.string().describe(`A JavaScript function to run in the currently selected page.
+Example without arguments: \`() => {
+  return document.title
+}\` or \`async () => {
+  return await fetch("example.com")
+}\`.
+Example with arguments: \`(el) => {
+  return el.innerText;
+}\`
+`),
+        args: z
+            .array(z.object({
+            uid: z
+                .string()
+                .describe('The uid of an element on the page from the page content snapshot'),
+        }))
+            .optional()
+            .describe(`An optional list of arguments to pass to the function.`),
     },
     handler: async (request, response, context) => {
         const page = context.getSelectedPage();
-        const script = `(async () => {
-      return JSON.stringify(await (${request.params.function})());
-    })()`;
-        await waitForEventsAfterAction(page, async () => {
-            const result = await page.evaluate(script);
-            response.appendResponseLine('Script ran on page and returned:');
-            response.appendResponseLine('```json');
-            response.appendResponseLine(`${result}`);
-            response.appendResponseLine('```');
-        });
+        const fn = await page.evaluateHandle(`(${request.params.function})`);
+        const args = [fn];
+        try {
+            for (const el of request.params.args ?? []) {
+                args.push(await context.getElementByUid(el.uid));
+            }
+            await waitForEventsAfterAction(page, async () => {
+                const result = await page.evaluate(async (fn, ...args) => {
+                    // @ts-expect-error no types.
+                    return JSON.stringify(await fn(...args));
+                }, ...args);
+                response.appendResponseLine('Script ran on page and returned:');
+                response.appendResponseLine('```json');
+                response.appendResponseLine(`${result}`);
+                response.appendResponseLine('```');
+            });
+        }
+        finally {
+            Promise.allSettled(args.map(arg => arg.dispose())).catch(() => { });
+        }
     },
 });

package/build/src/trace-processing/parse.js

@@ -3,9 +3,11 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { PerformanceTraceFormatter } from '../../node_modules/chrome-devtools-frontend/front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatter.js';
 import { PerformanceInsightFormatter } from '../../node_modules/chrome-devtools-frontend/front_end/models/ai_assistance/data_formatters/PerformanceInsightFormatter.js';
 import * as TraceEngine from '../../node_modules/chrome-devtools-frontend/front_end/models/trace/trace.js';
 import { logger } from '../logger.js';
+import { AgentFocus } from '../../node_modules/chrome-devtools-frontend/front_end/models/ai_assistance/performance/AIContext.js';
 const engine = TraceEngine.TraceModel.Model.createWithAllHandlers();
 export async function parseRawTraceBuffer(buffer) {
     engine.resetProcessor();
@@ -43,31 +45,33 @@ export async function parseRawTraceBuffer(buffer) {
         return null;
     }
 }
-// TODO(jactkfranklin): move the formatters from DevTools to use here.
-// This is a very temporary helper to output some text from the tool call to aid development.
-export function insightOutput(result) {
+export function getTraceSummary(result) {
+    const focus = AgentFocus.full(result.parsedTrace);
+    const serializer = new TraceEngine.EventsSerializer.EventsSerializer();
+    const formatter = new PerformanceTraceFormatter(focus, serializer);
+    const output = formatter.formatTraceSummary();
+    return output;
+}
+export function getInsightOutput(result, insightName) {
+    // Currently, we do not support inspecting traces with multiple navigations. We either:
+    // 1. Find Insights from the first navigation (common case: user records a trace with a page reload to test load performance)
+    // 2. Fall back to finding Insights not associated with a navigation (common case: user tests an interaction without a page load).
     const mainNavigationId = result.parsedTrace.data.Meta.mainFrameNavigations.at(0)?.args.data
         ?.navigationId;
-    if (!mainNavigationId) {
-        return '';
-    }
-    let text = '';
-    const insightsForNav = result.insights.get(mainNavigationId);
+    const insightsForNav = result.insights.get(mainNavigationId ?? TraceEngine.Types.Events.NO_NAVIGATION);
     if (!insightsForNav) {
-        text += 'No Performance insights were found for this trace.';
-        return text;
+        return {
+            error: 'No Performance Insights for this trace.',
+        };
     }
-    const failingInsightKeys = Object.keys(insightsForNav.model).filter(insightKey => {
-        const key = insightKey;
-        const data = insightsForNav.model[key] ?? null;
-        return data?.state === 'fail';
-    });
-    logger(`Found failing Insight keys: ${failingInsightKeys.join(', ')}`);
-    for (const failingKey of failingInsightKeys) {
-        const modelData = insightsForNav.model[failingKey];
-        const formatter = new PerformanceInsightFormatter(result.parsedTrace, modelData);
-        const output = formatter.formatInsight();
-        text += `${output}\n`;
+    const matchingInsight = insightName in insightsForNav.model
+        ? insightsForNav.model[insightName]
+        : null;
+    if (!matchingInsight) {
+        return {
+            error: `No Insight with the name ${insightName} found. Double check the name you provided is accurate and try again.`,
+        };
     }
-    return text;
+    const formatter = new PerformanceInsightFormatter(result.parsedTrace, matchingInsight);
+    return { output: formatter.formatInsight() };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp",
-  "version": "0.0.2",
+  "version": "0.2.0",
   "description": "MCP server for Chrome DevTools",
   "type": "module",
   "bin": {
@@ -9,14 +9,16 @@
   "main": "index.js",
   "scripts": {
     "build": "tsc && node --experimental-strip-types scripts/post-build.ts",
+    "typecheck": "tsc --noEmit",
     "format": "eslint --cache --fix . ;prettier --write --cache .",
     "check-format": "eslint --cache .; prettier --check --cache .;",
     "generate-docs": "npm run build && node --experimental-strip-types scripts/generate-docs.ts",
     "start": "npm run build && node build/src/index.js",
     "start-debug": "DEBUG=mcp:* DEBUG_COLORS=false npm run build && node build/src/index.js",
-    "test": "npm run build && node --test-reporter spec --test-force-exit --test 'build/tests/**/*.test.js'",
-    "test:only": "npm run build && node --test-reporter spec --test-force-exit --test --test-only 'build/tests/**/*.test.js'",
-    "test:only:no-build": "node --test-reporter spec --test-force-exit --test --test-only 'build/tests/**/*.test.js'",
+    "test": "npm run build && node --require ./build/tests/setup.js --test-reporter spec --test-force-exit --test 'build/tests/**/*.test.js'",
+    "test:only": "npm run build && node --require ./build/tests/setup.js --test-reporter spec --test-force-exit --test --test-only 'build/tests/**/*.test.js'",
+    "test:only:no-build": "node --require ./build/tests/setup.js --test-reporter spec --test-force-exit --test --test-only 'build/tests/**/*.test.js'",
+    "test:update-snapshots": "npm run build && node --require ./build/tests/setup.js --test-force-exit --test --test-update-snapshots 'build/tests/**/*.test.js'",
     "prepare": "node --experimental-strip-types scripts/prepare.ts"
   },
   "files": [
@@ -35,7 +37,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.18.0",
     "debug": "4.4.3",
-    "puppeteer-core": "24.21.0",
+    "puppeteer-core": "24.22.0",
     "yargs": "18.0.0"
   },
   "devDependencies": {
@@ -47,11 +49,11 @@
     "@types/yargs": "^17.0.33",
     "@typescript-eslint/eslint-plugin": "^8.43.0",
     "@typescript-eslint/parser": "^8.43.0",
-    "chrome-devtools-frontend": "1.0.1514545",
+    "chrome-devtools-frontend": "1.0.1515796",
     "eslint": "^9.35.0",
     "globals": "^16.4.0",
     "prettier": "^3.6.2",
-    "puppeteer": "24.21.0",
+    "puppeteer": "24.22.0",
     "sinon": "^21.0.0",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.43.0"