opera-devtools-mcp 0.2.4 → 0.3.0

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, getEnumValues, 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.
@@ -66,14 +66,7 @@ export function generateToolMetrics(tools) {
             const transformedName = transformArgName(zodType, name);
             let argType = transformArgType(zodType);
             if (argType === 'enum') {
-                let values;
-                if (schema._def.values?.length > 0) {
-                    values = schema._def.values;
-                }
-                else {
-                    values = schema._def.innerType._def.values;
-                }
-                argType = validateEnumHomogeneity(values);
+                argType = validateEnumHomogeneity(getEnumValues(schema));
             }
             args.push({
                 name: transformedName,
@@ -81,9 +74,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

@@ -7,7 +7,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import process from 'node:process';
-import { logger } from '../logger.js';
+import { logger } from '../utils/logger.js';
 import { ClearcutLogger } from './ClearcutLogger.js';
 import { ErrorCode } from './errors.js';
 const STATE_FILE_NAME = 'telemetry_state.json';
@@ -45,7 +45,7 @@ export class FilePersistence {
             return JSON.parse(content);
         }
         catch (error) {
-            logger(`Failed to read telemetry state from ${filePath}:`, error);
+            logger?.(`Failed to read telemetry state from ${filePath}:`, error);
             void ClearcutLogger.get()?.logServerError({
                 errorCode: ErrorCode.ERROR_CODE_PERSISTENCE_FILE_READ_FAILED,
             });
@@ -62,7 +62,7 @@ export class FilePersistence {
         }
         catch (error) {
             // Ignore errors during state saving to avoid crashing the server
-            logger(`Failed to save telemetry state to ${filePath}:`, error);
+            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,184 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isLocalhost } from '../utils/url.js';
+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}`);
+}
+/**
+ * Resolves the values of an enum parameter, unwrapping any optional/default/
+ * nullable/effects wrappers (in any order), mirroring {@link getZodType}.
+ */
+export function getEnumValues(zodType) {
+    const def = zodType._def;
+    const typeName = def.typeName;
+    if (typeName === 'ZodOptional' ||
+        typeName === 'ZodDefault' ||
+        typeName === 'ZodNullable') {
+        return getEnumValues(def.innerType);
+    }
+    if (typeName === 'ZodEffects') {
+        return getEnumValues(def.schema);
+    }
+    if (typeName === 'ZodEnum') {
+        return def.values;
+    }
+    throw new Error(`Cannot resolve enum values for zod type: ${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;
+}
+function transformDevToolsData(devToolsData) {
+    const logged = {};
+    if (devToolsData.cdpBackendNodeId !== undefined) {
+        logged.is_dom_element_selected = true;
+    }
+    if (devToolsData.cdpRequestId !== undefined) {
+        logged.is_network_request_selected = true;
+    }
+    return logged;
+}
+export function buildContext(devToolsData, pageUrl) {
+    let context;
+    if (devToolsData === undefined) {
+        context = { is_devtools_open: false };
+    }
+    else {
+        context = {
+            is_devtools_open: Object.keys(devToolsData).length > 0,
+        };
+        const loggedDevtoolsData = transformDevToolsData(devToolsData);
+        if (Object.keys(loggedDevtoolsData).length > 0) {
+            context.devtools_data = loggedDevtoolsData;
+        }
+    }
+    if (pageUrl !== undefined) {
+        context.is_localhost = isLocalhost(pageUrl);
+    }
+    return context;
+}
+//# sourceMappingURL=transformation.js.map

package/build/src/telemetry/watchdog/ClearcutSender.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import crypto from 'node:crypto';
-import { logger } from '../../logger.js';
+import { logger } from '../../utils/logger.js';
 const MAX_BUFFER_SIZE = 1000;
 const DEFAULT_CLEARCUT_ENDPOINT = 'https://play.googleapis.com/log?format=json_proto';
 const DEFAULT_FLUSH_INTERVAL_MS = 15 * 60 * 1000;
@@ -48,7 +48,7 @@ export class ClearcutSender {
             app_version: this.#appVersion,
             os_type: this.#osType,
         };
-        logger('Enqueing telemetry event', JSON.stringify(eventToSend, null, 2));
+        logger?.('Enqueing telemetry event', JSON.stringify(eventToSend, null, 2));
         this.#addToBuffer(eventToSend);
         if (!this.#timerStarted) {
             this.#timerStarted = true;
@@ -69,10 +69,10 @@ export class ClearcutSender {
                 this.#finalFlush(),
                 new Promise(resolve => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS)),
             ]);
-            logger('Final flush completed');
+            logger?.('Final flush completed');
         }
         catch (error) {
-            logger('Final flush failed:', error);
+            logger?.('Final flush failed:', error);
         }
     }
     async #flush() {
@@ -97,7 +97,7 @@ export class ClearcutSender {
                 }
             }
             else if (result.isPermanentError) {
-                logger('Permanent error, dropped batch of', eventsToSend.length, 'events');
+                logger?.('Permanent error, dropped batch of', eventsToSend.length, 'events');
             }
             else {
                 // Transient error: Requeue events at the front of the buffer
@@ -108,7 +108,7 @@ export class ClearcutSender {
         catch (error) {
             // Safety catch for unexpected errors, requeue events
             this.#buffer = [...eventsToSend, ...this.#buffer];
-            logger('Flush failed unexpectedly:', error);
+            logger?.('Flush failed unexpectedly:', error);
         }
         finally {
             this.#isFlushing = false;
@@ -118,7 +118,7 @@ export class ClearcutSender {
     #addToBuffer(event) {
         if (this.#buffer.length >= MAX_BUFFER_SIZE) {
             this.#buffer.shift();
-            logger('Telemetry buffer overflow: dropped oldest event');
+            logger?.('Telemetry buffer overflow: dropped oldest event');
         }
         this.#buffer.push({
             event,
@@ -126,18 +126,18 @@ export class ClearcutSender {
         });
     }
     #scheduleFlush(delayMs) {
-        logger(`Scheduling flush in ${delayMs}`);
+        logger?.(`Scheduling flush in ${delayMs}`);
         if (this.#flushTimer) {
             clearTimeout(this.#flushTimer);
         }
         this.#flushTimer = setTimeout(() => {
             this.#flush().catch(err => {
-                logger('Flush error:', err);
+                logger?.('Flush error:', err);
             });
         }, delayMs);
     }
     async #sendBatch(events) {
-        logger(`Sending batch of ${events.length}`);
+        logger?.(`Sending batch of ${events.length}`);
         const requestBody = {
             log_source: LOG_SOURCE,
             request_time_ms: Date.now().toString(),
@@ -176,7 +176,7 @@ export class ClearcutSender {
             if (status >= 500 || status === 429) {
                 return { success: false };
             }
-            logger('Telemetry permanent error:', status);
+            logger?.('Telemetry permanent error:', status);
             return { success: false, isPermanentError: true };
         }
         catch {

package/build/src/telemetry/watchdog/main.js

@@ -6,7 +6,7 @@
 import process from 'node:process';
 import readline from 'node:readline';
 import { parseArgs } from 'node:util';
-import { logger, flushLogs, saveLogsToFile } from '../../logger.js';
+import { logger, flushLogs, saveLogsToFile } from '../../utils/logger.js';
 import { WatchdogMessageType } from '../types.js';
 import { ClearcutSender } from './ClearcutSender.js';
 function parseWatchdogArgs() {
@@ -65,7 +65,7 @@ function main() {
             process.exit(code);
         });
     };
-    logger('Watchdog started', JSON.stringify({
+    logger?.('Watchdog started', JSON.stringify({
         pid: process.pid,
         parentPid,
         version: appVersion,
@@ -84,15 +84,15 @@ function main() {
             return;
         }
         isShuttingDown = true;
-        logger(`Parent death detected (${reason}). Sending shutdown event...`);
+        logger?.(`Parent death detected (${reason}). Sending shutdown event...`);
         sender
             .sendShutdownEvent()
             .then(() => {
-            logger('Shutdown event sent. Exiting.');
+            logger?.('Shutdown event sent. Exiting.');
             exit(0);
         })
             .catch(err => {
-            logger('Failed to send shutdown event', err);
+            logger?.('Failed to send shutdown event', err);
             exit(1);
         });
     }
@@ -114,7 +114,7 @@ function main() {
             }
         }
         catch (err) {
-            logger('Failed to parse IPC message', err);
+            logger?.('Failed to parse IPC message', err);
         }
     });
 }