refactor(telemetry): improve type safety in telemetry parsers

moazbuilds · moazbuilds · commit b032d4c27ac0 · 2025-11-08T18:59:33.000+02:00
- Replace 'any' with 'unknown' and add proper type guards
- Update eslint config to use tseslint.config
- Rename CCR engine display name to 'Claude Code Router'
diff --git a/eslint.config.js b/eslint.config.js
@@ -1,12 +1,11 @@
 import js from '@eslint/js';
 import eslintConfigPrettier from 'eslint-config-prettier';
 import importPlugin from 'eslint-plugin-import';
-import { defineConfig } from 'typescript-eslint';
 import tseslint from 'typescript-eslint';
 
 const typescriptFiles = ['src/**/*.{ts,tsx}', 'tests/**/*.{ts,tsx}'];
 
-export default defineConfig(
+export default tseslint.config(
   {
     ignores: ['node_modules', 'dist', 'coverage'],
   },
diff --git a/src/infra/engines/providers/ccr/telemetryParser.ts b/src/infra/engines/providers/ccr/telemetryParser.ts
@@ -13,18 +13,26 @@ interface CapturedTelemetry {
  *
  * CCR uses Claude API format with "result" events
  */
-export function parseTelemetry(json: any): CapturedTelemetry | null {
-  // CCR format: same as Claude - type: 'result' with detailed usage
-  if (json.type === 'result' && json.usage) {
+export function parseTelemetry(json: unknown): CapturedTelemetry | null {
+  // Type guard to check if json is an object with required properties
+  if (
+    typeof json === 'object' &&
+    json !== null &&
+    'type' in json &&
+    (json as Record<string, unknown>).type === 'result' &&
+    'usage' in json
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = json as Record<string, any>;
     // Calculate cached tokens from both cache_read_input_tokens and cache_creation_input_tokens
-    const cachedTokens = (json.usage.cache_read_input_tokens || 0) + (json.usage.cache_creation_input_tokens || 0);
+    const cachedTokens = (data.usage.cache_read_input_tokens || 0) + (data.usage.cache_creation_input_tokens || 0);
 
     return {
-      duration: json.duration_ms,
-      cost: json.total_cost_usd,
+      duration: data.duration_ms,
+      cost: data.total_cost_usd,
       tokens: {
-        input: json.usage.input_tokens,
-        output: json.usage.output_tokens,
+        input: data.usage.input_tokens,
+        output: data.usage.output_tokens,
         cached: cachedTokens > 0 ? cachedTokens : undefined,
       },
     };
diff --git a/src/infra/engines/providers/claude/telemetryParser.ts b/src/infra/engines/providers/claude/telemetryParser.ts
@@ -13,18 +13,26 @@ interface CapturedTelemetry {
  *
  * Claude emits telemetry in "result" events with full usage data
  */
-export function parseTelemetry(json: any): CapturedTelemetry | null {
-  // Claude format: type: 'result' with detailed usage
-  if (json.type === 'result' && json.usage) {
+export function parseTelemetry(json: unknown): CapturedTelemetry | null {
+  // Type guard to check if json is an object with required properties
+  if (
+    typeof json === 'object' &&
+    json !== null &&
+    'type' in json &&
+    (json as Record<string, unknown>).type === 'result' &&
+    'usage' in json
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = json as Record<string, any>;
     // Calculate cached tokens from both cache_read_input_tokens and cache_creation_input_tokens
-    const cachedTokens = (json.usage.cache_read_input_tokens || 0) + (json.usage.cache_creation_input_tokens || 0);
+    const cachedTokens = (data.usage.cache_read_input_tokens || 0) + (data.usage.cache_creation_input_tokens || 0);
 
     return {
-      duration: json.duration_ms,
-      cost: json.total_cost_usd,
+      duration: data.duration_ms,
+      cost: data.total_cost_usd,
       tokens: {
-        input: json.usage.input_tokens,
-        output: json.usage.output_tokens,
+        input: data.usage.input_tokens,
+        output: data.usage.output_tokens,
         cached: cachedTokens > 0 ? cachedTokens : undefined,
       },
     };
diff --git a/src/infra/engines/providers/codex/telemetryParser.ts b/src/infra/engines/providers/codex/telemetryParser.ts
@@ -13,14 +13,22 @@ interface CapturedTelemetry {
  *
  * Codex emits telemetry in "turn.completed" events with usage data
  */
-export function parseTelemetry(json: any): CapturedTelemetry | null {
-  // Codex format: type: 'turn.completed' with usage
-  if (json.type === 'turn.completed' && json.usage) {
+export function parseTelemetry(json: unknown): CapturedTelemetry | null {
+  // Type guard to check if json is an object with required properties
+  if (
+    typeof json === 'object' &&
+    json !== null &&
+    'type' in json &&
+    (json as Record<string, unknown>).type === 'turn.completed' &&
+    'usage' in json
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = json as Record<string, any>;
     return {
       tokens: {
-        input: json.usage.input_tokens,
-        output: json.usage.output_tokens,
-        cached: json.usage.cached_input_tokens,
+        input: data.usage.input_tokens,
+        output: data.usage.output_tokens,
+        cached: data.usage.cached_input_tokens,
       },
     };
   }
diff --git a/src/infra/engines/providers/cursor/telemetryParser.ts b/src/infra/engines/providers/cursor/telemetryParser.ts
@@ -13,18 +13,26 @@ interface CapturedTelemetry {
  *
  * Cursor uses Claude API format with "result" events
  */
-export function parseTelemetry(json: any): CapturedTelemetry | null {
-  // Cursor format: same as Claude - type: 'result' with detailed usage
-  if (json.type === 'result' && json.usage) {
+export function parseTelemetry(json: unknown): CapturedTelemetry | null {
+  // Type guard to check if json is an object with required properties
+  if (
+    typeof json === 'object' &&
+    json !== null &&
+    'type' in json &&
+    (json as Record<string, unknown>).type === 'result' &&
+    'usage' in json
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = json as Record<string, any>;
     // Calculate cached tokens from both cache_read_input_tokens and cache_creation_input_tokens
-    const cachedTokens = (json.usage.cache_read_input_tokens || 0) + (json.usage.cache_creation_input_tokens || 0);
+    const cachedTokens = (data.usage.cache_read_input_tokens || 0) + (data.usage.cache_creation_input_tokens || 0);
 
     return {
-      duration: json.duration_ms,
-      cost: json.total_cost_usd,
+      duration: data.duration_ms,
+      cost: data.total_cost_usd,
       tokens: {
-        input: json.usage.input_tokens,
-        output: json.usage.output_tokens,
+        input: data.usage.input_tokens,
+        output: data.usage.output_tokens,
         cached: cachedTokens > 0 ? cachedTokens : undefined,
       },
     };
diff --git a/src/infra/engines/providers/opencode/execution/runner.ts b/src/infra/engines/providers/opencode/execution/runner.ts
@@ -76,10 +76,12 @@ function cleanAnsi(text: string, plainLogs: boolean): string {
   return text.replace(ANSI_ESCAPE_SEQUENCE, '');
 }
 
-function formatToolUse(part: any, plainLogs: boolean): string {
-  const tool = part?.tool ?? 'tool';
+function formatToolUse(part: unknown, plainLogs: boolean): string {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const partObj = (typeof part === 'object' && part !== null ? part : {}) as Record<string, any>;
+  const tool = partObj?.tool ?? 'tool';
   const base = formatCommand(tool, 'success');
-  const state = part?.state ?? {};
+  const state = partObj?.state ?? {};
 
   if (tool === 'bash') {
     const outputRaw =
@@ -108,15 +110,17 @@ function formatToolUse(part: any, plainLogs: boolean): string {
   return base;
 }
 
-function formatStepEvent(type: string, part: any): string | null {
-  const reason = typeof part?.reason === 'string' ? part.reason : undefined;
+function formatStepEvent(type: string, part: unknown): string | null {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const partObj = (typeof part === 'object' && part !== null ? part : {}) as Record<string, any>;
+  const reason = typeof partObj?.reason === 'string' ? partObj.reason : undefined;
 
   // Only show final step (reason: 'stop'), skip intermediate steps (reason: 'tool-calls')
   if (reason !== 'stop') {
     return null;
   }
 
-  const tokens = part?.tokens;
+  const tokens = partObj?.tokens;
   if (!tokens) {
     return null;
   }
@@ -128,14 +132,16 @@ function formatStepEvent(type: string, part: any): string | null {
   return tokenSummary;
 }
 
-function formatErrorEvent(error: any, plainLogs: boolean): string {
+function formatErrorEvent(error: unknown, plainLogs: boolean): string {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const errorObj = (typeof error === 'object' && error !== null ? error : {}) as Record<string, any>;
   const dataMessage =
-    typeof error?.data?.message === 'string'
-      ? error.data.message
-      : typeof error?.message === 'string'
-        ? error.message
-        : typeof error?.name === 'string'
-          ? error.name
+    typeof errorObj?.data?.message === 'string'
+      ? errorObj.data.message
+      : typeof errorObj?.message === 'string'
+        ? errorObj.message
+        : typeof errorObj?.name === 'string'
+          ? errorObj.name
           : 'OpenCode reported an unknown error';
 
   const cleaned = cleanAnsi(dataMessage, plainLogs);
@@ -184,7 +190,7 @@ export async function runOpenCode(options: RunOpenCodeOptions): Promise<RunOpenC
       return;
     }
 
-    let parsed: any;
+    let parsed: unknown;
     try {
       parsed = JSON.parse(line);
     } catch {
@@ -208,10 +214,17 @@ export async function runOpenCode(options: RunOpenCodeOptions): Promise<RunOpenC
       }
     }
 
+    // Type guard for parsed JSON
+    if (typeof parsed !== 'object' || parsed === null) {
+      return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const parsedObj = parsed as Record<string, any>;
+
     let formatted: string | null = null;
-    switch (parsed.type) {
+    switch (parsedObj.type) {
       case 'tool_use':
-        formatted = formatToolUse(parsed.part, plainLogs);
+        formatted = formatToolUse(parsedObj.part, plainLogs);
         break;
       case 'step_start':
         if (isFirstStep) {
@@ -221,10 +234,10 @@ export async function runOpenCode(options: RunOpenCodeOptions): Promise<RunOpenC
         // Subsequent step_start events are silent
         break;
       case 'step_finish':
-        formatted = formatStepEvent(parsed.type, parsed.part);
+        formatted = formatStepEvent(parsedObj.type, parsedObj.part);
         break;
       case 'text': {
-        const textPart = parsed.part;
+        const textPart = parsedObj.part;
         const textValue =
           typeof textPart?.text === 'string'
             ? cleanAnsi(textPart.text, plainLogs)
@@ -233,7 +246,7 @@ export async function runOpenCode(options: RunOpenCodeOptions): Promise<RunOpenC
         break;
       }
       case 'error':
-        formatted = formatErrorEvent(parsed.error, plainLogs);
+        formatted = formatErrorEvent(parsedObj.error, plainLogs);
         break;
       default:
         break;
diff --git a/src/infra/engines/providers/opencode/telemetryParser.ts b/src/infra/engines/providers/opencode/telemetryParser.ts
@@ -13,20 +13,30 @@ interface CapturedTelemetry {
  *
  * OpenCode emits telemetry in "step_finish" events with nested tokens in part.tokens
  */
-export function parseTelemetry(json: any): CapturedTelemetry | null {
-  // OpenCode format: type: 'step_finish' with part.tokens
-  if (json.type === 'step_finish' && json.part?.tokens) {
-    const tokens = json.part.tokens;
-    const cache = (tokens.cache?.read || 0) + (tokens.cache?.write || 0);
+export function parseTelemetry(json: unknown): CapturedTelemetry | null {
+  // Type guard to check if json is an object with required properties
+  if (
+    typeof json === 'object' &&
+    json !== null &&
+    'type' in json &&
+    (json as Record<string, unknown>).type === 'step_finish' &&
+    'part' in json
+  ) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const data = json as Record<string, any>;
+    if (data.part?.tokens) {
+      const tokens = data.part.tokens;
+      const cache = (tokens.cache?.read || 0) + (tokens.cache?.write || 0);
 
-    return {
-      tokens: {
-        input: tokens.input,
-        output: tokens.output,
-        cached: cache > 0 ? cache : undefined,
-      },
-      cost: json.part.cost,
-    };
+      return {
+        tokens: {
+          input: tokens.input,
+          output: tokens.output,
+          cached: cache > 0 ? cache : undefined,
+        },
+        cost: data.part.cost,
+      };
+    }
   }
 
   return null;
diff --git a/src/shared/telemetry/capture.ts b/src/shared/telemetry/capture.ts
@@ -16,7 +16,7 @@ interface CapturedTelemetry {
   };
 }
 
-type TelemetryParser = (json: any) => CapturedTelemetry | null;
+type TelemetryParser = (json: unknown) => CapturedTelemetry | null;
 
 /**
  * Engine-specific telemetry parsers
diff --git a/tests/unit/infra/ccr-registry.spec.ts b/tests/unit/infra/ccr-registry.spec.ts
@@ -13,7 +13,7 @@ describe('CCR Engine Registry Integration', () => {
     expect(ccrEngine).toBeDefined();
     expect(ccrEngine?.metadata).toEqual({
       id: 'ccr',
-      name: 'CCR',
+      name: 'Claude Code Router',
       description: 'Authenticate with Claude Code Router',
       cliCommand: 'ccr',
       cliBinary: 'ccr',

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ interface CapturedTelemetry {`
`16`	`16`	`};`
`17`	`17`	`}`
`18`	`18`
`19`		`-type TelemetryParser = (json: any) => CapturedTelemetry \| null;`
	`19`	`+type TelemetryParser = (json: unknown) => CapturedTelemetry \| null;`
`20`	`20`
`21`	`21`	`/**`
`22`	`22`	`* Engine-specific telemetry parsers`