opera-devtools-mcp 0.2.4 → 0.4.0

package/build/src/telemetry/ClearcutLogger.js

@@ -5,124 +5,11 @@
  */
 import process from 'node:process';
 import { DAEMON_CLIENT_NAME } from '../daemon/utils.js';
-import { logger } from '../logger.js';
+import { logger } from '../utils/logger.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':
@@ -194,14 +81,18 @@ 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.context).length > 0) {
+            tool_invocation.context = args.context;
+        }
         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({
@@ -248,7 +139,7 @@ export class ClearcutLogger {
             }
         }
         catch (err) {
-            logger('Error in logDailyActiveIfNeeded:', err);
+            logger?.('Error in logDailyActiveIfNeeded:', err);
         }
     }
     async logServerError(args) {
@@ -257,7 +148,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/WatchdogClient.js

@@ -5,7 +5,7 @@
  */
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { logger } from '../logger.js';
+import { logger } from '../utils/logger.js';
 export class WatchdogClient {
     #childProcess;
     constructor(config, options) {
@@ -35,10 +35,10 @@ export class WatchdogClient {
         });
         this.#childProcess.unref();
         this.#childProcess.on('error', err => {
-            logger('Watchdog process error:', err);
+            logger?.('Watchdog process error:', err);
         });
         this.#childProcess.on('exit', (code, signal) => {
-            logger(`Watchdog exited with code ${code} and signal ${signal}`);
+            logger?.(`Watchdog exited with code ${code} and signal ${signal}`);
         });
     }
     send(message) {
@@ -50,11 +50,11 @@ export class WatchdogClient {
                 this.#childProcess.stdin.write(line);
             }
             catch (err) {
-                logger('Failed to write to watchdog stdin', err);
+                logger?.('Failed to write to watchdog stdin', err);
             }
         }
         else {
-            logger('Watchdog stdin not available, dropping message');
+            logger?.('Watchdog stdin not available, dropping message');
         }
     }
 }

package/build/src/telemetry/errors.js

@@ -13,6 +13,6 @@ 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"] = 3] = "ERROR_CODE_PERSISTENCE_FILE_SAVE_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

@@ -2,17 +2,17 @@
  * @license
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
- *
- * Modified by Opera Software AS.
  */
-import { toSnakeCase } from '../utils/string.js';
+import { DevTools } from '../third_party/index.js';
+import { stripUnderscoreBeforeNumber } from './transformation.js';
+const { StringUtilities } = DevTools.Platform;
 /**
  * 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.
@@ -31,7 +31,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(StringUtilities.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
@@ -60,7 +60,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(StringUtilities.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, 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,193 @@
+/**
+ * @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',
+    'ZodRecord',
+];
+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' || zodType === 'ZodRecord') {
+        transformed = `${snakeCaseName}_count`;
+    }
+    else {
+        transformed = snakeCaseName;
+    }
+    return stripUnderscoreBeforeNumber(transformed);
+}
+export function transformArgType(zodType) {
+    if (zodType === 'ZodString' ||
+        zodType === 'ZodArray' ||
+        zodType === 'ZodRecord') {
+        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 if (zodType === 'ZodRecord') {
+        return Object.keys(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 === 'ZodRecord') {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+    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);
         }
     });
 }