chrome-devtools-mcp 0.26.0 → 1.1.0

package/build/src/index.js

@@ -9,6 +9,7 @@ import { logger } from './logger.js';
 import { McpContext } from './McpContext.js';
 import { Mutex } from './Mutex.js';
 import { ClearcutLogger } from './telemetry/ClearcutLogger.js';
+import { FilePersistence } from './telemetry/persistence.js';
 import { McpServer, SetLevelRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, } from './third_party/index.js';
 import { ToolHandler } from './ToolHandler.js';
 import { createTools } from './tools/tools.js';
@@ -17,6 +18,7 @@ export { buildFlag } from './ToolHandler.js';
 export async function createMcpServer(serverArgs, options) {
     if (serverArgs.usageStatistics) {
         ClearcutLogger.initialize({
+            persistence: new FilePersistence(),
             logFile: serverArgs.logFile,
             appVersion: VERSION,
             clearcutEndpoint: serverArgs.clearcutEndpoint,
@@ -109,7 +111,7 @@ export async function createMcpServer(serverArgs, options) {
         }
         server.registerTool(tool.name, {
             description: tool.description,
-            inputSchema: toolHandler.inputSchema,
+            inputSchema: toolHandler.registeredInputSchema,
             annotations: tool.annotations,
         }, async (params) => {
             return await toolHandler.handle(params);

package/build/src/telemetry/ClearcutLogger.js

@@ -6,124 +6,10 @@
 import process from 'node:process';
 import { DAEMON_CLIENT_NAME } from '../daemon/utils.js';
 import { logger } from '../logger.js';
-import { FilePersistence } from './persistence.js';
+import { sanitizeParams, stripUnderscoreBeforeNumber } from './transformation.js';
 import { McpClient, WatchdogMessageType, OsType, } from './types.js';
 import { WatchdogClient } from './WatchdogClient.js';
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
-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 transformArgName(zodType, name) {
-    const snakeCaseName = name.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-    if (zodType === 'ZodString') {
-        return `${snakeCaseName}_length`;
-    }
-    else if (zodType === 'ZodArray') {
-        return `${snakeCaseName}_count`;
-    }
-    else {
-        return snakeCaseName;
-    }
-}
-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;
-}
 function detectOsType() {
     switch (process.platform) {
         case 'win32':
@@ -156,7 +42,7 @@ export class ClearcutLogger {
         _clearcut_logger_instance = undefined;
     }
     constructor(options) {
-        this.#persistence = options.persistence ?? new FilePersistence();
+        this.#persistence = options.persistence;
         this.#watchdog =
             options.watchdogClient ??
                 new WatchdogClient({
@@ -195,14 +81,15 @@ export class ClearcutLogger {
         }
     }
     async logToolInvocation(args) {
+        const sanitizedToolName = stripUnderscoreBeforeNumber(args.toolName);
         const tool_invocation = {
-            tool_name: args.toolName,
+            tool_name: sanitizedToolName,
             success: args.success,
             latency_ms: args.latencyMs,
         };
         if (Object.keys(args.params).length > 0) {
             tool_invocation.tool_params = {
-                [`${args.toolName}_params`]: sanitizeParams(args.params, args.schema),
+                [`${sanitizedToolName}_params`]: sanitizeParams(args.params, args.schema),
             };
         }
         this.#watchdog.send({
@@ -258,7 +145,9 @@ export class ClearcutLogger {
             payload: {
                 mcp_client: this.#mcpClient,
                 server_error: {
-                    tool_name: args.toolName ?? '',
+                    tool_name: args.toolName
+                        ? stripUnderscoreBeforeNumber(args.toolName)
+                        : '',
                     error_code: args.errorCode,
                 },
             },

package/build/src/telemetry/errors.js

@@ -6,9 +6,13 @@
  * IMPORTANT:
  *   1. this module must only contain ErrorCode.
  *   2. do not refactor ErrorCode to elsewhere.
+ *   3. prefix new enum values with "ERROR_CODE_". This makes it easier to
+ *      programmtically parse this file.
  */
 export var ErrorCode;
 (function (ErrorCode) {
     ErrorCode[ErrorCode["ERROR_CODE_UNSPECIFIED"] = 0] = "ERROR_CODE_UNSPECIFIED";
+    ErrorCode[ErrorCode["ERROR_CODE_PERSISTENCE_FILE_READ_FAILED"] = 1] = "ERROR_CODE_PERSISTENCE_FILE_READ_FAILED";
+    ErrorCode[ErrorCode["ERROR_CODE_PERSISTENCE_FILE_SAVE_FAILED"] = 2] = "ERROR_CODE_PERSISTENCE_FILE_SAVE_FAILED";
 })(ErrorCode || (ErrorCode = {}));
 //# sourceMappingURL=errors.js.map

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