@yezack/chrome-devtools-mcp-108 0.0.0-stage → 1.10.2

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

@@ -0,0 +1,75 @@
+/**
+ * @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',
+            windowsHide: true,
+        });
+        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,57 @@
+/**
+ * @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 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

package/build/src/utils/logger.js

@@ -0,0 +1,52 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import util from 'node:util';
+const mcpDebugNamespace = 'mcp:log';
+let logFileStream;
+const _debugLog = util.debuglog(mcpDebugNamespace);
+export function saveLogsToFile(fileName) {
+    const logFile = fs.createWriteStream(fileName, { flags: 'a+' });
+    logFile.on('error', function (error) {
+        console.error(`Error when opening/writing to log file: ${error.message}`);
+        logFile.end();
+        process.exit(1);
+    });
+    logFileStream = logFile;
+    return logFile;
+}
+export function flushLogs(logFile, timeoutMs = 2000) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(reject, timeoutMs);
+        logFile.end(() => {
+            clearTimeout(timeout);
+            resolve();
+        });
+    });
+}
+export const logger = (...args) => {
+    if (logFileStream) {
+        logFileStream.write(`${new Date().toISOString()} ${mcpDebugNamespace} ${util.format(...args)}\n`);
+    }
+    else if (_debugLog.enabled) {
+        _debugLog('%s %s', new Date().toISOString(), util.format(...args));
+    }
+};
+export const puppeteerLogger = (prefix) => {
+    const dbg = util.debuglog(prefix);
+    if (!dbg.enabled) {
+        return;
+    }
+    if (logFileStream) {
+        return (...args) => {
+            logFileStream.write(`${new Date().toISOString()} ${prefix} ${util.format(...args)}\n`);
+        };
+    }
+    return (...args) => {
+        dbg('%s %s', new Date().toISOString(), util.format(...args));
+    };
+};
+//# sourceMappingURL=logger.js.map

package/build/src/utils/pagination.js

@@ -0,0 +1,50 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_PAGE_SIZE = 20;
+export function paginate(items, options) {
+    const total = items.length;
+    if (!options || noPaginationOptions(options)) {
+        return {
+            items,
+            currentPage: 0,
+            totalPages: 1,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            startIndex: 0,
+            endIndex: total,
+            invalidPage: false,
+        };
+    }
+    const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+    const totalPages = Math.max(1, Math.ceil(total / pageSize));
+    const { currentPage, invalidPage } = resolvePageIndex(options.pageIdx, totalPages);
+    const startIndex = currentPage * pageSize;
+    const pageItems = items.slice(startIndex, startIndex + pageSize);
+    const endIndex = startIndex + pageItems.length;
+    return {
+        items: pageItems,
+        currentPage,
+        totalPages,
+        hasNextPage: currentPage < totalPages - 1,
+        hasPreviousPage: currentPage > 0,
+        startIndex,
+        endIndex,
+        invalidPage,
+    };
+}
+function noPaginationOptions(options) {
+    return options.pageSize === undefined && options.pageIdx === undefined;
+}
+function resolvePageIndex(pageIdx, totalPages) {
+    if (pageIdx === undefined) {
+        return { currentPage: 0, invalidPage: false };
+    }
+    if (pageIdx < 0 || pageIdx >= totalPages) {
+        return { currentPage: 0, invalidPage: true };
+    }
+    return { currentPage: pageIdx, invalidPage: false };
+}
+//# sourceMappingURL=pagination.js.map

package/build/src/utils/polyfill.js

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { DisposableStack, AsyncDisposableStack, SuppressedError, } from '../third_party/index.js';
+globalThis.DisposableStack ??= DisposableStack;
+globalThis.AsyncDisposableStack ??= AsyncDisposableStack;
+// @ts-expect-error Type mismatch between puppeteer-core and node for SuppressedError.
+globalThis.SuppressedError ??= SuppressedError;
+//# sourceMappingURL=polyfill.js.map

package/build/src/utils/url.js

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const ALLOWED_PROTOCOLS = new Set(['http:', 'https:', 'ws:', 'wss:']);
+const IPV4_LOOPBACK_REGEX = /^127(?:\.(?:25[0-5]|2[0-4]\d|[01]?\d\d?)){3}$/;
+/**
+ * Determines whether a given URL string points to a localhost / loopback address.
+ *
+ * @param url The URL string to test.
+ * @returns true if the URL is a valid network URL pointing to localhost or a loopback IP.
+ */
+export function isLocalhost(url) {
+    if (!url || typeof url !== 'string' || url.trim() === '') {
+        return false;
+    }
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (!ALLOWED_PROTOCOLS.has(parsed.protocol)) {
+        return false;
+    }
+    const hostname = parsed.hostname.toLowerCase().replace(/\.$/, '');
+    // 1. Check localhost and RFC 6761 *.localhost subdomains
+    if (hostname === 'localhost' || hostname.endsWith('.localhost')) {
+        return true;
+    }
+    // 2. Check IPv6 loopback ([::1] as returned by URL.hostname, or ::1)
+    if (hostname === '[::1]' || hostname === '::1') {
+        return true;
+    }
+    // 3. Check IPv4 loopback (127.0.0.0/8)
+    if (IPV4_LOOPBACK_REGEX.test(hostname)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Determines whether a URL is allowed for navigation and page tracking.
+ *
+ * Disallowed schemes:
+ * - chrome: (except chrome://newtab/ and chrome://inspect*)
+ * - chrome-untrusted:
+ * - chrome-extension: (unless categoryExtensions is true)
+ *
+ * @param url The URL string to test.
+ * @param options Configuration specifying whether extensions are enabled.
+ * @returns true if the URL is allowed.
+ */
+export function isAllowedUrl(url, options) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol === 'chrome:') {
+        const host = parsed.hostname.toLowerCase();
+        const path = parsed.pathname.toLowerCase();
+        if (host === 'newtab' || host === 'new-tab-page' || host === 'inspect') {
+            return true;
+        }
+        if (host === '' &&
+            (path === 'newtab' ||
+                path === 'new-tab-page' ||
+                path.startsWith('inspect'))) {
+            return true;
+        }
+    }
+    if (parsed.protocol === 'chrome:' ||
+        parsed.protocol === 'chrome-untrusted:') {
+        return false;
+    }
+    if (!options.categoryExtensions && parsed.protocol === 'chrome-extension:') {
+        return false;
+    }
+    return true;
+}
+const DISALLOWED_PROTOCOLS = new Set(['javascript:', 'data:', 'vbscript:']);
+/**
+ * Validates a URL string by parsing it with `new URL` and checking for disallowed protocols and restricted schemes.
+ *
+ * @param url The URL string to validate.
+ * @param options Options object containing javascriptEvaluation and categoryExtensions.
+ * @returns The parsed URL.
+ * @throws Error if the URL does not parse with `new URL`, or if JavaScript evaluation is disabled and a disallowed URL is passed,
+ * or if navigating to a restricted scheme.
+ */
+export function validateUrl(url, options) {
+    const { javascriptEvaluation, categoryExtensions } = options;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`Invalid URL: "${url}". URLs must be valid according to the URL standard.`);
+    }
+    if (javascriptEvaluation === false &&
+        DISALLOWED_PROTOCOLS.has(parsed.protocol)) {
+        throw new Error(`Navigating to ${parsed.protocol} URLs is not allowed when JavaScript evaluation is disabled.`);
+    }
+    if (!isAllowedUrl(url, { categoryExtensions })) {
+        if (parsed.protocol === 'chrome-extension:') {
+            throw new Error(`Navigating to chrome-extension: URLs is not allowed without --categoryExtensions.`);
+        }
+        throw new Error(`Navigating to ${parsed.protocol} URLs is not allowed.`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=url.js.map

package/build/src/version.js

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// If moved update release-please config
+// x-release-please-start-version
+export const VERSION = '1.10.1';
+// x-release-please-end
+//# sourceMappingURL=version.js.map