@gabrielbryk/arc-devtools-mcp 1.3.0

package/build/src/tools/tools.js

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as consoleTools from './console.js';
+import * as emulationTools from './emulation.js';
+import * as extensionTools from './extensions.js';
+import * as inputTools from './input.js';
+import * as lighthouseTools from './lighthouse.js';
+import * as memoryTools from './memory.js';
+import * as networkTools from './network.js';
+import * as pagesTools from './pages.js';
+import * as performanceTools from './performance.js';
+import * as screencastTools from './screencast.js';
+import * as screenshotTools from './screenshot.js';
+import * as scriptTools from './script.js';
+import * as slimTools from './slim/tools.js';
+import * as snapshotTools from './snapshot.js';
+import * as thirdPartyDeveloperTools from './thirdPartyDeveloper.js';
+import * as webmcpTools from './webmcp.js';
+export const createTools = (args) => {
+    const rawTools = args.slim
+        ? Object.values(slimTools)
+        : [
+            ...Object.values(consoleTools),
+            ...Object.values(emulationTools),
+            ...Object.values(extensionTools),
+            ...Object.values(inputTools),
+            ...Object.values(lighthouseTools),
+            ...Object.values(memoryTools),
+            ...Object.values(networkTools),
+            ...Object.values(pagesTools),
+            ...Object.values(performanceTools),
+            ...Object.values(screencastTools),
+            ...Object.values(screenshotTools),
+            ...Object.values(scriptTools),
+            ...Object.values(snapshotTools),
+            ...Object.values(thirdPartyDeveloperTools),
+            ...Object.values(webmcpTools),
+        ];
+    const tools = [];
+    for (const tool of rawTools) {
+        if (typeof tool === 'function') {
+            tools.push(tool(args));
+        }
+        else {
+            tools.push(tool);
+        }
+    }
+    tools.sort((a, b) => {
+        return a.name.localeCompare(b.name);
+    });
+    return tools;
+};
+//# sourceMappingURL=tools.js.map

package/build/src/tools/webmcp.js

@@ -0,0 +1,66 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+export const listWebMcpTools = definePageTool({
+    name: 'list_webmcp_tools',
+    description: `Lists all WebMCP tools the page exposes.`,
+    annotations: {
+        category: ToolCategory.WEBMCP,
+        readOnlyHint: true,
+    },
+    schema: {},
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    handler: async (_request, response, _context) => {
+        response.setListWebMcpTools();
+    },
+});
+export const executeWebMcpTool = definePageTool({
+    name: 'execute_webmcp_tool',
+    description: `Executes a WebMCP tool exposed by the page.`,
+    annotations: {
+        category: ToolCategory.WEBMCP,
+        readOnlyHint: false,
+    },
+    schema: {
+        toolName: zod.string().describe('The name of the WebMCP tool to execute'),
+        input: zod
+            .string()
+            .optional()
+            .describe('The JSON-stringified parameters to pass to the WebMCP tool'),
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    handler: async (request, response) => {
+        const toolName = request.params.toolName;
+        let input = {};
+        if (request.params.input) {
+            try {
+                const parsed = JSON.parse(request.params.input);
+                if (typeof parsed === 'object' && parsed !== null) {
+                    input = parsed;
+                }
+                else {
+                    throw new Error('Parsed input is not an object');
+                }
+            }
+            catch (e) {
+                const errorMessage = e instanceof Error ? e.message : String(e);
+                throw new Error(`Failed to parse input as JSON: ${errorMessage}`);
+            }
+        }
+        const tools = request.page.pptrPage.webmcp.tools();
+        const tool = tools.find(t => t.name === toolName);
+        if (!tool) {
+            throw new Error(`Tool ${toolName} not found`);
+        }
+        const { status, output, errorText } = await tool.execute(input);
+        response.appendResponseLine(JSON.stringify({ status, output, errorText }, null, 2));
+    },
+});
+//# sourceMappingURL=webmcp.js.map

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

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { logger } from '../logger.js';
+import { DevTools } from '../third_party/index.js';
+const engine = DevTools.TraceEngine.TraceModel.Model.createWithAllHandlers();
+export function traceResultIsSuccess(x) {
+    return 'parsedTrace' in x;
+}
+export async function parseRawTraceBuffer(buffer, metadata) {
+    engine.resetProcessor();
+    if (!buffer) {
+        return {
+            error: 'No buffer was provided.',
+        };
+    }
+    const asString = new TextDecoder().decode(buffer);
+    if (!asString) {
+        return {
+            error: 'Decoding the trace buffer returned an empty string.',
+        };
+    }
+    try {
+        const data = JSON.parse(asString);
+        const events = Array.isArray(data) ? data : data.traceEvents;
+        await engine.parse(events, { metadata });
+        const parsedTrace = engine.parsedTrace();
+        if (!parsedTrace) {
+            return {
+                error: 'No parsed trace was returned from the trace engine.',
+            };
+        }
+        const insights = parsedTrace?.insights ?? null;
+        return {
+            parsedTrace,
+            insights,
+        };
+    }
+    catch (e) {
+        const errorText = e instanceof Error ? e.message : JSON.stringify(e);
+        logger?.(`Unexpected error parsing trace: ${errorText}`);
+        return {
+            error: errorText,
+        };
+    }
+}
+const extraFormatDescriptions = `Information on performance traces may contain main thread activity represented as call frames and network requests.
+
+${DevTools.PerformanceTraceFormatter.callFrameDataFormatDescription}
+
+${DevTools.PerformanceTraceFormatter.networkDataFormatDescription}`;
+export function getTraceSummary(result, deviceScope) {
+    const focus = DevTools.AgentFocus.fromParsedTrace(result.parsedTrace);
+    const formatter = new DevTools.PerformanceTraceFormatter(focus, deviceScope);
+    const summaryText = formatter.formatTraceSummary();
+    return `## Summary of Performance trace findings:
+${summaryText}
+
+## Details on call tree & network request formats:
+${extraFormatDescriptions}`;
+}
+export function getInsightOutput(result, insightSetId, insightName, deviceScope) {
+    if (!result.insights) {
+        return {
+            error: 'No Performance insights are available for this trace.',
+        };
+    }
+    const insightSet = result.insights.get(insightSetId);
+    if (!insightSet) {
+        return {
+            error: 'No Performance Insights for the given insight set id. Only use ids given in the "Available insight sets" list.',
+        };
+    }
+    const matchingInsight = insightName in insightSet.model ? insightSet.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.`,
+        };
+    }
+    const formatter = new DevTools.PerformanceInsightFormatter(DevTools.AgentFocus.fromParsedTrace(result.parsedTrace), matchingInsight, deviceScope);
+    return { output: formatter.formatInsight() };
+}
+//# sourceMappingURL=parse.js.map

package/build/src/types.js

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/build/src/utils/check-for-updates.js

@@ -0,0 +1,74 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import child_process from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { semver } from '../third_party/index.js';
+import { VERSION } from '../version.js';
+/**
+ * Notifies the user if an update is available.
+ * @param message The message to display in the update notification.
+ */
+let isChecking = false;
+/** @internal Reset flag for tests only. */
+export function resetUpdateCheckFlagForTesting() {
+    isChecking = false;
+}
+export async function checkForUpdates(message) {
+    if (isChecking || process.env['CHROME_DEVTOOLS_MCP_NO_UPDATE_CHECKS']) {
+        return;
+    }
+    isChecking = true;
+    const cachePath = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', 'latest.json');
+    let cachedVersion;
+    let stats;
+    try {
+        stats = await fs.stat(cachePath);
+        const data = await fs.readFile(cachePath, 'utf8');
+        cachedVersion = JSON.parse(data).version;
+    }
+    catch {
+        // Ignore errors reading cache.
+    }
+    if (cachedVersion && semver.lt(VERSION, cachedVersion)) {
+        console.warn(`\nUpdate available: ${VERSION} -> ${cachedVersion}\n${message}\n`);
+    }
+    const now = Date.now();
+    if (stats && now - stats.mtimeMs < 24 * 60 * 60 * 1000) {
+        return;
+    }
+    // Update mtime immediately to prevent multiple subprocesses.
+    try {
+        const parentDir = path.dirname(cachePath);
+        await fs.mkdir(parentDir, { recursive: true });
+        const nowTime = new Date();
+        if (stats) {
+            await fs.utimes(cachePath, nowTime, nowTime);
+        }
+        else {
+            await fs.writeFile(cachePath, JSON.stringify({ version: VERSION }));
+        }
+    }
+    catch {
+        // Ignore errors.
+    }
+    // In a separate process, check the latest available version number
+    // and update the local snapshot accordingly.
+    const scriptPath = path.join(import.meta.dirname, '..', 'bin', 'check-latest-version.js');
+    try {
+        const child = child_process.spawn(process.execPath, [scriptPath, cachePath], {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
+    catch {
+        // Fail silently in case of any errors.
+    }
+}
+//# sourceMappingURL=check-for-updates.js.map

package/build/src/utils/files.js

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+export async function getTempFilePath(filename) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'chrome-devtools-mcp-'));
+    const filepath = path.join(dir, filename);
+    return filepath;
+}
+export function ensureExtension(filepath, extension) {
+    const ext = path.extname(filepath);
+    return filepath.slice(0, filepath.length - ext.length) + extension;
+}
+export async function resolveCanonicalPath(filePath) {
+    const absolutePath = path.resolve(filePath);
+    try {
+        // Get the true canonical path, resolving all symlinks.
+        return await fs.realpath(absolutePath);
+    }
+    catch (err) {
+        if (err &&
+            typeof err === 'object' &&
+            'code' in err &&
+            err.code === 'ENOENT') {
+            // Find the nearest existing ancestor directory on the filesystem.
+            let current = absolutePath;
+            const missingSegments = [];
+            while (true) {
+                const parent = path.dirname(current);
+                if (parent === current) {
+                    // Reached root directory but still couldn't resolve anything.
+                    throw err;
+                }
+                try {
+                    const canonicalParent = await fs.realpath(parent);
+                    return path.join(canonicalParent, path.basename(current), ...missingSegments);
+                }
+                catch (parentErr) {
+                    if (parentErr &&
+                        typeof parentErr === 'object' &&
+                        'code' in parentErr &&
+                        parentErr.code === 'ENOENT') {
+                        missingSegments.unshift(path.basename(current));
+                        current = parent;
+                    }
+                    else {
+                        throw parentErr;
+                    }
+                }
+            }
+        }
+        else {
+            throw err;
+        }
+    }
+}
+//# sourceMappingURL=files.js.map

package/build/src/utils/id.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function createIdGenerator() {
+    let i = 1;
+    return () => {
+        if (i === Number.MAX_SAFE_INTEGER) {
+            i = 0;
+        }
+        return i++;
+    };
+}
+export const stableIdSymbol = Symbol('stableIdSymbol');
+//# sourceMappingURL=id.js.map

package/build/src/utils/keyboard.js

@@ -0,0 +1,297 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// See the KeyInput type for the list of supported keys.
+const validKeys = new Set([
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    'Power',
+    'Eject',
+    'Abort',
+    'Help',
+    'Backspace',
+    'Tab',
+    'Numpad5',
+    'NumpadEnter',
+    'Enter',
+    '\r',
+    '\n',
+    'ShiftLeft',
+    'ShiftRight',
+    'ControlLeft',
+    'ControlRight',
+    'AltLeft',
+    'AltRight',
+    'Pause',
+    'CapsLock',
+    'Escape',
+    'Convert',
+    'NonConvert',
+    'Space',
+    'Numpad9',
+    'PageUp',
+    'Numpad3',
+    'PageDown',
+    'End',
+    'Numpad1',
+    'Home',
+    'Numpad7',
+    'ArrowLeft',
+    'Numpad4',
+    'Numpad8',
+    'ArrowUp',
+    'ArrowRight',
+    'Numpad6',
+    'Numpad2',
+    'ArrowDown',
+    'Select',
+    'Open',
+    'PrintScreen',
+    'Insert',
+    'Numpad0',
+    'Delete',
+    'NumpadDecimal',
+    'Digit0',
+    'Digit1',
+    'Digit2',
+    'Digit3',
+    'Digit4',
+    'Digit5',
+    'Digit6',
+    'Digit7',
+    'Digit8',
+    'Digit9',
+    'KeyA',
+    'KeyB',
+    'KeyC',
+    'KeyD',
+    'KeyE',
+    'KeyF',
+    'KeyG',
+    'KeyH',
+    'KeyI',
+    'KeyJ',
+    'KeyK',
+    'KeyL',
+    'KeyM',
+    'KeyN',
+    'KeyO',
+    'KeyP',
+    'KeyQ',
+    'KeyR',
+    'KeyS',
+    'KeyT',
+    'KeyU',
+    'KeyV',
+    'KeyW',
+    'KeyX',
+    'KeyY',
+    'KeyZ',
+    'MetaLeft',
+    'MetaRight',
+    'ContextMenu',
+    'NumpadMultiply',
+    'NumpadAdd',
+    'NumpadSubtract',
+    'NumpadDivide',
+    'F1',
+    'F2',
+    'F3',
+    'F4',
+    'F5',
+    'F6',
+    'F7',
+    'F8',
+    'F9',
+    'F10',
+    'F11',
+    'F12',
+    'F13',
+    'F14',
+    'F15',
+    'F16',
+    'F17',
+    'F18',
+    'F19',
+    'F20',
+    'F21',
+    'F22',
+    'F23',
+    'F24',
+    'NumLock',
+    'ScrollLock',
+    'AudioVolumeMute',
+    'AudioVolumeDown',
+    'AudioVolumeUp',
+    'MediaTrackNext',
+    'MediaTrackPrevious',
+    'MediaStop',
+    'MediaPlayPause',
+    'Semicolon',
+    'Equal',
+    'NumpadEqual',
+    'Comma',
+    'Minus',
+    'Period',
+    'Slash',
+    'Backquote',
+    'BracketLeft',
+    'Backslash',
+    'BracketRight',
+    'Quote',
+    'AltGraph',
+    'Props',
+    'Cancel',
+    'Clear',
+    'Shift',
+    'Control',
+    'Alt',
+    'Accept',
+    'ModeChange',
+    ' ',
+    'Print',
+    'Execute',
+    '\u0000',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    'Meta',
+    '*',
+    '+',
+    '-',
+    '/',
+    ';',
+    '=',
+    ',',
+    '.',
+    '`',
+    '[',
+    '\\',
+    ']',
+    "'",
+    'Attn',
+    'CrSel',
+    'ExSel',
+    'EraseEof',
+    'Play',
+    'ZoomOut',
+    ')',
+    '!',
+    '@',
+    '#',
+    '$',
+    '%',
+    '^',
+    '&',
+    '(',
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    ':',
+    '<',
+    '_',
+    '>',
+    '?',
+    '~',
+    '{',
+    '|',
+    '}',
+    '"',
+    'SoftLeft',
+    'SoftRight',
+    'Camera',
+    'Call',
+    'EndCall',
+    'VolumeDown',
+    'VolumeUp',
+]);
+function throwIfInvalidKey(key) {
+    if (validKeys.has(key)) {
+        return key;
+    }
+    throw new Error(`${key} is invalid. Valid keys are: ${Array.from(validKeys.values()).join(',')}.`);
+}
+/**
+ * Returns the primary key, followed by modifiers in original order.
+ */
+export function parseKey(keyInput) {
+    let key = '';
+    const result = [];
+    for (const ch of keyInput) {
+        // Handle cases like Shift++.
+        if (ch === '+' && key) {
+            result.push(throwIfInvalidKey(key));
+            key = '';
+        }
+        else {
+            key += ch;
+        }
+    }
+    if (key) {
+        result.push(throwIfInvalidKey(key));
+    }
+    if (result.length === 0) {
+        throw new Error(`Key ${keyInput} could not be parsed.`);
+    }
+    if (new Set(result).size !== result.length) {
+        throw new Error(`Key ${keyInput} contains duplicate keys.`);
+    }
+    return [result.at(-1), ...result.slice(0, -1)];
+}
+//# sourceMappingURL=keyboard.js.map