chrome-devtools-mcp 0.25.0 → 1.0.1

package/build/src/telemetry/flagUtils.js

@@ -4,13 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { toSnakeCase } from '../utils/string.js';
+import { stripUnderscoreBeforeNumber } from './transformation.js';
 /**
  * For enums, log the value as uppercase.
  * We're going to have an enum for such flags with choices represented
  * as an `enum` where the keys of the enum will map to the uppercase `choice`.
  */
 function formatEnumChoice(snakeCaseName, choice) {
-    return `${snakeCaseName}_${choice}`.toUpperCase();
+    return stripUnderscoreBeforeNumber(`${snakeCaseName}_${choice}`).toUpperCase();
 }
 /**
  * Computes telemetry flag usage from parsed arguments and CLI options.
@@ -29,7 +30,7 @@ export function computeFlagUsage(args, options) {
     const usage = {};
     for (const [flagName, config] of Object.entries(options)) {
         const value = args[flagName];
-        const snakeCaseName = toSnakeCase(flagName);
+        const snakeCaseName = stripUnderscoreBeforeNumber(toSnakeCase(flagName));
         // If there isn't a default value provided for the flag,
         // we're going to log whether it's present on the args user
         // provided or not. If there is a default value, we only log presence
@@ -58,7 +59,7 @@ export function computeFlagUsage(args, options) {
 export function getPossibleFlagMetrics(options) {
     const metrics = [];
     for (const [flagName, config] of Object.entries(options)) {
-        const snakeCaseName = toSnakeCase(flagName);
+        const snakeCaseName = stripUnderscoreBeforeNumber(toSnakeCase(flagName));
         // _present is always a possible metric
         metrics.push({
             name: `${snakeCaseName}_present`,

package/build/src/telemetry/{toolMetricsUtils.js → metricsRegistry.js}

@@ -3,7 +3,7 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { transformArgName, transformArgType, getZodType, PARAM_BLOCKLIST, } from './ClearcutLogger.js';
+import { transformArgName, transformArgType, getZodType, PARAM_BLOCKLIST, stripUnderscoreBeforeNumber, } from './transformation.js';
 /**
  * Validates that all values in an enum are of the homogeneous primitive type.
  * Returns the primitive type string. Throws an error if heterogeneous.
@@ -81,9 +81,9 @@ export function generateToolMetrics(tools) {
             });
         }
         return {
-            name: tool.name,
+            name: stripUnderscoreBeforeNumber(tool.name),
             args,
         };
     });
 }
-//# sourceMappingURL=toolMetricsUtils.js.map
+//# sourceMappingURL=metricsRegistry.js.map

package/build/src/telemetry/persistence.js

@@ -8,6 +8,8 @@ import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
 import { logger } from '../logger.js';
+import { ClearcutLogger } from './ClearcutLogger.js';
+import { ErrorCode } from './errors.js';
 const STATE_FILE_NAME = 'telemetry_state.json';
 function getDataFolder() {
     const homedir = os.homedir();
@@ -28,12 +30,25 @@ export class FilePersistence {
         this.#dataFolder = dataFolderOverride ?? getDataFolder();
     }
     async loadState() {
+        const filePath = path.join(this.#dataFolder, STATE_FILE_NAME);
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            // File doesn't exist. Not an error because new users do not have the state file.
+            return {
+                lastActive: '',
+            };
+        }
         try {
-            const filePath = path.join(this.#dataFolder, STATE_FILE_NAME);
             const content = await fs.readFile(filePath, 'utf-8');
             return JSON.parse(content);
         }
-        catch {
+        catch (error) {
+            logger(`Failed to read telemetry state from ${filePath}:`, error);
+            void ClearcutLogger.get()?.logServerError({
+                errorCode: ErrorCode.ERROR_CODE_PERSISTENCE_FILE_READ_FAILED,
+            });
             return {
                 lastActive: '',
             };
@@ -48,6 +63,9 @@ export class FilePersistence {
         catch (error) {
             // Ignore errors during state saving to avoid crashing the server
             logger(`Failed to save telemetry state to ${filePath}:`, error);
+            void ClearcutLogger.get()?.logServerError({
+                errorCode: ErrorCode.ERROR_CODE_PERSISTENCE_FILE_SAVE_FAILED,
+            });
         }
     }
 }

package/build/src/telemetry/transformation.js

@@ -0,0 +1,134 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const LATENCY_BUCKETS = [50, 100, 250, 500, 1000, 2500, 5000, 10000];
+export function bucketizeLatency(latencyMs) {
+    for (const bucket of LATENCY_BUCKETS) {
+        if (latencyMs <= bucket) {
+            return bucket;
+        }
+    }
+    return LATENCY_BUCKETS[LATENCY_BUCKETS.length - 1];
+}
+export const PARAM_BLOCKLIST = new Set(['uid', 'reqid', 'msgid']);
+const SUPPORTED_ZOD_TYPES = [
+    'ZodString',
+    'ZodNumber',
+    'ZodBoolean',
+    'ZodArray',
+    'ZodEnum',
+];
+function isZodType(type) {
+    return SUPPORTED_ZOD_TYPES.includes(type);
+}
+export function getZodType(zodType) {
+    const def = zodType._def;
+    const typeName = def.typeName;
+    if (typeName === 'ZodOptional' ||
+        typeName === 'ZodDefault' ||
+        typeName === 'ZodNullable') {
+        return getZodType(def.innerType);
+    }
+    if (typeName === 'ZodEffects') {
+        return getZodType(def.schema);
+    }
+    if (isZodType(typeName)) {
+        return typeName;
+    }
+    throw new Error(`Unsupported zod type for tool parameter: ${typeName}`);
+}
+export function stripUnderscoreBeforeNumber(name) {
+    return name.replace(/_([0-9])/g, '$1');
+}
+export function transformArgName(zodType, name) {
+    const snakeCaseName = name.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+    let transformed;
+    if (zodType === 'ZodString') {
+        transformed = `${snakeCaseName}_length`;
+    }
+    else if (zodType === 'ZodArray') {
+        transformed = `${snakeCaseName}_count`;
+    }
+    else {
+        transformed = snakeCaseName;
+    }
+    return stripUnderscoreBeforeNumber(transformed);
+}
+export function transformArgType(zodType) {
+    if (zodType === 'ZodString' || zodType === 'ZodArray') {
+        return 'number';
+    }
+    switch (zodType) {
+        case 'ZodNumber':
+            return 'number';
+        case 'ZodBoolean':
+            return 'boolean';
+        case 'ZodEnum':
+            return 'enum';
+        default:
+            throw new Error(`Unsupported zod type for tool parameter: ${zodType}`);
+    }
+}
+const BUCKETS = [
+    0, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000,
+];
+function bucketize(value) {
+    for (const bucket of BUCKETS) {
+        if (bucket >= value) {
+            return bucket;
+        }
+    }
+    return BUCKETS[BUCKETS.length - 1];
+}
+function transformValue(zodType, value) {
+    if (zodType === 'ZodString') {
+        return bucketize(value.length);
+    }
+    else if (zodType === 'ZodArray') {
+        return value.length;
+    }
+    else {
+        return value;
+    }
+}
+function hasEquivalentType(zodType, value) {
+    if (zodType === 'ZodString') {
+        return typeof value === 'string';
+    }
+    else if (zodType === 'ZodArray') {
+        return Array.isArray(value);
+    }
+    else if (zodType === 'ZodNumber') {
+        return typeof value === 'number';
+    }
+    else if (zodType === 'ZodBoolean') {
+        return typeof value === 'boolean';
+    }
+    else if (zodType === 'ZodEnum') {
+        return (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean');
+    }
+    else {
+        return false;
+    }
+}
+export function sanitizeParams(params, schema) {
+    const transformed = {};
+    for (const [name, value] of Object.entries(params)) {
+        if (PARAM_BLOCKLIST.has(name)) {
+            continue;
+        }
+        const zodType = getZodType(schema[name]);
+        if (!hasEquivalentType(zodType, value)) {
+            throw new Error(`parameter ${name} has type ${zodType} but value ${value} is not of equivalent type`);
+        }
+        const transformedName = transformArgName(zodType, name);
+        const transformedValue = transformValue(zodType, value);
+        transformed[transformedName] = transformedValue;
+    }
+    return transformed;
+}
+//# sourceMappingURL=transformation.js.map

package/build/src/telemetry/types.js

@@ -11,14 +11,6 @@ export var OsType;
     OsType[OsType["OS_TYPE_MACOS"] = 2] = "OS_TYPE_MACOS";
     OsType[OsType["OS_TYPE_LINUX"] = 3] = "OS_TYPE_LINUX";
 })(OsType || (OsType = {}));
-export var ChromeChannel;
-(function (ChromeChannel) {
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_UNSPECIFIED"] = 0] = "CHROME_CHANNEL_UNSPECIFIED";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_CANARY"] = 1] = "CHROME_CHANNEL_CANARY";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_DEV"] = 2] = "CHROME_CHANNEL_DEV";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_BETA"] = 3] = "CHROME_CHANNEL_BETA";
-    ChromeChannel[ChromeChannel["CHROME_CHANNEL_STABLE"] = 4] = "CHROME_CHANNEL_STABLE";
-})(ChromeChannel || (ChromeChannel = {}));
 export var McpClient;
 (function (McpClient) {
     McpClient[McpClient["MCP_CLIENT_UNSPECIFIED"] = 0] = "MCP_CLIENT_UNSPECIFIED";