@mks2508/mks-ui 0.3.2 → 0.4.0

package/src/react-ui/blocks/Terminal/parsing/LogParserService.ts

@@ -0,0 +1,686 @@
+/**
+ * Log parser service for terminal log processing.
+ *
+ * Main service that combines ANSI parsing, log level detection,
+ * timestamp extraction, and structured log handling into a
+ * unified API for processing log streams.
+ *
+ * @module components/devenv/terminal/parsing/service
+ */
+
+import { AnsiParser } from './ansi/AnsiParser';
+import { LogLevelDetector } from './levels/LogLevelDetector';
+import { BadgeFormatter } from './BadgeFormatter';
+import { MultilineAggregator } from './MultilineAggregator';
+import type {
+  IParsedLogEntry,
+  IParserState,
+  ILogParserOptions,
+  ILogFilterOptions,
+  ILogStats,
+  TLogLevel,
+} from './LogParser.types';
+
+/**
+ * Timestamp patterns for common log formats.
+ *
+ * IMPORTANT: Order matters! More specific patterns must come first.
+ * The double timestamp pattern MUST be before single timestamp patterns.
+ */
+const TIMESTAMP_PATTERNS = [
+  // Double timestamp (devenv-agent-backend better-logger): 2026-02-05T22:41:05.372991285Z 22:41:05.372
+  // This MUST come first as it's more specific
+  {
+    regex: /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s+(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\s+/,
+    format: 'double',
+    extractIndex: 2, // Extract the time portion (index 2) for display
+  },
+  // Supervisord format (comma in milliseconds): 2026-02-05 22:22:38,372
+  {
+    regex: /^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}),(\d+)\s+/,
+    format: 'supervisord',
+  },
+  // ISO 8601 with microseconds: 2026-02-05T21:35:28.944519682Z
+  {
+    regex: /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?)\s/,
+    format: 'iso',
+  },
+  // Time with milliseconds: 21:35:28.944
+  {
+    regex: /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)\s/,
+    format: 'time',
+  },
+  // Unix timestamp in milliseconds: [1770328479225]
+  {
+    regex: /^\[(\d{13,})\]\s/,
+    format: 'unix',
+  },
+  // Date/time: [2026-02-05 21:35:28]
+  {
+    regex: /^\[(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})\]\s/,
+    format: 'datetime',
+  },
+  // Syslog format: Feb  5 21:35:28
+  {
+    regex: /^([A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2})\s/,
+    format: 'syslog',
+  },
+];
+
+/**
+ * Tag extraction pattern.
+ * Matches: ⦗COMPONENT⦘ ⦗ROUTES⦘ etc.
+ */
+const TAG_PATTERN = /⦗([^⦘]+)⦘/g;
+
+/**
+ * Log parser service class.
+ *
+ * Provides unified API for parsing log text with ANSI colorization,
+ * log level detection, timestamp extraction, and structured data handling.
+ *
+ * @example
+ * ```ts
+ * const parser = new LogParserService();
+ * const entry = parser.parseLine('2026-02-05T21:35:28.944Z INFO ⦗API⦘ Message');
+ * // entry.level = 'info'
+ * // entry.timestamp = '2026-02-05T21:35:28.944Z'
+ * // entry.tags = ['API']
+ * ```
+ */
+export class LogParserService {
+  /** ANSI parser instance */
+  private ansiParser: AnsiParser;
+
+  /** Log level detector instance */
+  private levelDetector: LogLevelDetector;
+
+  /** Badge formatter instance */
+  private badgeFormatter: BadgeFormatter;
+
+  /** Multiline aggregator instance */
+  private multilineAggregator: MultilineAggregator;
+
+  /** Parser options */
+  private options: Required<ILogParserOptions>;
+
+  /**
+   * Create a new log parser service.
+   *
+   * @param options - Parser configuration options
+   */
+  constructor(options: ILogParserOptions = {}) {
+    this.options = {
+      enable_ansi: true,
+      timestamp_format: 'time',
+      enable_structured: true,
+      enable_tags: true,
+      max_line_length: 10000,
+      level_patterns: {},
+      ...options,
+    };
+
+    this.ansiParser = new AnsiParser();
+    this.badgeFormatter = new BadgeFormatter();
+    this.multilineAggregator = new MultilineAggregator();
+
+    // Convert level_patterns from Partial<Record<TLogLevel, RegExp>> to ILogLevelPattern[]
+    const customPatterns = this.options.level_patterns
+      ? Object.entries(this.options.level_patterns).map(([level, regex]) => ({
+          level: level as TLogLevel,
+          regex,
+          confidence: 0.9,
+        }))
+      : undefined;
+
+    this.levelDetector = new LogLevelDetector({
+      custom_patterns: customPatterns,
+    });
+  }
+
+  /**
+   * Parse a single log line into structured entry.
+   *
+   * @param line - Raw log line
+   * @param lineNumber - Line number in stream
+   * @param isStderr - Whether this is from stderr
+   * @returns Parsed log entry
+   */
+  parseLine(line: string, lineNumber: number, isStderr = false): IParsedLogEntry {
+    // Truncate if too long
+    let raw = line;
+    let wasTruncated = false;
+
+    if (line.length > this.options.max_line_length) {
+      raw = line.slice(0, this.options.max_line_length) + '... (truncated)';
+      wasTruncated = true;
+    }
+
+    // Detect log level
+    const levelDetection = this.levelDetector.detect(raw);
+    const level =
+      levelDetection.confidence >= 0.5 ? levelDetection.level : this.levelDetector.detectOrDefault(raw);
+
+    // Extract timestamp
+    const timestamp = this.extractTimestamp(raw);
+    const timestampDisplay = this.formatTimestamp(timestamp);
+
+    // Extract tags
+    const tags = this.options.enable_tags ? this.extractTags(raw) : undefined;
+
+    // Extract message (after level and metadata)
+    const message = this.extractMessage(raw, timestamp, levelDetection.matched);
+
+    // Parse ANSI if enabled
+    let formatted = raw;
+    if (this.options.enable_ansi) {
+      const result = this.ansiParser.parse(raw);
+      formatted = result.text;
+    } else {
+      formatted = AnsiParser.stripAnsi(raw);
+    }
+
+    // Detect structured data (JSON)
+    let structured: Record<string, unknown> | undefined;
+    if (this.options.enable_structured) {
+      structured = this.parseStructured(raw);
+    }
+
+    return {
+      raw: wasTruncated ? raw : line,
+      formatted,
+      level,
+      timestamp,
+      timestamp_display: timestampDisplay,
+      line_number: lineNumber,
+      is_stderr: isStderr,
+      structured,
+      tags,
+      message,
+    };
+  }
+
+  /**
+   * Parse multiple lines (batch processing).
+   *
+   * @param lines - Array of raw log lines
+   * @param startNumber - Starting line number (default: 1)
+   * @returns Array of parsed log entries
+   */
+  parseLines(lines: string[], startNumber = 1): IParsedLogEntry[] {
+    return lines.map((line, index) => this.parseLine(line, startNumber + index));
+  }
+
+  /**
+   * Parse logs with incremental state (for streaming).
+   *
+   * Maintains state between chunks for proper multiline log
+   * aggregation and line numbering. Applies multiline aggregation
+   * to mark continuation lines.
+   *
+   * @param chunk - New log chunk
+   * @param prevState - Previous parser state
+   * @returns Parsed entries and new state
+   */
+  parseIncremental(chunk: string, prevState: IParserState): { entries: IParsedLogEntry[]; newState: IParserState } {
+    // Append chunk to buffer
+    const buffer = prevState.buffer + chunk;
+
+    // Split by newlines
+    const lines = buffer.split('\n');
+
+    // Keep last incomplete line in buffer
+    const lastLine = lines.pop() ?? '';
+    let currentLineNumber = prevState.line_number;
+
+    // Parse complete lines
+    const entries: IParsedLogEntry[] = [];
+    for (const line of lines) {
+      if (line.length > 0) {
+        currentLineNumber++;
+        entries.push(this.parseLine(line, currentLineNumber));
+      }
+    }
+
+    // Apply multiline aggregation to mark continuation lines
+    // Convert parser multiline state to aggregator state format
+    const initialMultilineState = prevState.multiline_state ? {
+      buffer: [],
+      isMultiline: prevState.multiline_state.isMultiline,
+      depth: prevState.multiline_state.depth,
+      expectedClose: prevState.multiline_state.expectedClose,
+      parentEntry: prevState.multiline_state.parentEntry,
+    } : undefined;
+
+    const { entries: aggregated, state: newMultilineState } = this.multilineAggregator.aggregate(entries, initialMultilineState);
+
+    // Convert aggregator state back to parser state format
+    const lastEntry = aggregated.length > 0 ? aggregated[aggregated.length - 1] : undefined;
+
+    const newState: IParserState = {
+      buffer: lastLine,
+      line_number: currentLineNumber,
+      last_level: lastEntry?.level ?? prevState.last_level,
+      last_timestamp: lastEntry?.timestamp ?? prevState.last_timestamp,
+      multiline_state: newMultilineState.isMultiline || newMultilineState.depth > 0 ? {
+        isMultiline: newMultilineState.isMultiline,
+        depth: newMultilineState.depth,
+        expectedClose: newMultilineState.expectedClose,
+        parentEntry: newMultilineState.parentEntry,
+      } : undefined,
+    };
+
+    return { entries: aggregated, newState };
+  }
+
+  /**
+   * Format log entry for xterm.js display.
+   *
+   * Supports two modes:
+   *
+   * **'raw' mode (default for terminal):**
+   * - Returns the log AS-IS without modifications
+   * - Preserves original ANSI codes from the source (bun, supervisord, etc.)
+   * - No badges, no formatting, just the raw log line
+   * - Prevents ANSI mixing artifacts and visible escape codes
+   *
+   * **'parsed' mode (for React viewer):**
+   * - Strips ANSI codes first
+   * - Adds level badge, tag badges, timestamp badge
+   * - Formats message content for React display
+   * - Continuation lines get indented
+   *
+   * @param entry - Parsed log entry
+   * @param mode - Format mode: 'raw' (default) or 'parsed'
+   * @returns Formatted string for xterm.js or React viewer
+   */
+  formatForTerminal(entry: IParsedLogEntry, mode: 'raw' | 'parsed' = 'raw'): string {
+    // RAW MODE: Return log as-is, no modifications
+    // This preserves original ANSI codes from the source that work correctly with xterm.js
+    if (mode === 'raw') {
+      return entry.raw;
+    }
+
+    // PARSED MODE: Strip ANSI, add badges, format for React viewer
+    // For continuation lines (multiline JSON), indent and return stripped
+    if (entry.is_continuation) {
+      const indent = '  ';
+      return indent + AnsiParser.stripAnsi(entry.raw).trimEnd();
+    }
+
+    const parts: string[] = [];
+
+    // 1. Level badge at start
+    const levelBadge = this.badgeFormatter.createLevelBadge(entry.level);
+    parts.push(levelBadge);
+
+    // 2. Tag badges (if any)
+    if (entry.tags && entry.tags.length > 0) {
+      const tagBadges = this.badgeFormatter.createTagBadges(entry.tags);
+      if (tagBadges) {
+        parts.push(tagBadges);
+      }
+    }
+
+    // 3. Message content - use STRIPPED message for parsed mode
+    // entry.message is stripped of metadata but may be incomplete
+    // entry.raw is the full line, we strip ANSI from it for parsed mode
+    const messageContent = entry.message ?? AnsiParser.stripAnsi(entry.raw);
+    parts.push(messageContent);
+
+    // 4. Build line with timestamp at end
+    let line = parts.join(' ');
+
+    // Add timestamp at the end, right-aligned
+    if (entry.timestamp_display) {
+      const timestampBadge = this.badgeFormatter.createTimestampBadge(entry.timestamp_display);
+      line = line + timestampBadge;
+    }
+
+    return line;
+  }
+
+  /**
+   * Check if line contains structured data (JSON).
+   *
+   * @param line - Log line to check
+   * @returns true if line contains valid JSON
+   */
+  isStructured(line: string): boolean {
+    const trimmed = line.trim();
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+      try {
+        JSON.parse(trimmed);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Filter log entries by criteria.
+   *
+   * @param entries - Array of parsed log entries
+   * @param filter - Filter options
+   * @returns Filtered array of entries
+   */
+  filter(entries: IParsedLogEntry[], filter: ILogFilterOptions): IParsedLogEntry[] {
+    return entries.filter((entry) => {
+      // Minimum level
+      if (filter.min_level !== undefined) {
+        const entrySeverity = LogLevelDetector.getSeverity(entry.level);
+        const minSeverity = LogLevelDetector.getSeverity(filter.min_level);
+        if (entrySeverity < minSeverity) return false;
+      }
+
+      // stderr only
+      if (filter.stderr_only !== undefined) {
+        if (filter.stderr_only && !entry.is_stderr) return false;
+        if (!filter.stderr_only && entry.is_stderr) return false;
+      }
+
+      // Pattern match
+      if (filter.pattern) {
+        if (!filter.pattern.test(entry.raw)) return false;
+      }
+
+      // Tags filter
+      if (filter.tags && filter.tags.length > 0) {
+        if (!entry.tags || !filter.tags.some((t) => entry.tags?.includes(t))) return false;
+      }
+
+      // Time range
+      if (filter.after && entry.timestamp) {
+        if (entry.timestamp < filter.after) return false;
+      }
+      if (filter.before && entry.timestamp) {
+        if (entry.timestamp > filter.before) return false;
+      }
+
+      return true;
+    });
+  }
+
+  /**
+   * Calculate statistics for log entries.
+   *
+   * @param entries - Array of parsed log entries
+   * @returns Log statistics
+   */
+  calculateStats(entries: IParsedLogEntry[]): ILogStats {
+    const byLevel: Partial<Record<TLogLevel, number>> = {
+      trace: 0,
+      debug: 0,
+      info: 0,
+      warn: 0,
+      error: 0,
+      fatal: 0,
+      unknown: 0,
+    };
+
+    let bytes = 0;
+    let earliest: string | undefined;
+    let latest: string | undefined;
+
+    for (const entry of entries) {
+      byLevel[entry.level] = (byLevel[entry.level] ?? 0) + 1;
+      bytes += entry.raw.length;
+
+      if (entry.timestamp) {
+        if (!earliest || entry.timestamp < earliest) earliest = entry.timestamp;
+        if (!latest || entry.timestamp > latest) latest = entry.timestamp;
+      }
+    }
+
+    return {
+      total: entries.length,
+      by_level: byLevel,
+      bytes,
+      earliest,
+      latest,
+    };
+  }
+
+  /**
+   * Create initial parser state.
+   *
+   * @returns Fresh parser state for incremental parsing
+   */
+  createInitialState(): IParserState {
+    return {
+      buffer: '',
+      line_number: 0,
+      last_level: 'info',
+      last_timestamp: undefined,
+      multiline_state: undefined,
+    };
+  }
+
+  /**
+   * Extract timestamp from log line.
+   *
+   * Handles multiple timestamp formats including:
+   * - Double timestamp (ISO + time): 2026-02-05T22:41:05.372Z 22:41:05.372
+   * - Supervisord: 2026-02-05 22:22:38,372
+   * - Unix milliseconds: [1770328479225]
+   *
+   * @param line - Log line
+   * @returns ISO timestamp string or undefined
+   * @private
+   */
+  private extractTimestamp(line: string): string | undefined {
+    for (const pattern of TIMESTAMP_PATTERNS) {
+      const match = line.match(pattern.regex);
+      if (match) {
+        // For double timestamp, extract the time portion (index 2 if available, else 1)
+        const captured = match[(pattern as { extractIndex?: number }).extractIndex ?? 1];
+
+        if (pattern.format === 'unix') {
+          return new Date(parseInt(captured, 10)).toISOString();
+        }
+
+        // For double timestamp, return the time portion for display
+        // For ISO, convert to time portion later in formatTimestamp
+        return captured;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Format timestamp for display.
+   *
+   * @param timestamp - ISO timestamp
+   * @returns Formatted timestamp string
+   * @private
+   */
+  private formatTimestamp(timestamp: string | undefined): string | undefined {
+    if (!timestamp) return undefined;
+
+    switch (this.options.timestamp_format) {
+      case 'none':
+        return undefined;
+
+      case 'full':
+        return timestamp;
+
+      case 'time':
+        // Extract time portion: 21:35:28.944
+        const timeMatch = timestamp.match(/(\d{2}:\d{2}:\d{2}(?:\.\d+)?)/);
+        return timeMatch ? timeMatch[1] : timestamp;
+
+      case 'relative':
+        const date = new Date(timestamp);
+        const now = new Date();
+        const diff = now.getTime() - date.getTime();
+        if (diff < 1000) return 'just now';
+        if (diff < 60000) return `${Math.floor(diff / 1000)}s ago`;
+        if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+        return `${Math.floor(diff / 3600000)}h ago`;
+
+      default:
+        return timestamp;
+    }
+  }
+
+  /**
+   * Extract tags from log line.
+   *
+   * @param line - Log line
+   * @returns Array of extracted tags
+   * @private
+   */
+  private extractTags(line: string): string[] {
+    const tags: string[] = [];
+    let match: RegExpExecArray | null;
+
+    // 1. Brackets format: [INFO], [WARN], [ERROR], [SUCCESS]
+    const bracketPattern = /\[([A-Z]+)\]/g;
+    bracketPattern.lastIndex = 0;
+    while ((match = bracketPattern.exec(line)) !== null) {
+      tags.push(match[1]);
+    }
+
+    // 2. Parentheses format: (INFO), (WARN), (ERROR)
+    const parenPattern = /\(([^)]+)\)/g;
+    parenPattern.lastIndex = 0;
+    while ((match = parenPattern.exec(line)) !== null) {
+      const tag = match[1].toUpperCase();
+      if (!tags.includes(tag)) {
+        tags.push(tag);
+      }
+    }
+
+    // 3. Angle brackets: <INFO>, <WARN>, <ERROR>
+    const anglePattern = /<([^>]+)>/g;
+    anglePattern.lastIndex = 0;
+    while ((match = anglePattern.exec(line)) !== null) {
+      const tag = match[1].toUpperCase();
+      if (!tags.includes(tag)) {
+        tags.push(tag);
+      }
+    }
+
+    // 4. Unicode tags: ⦗TAG⦘
+    TAG_PATTERN.lastIndex = 0;
+    while ((match = TAG_PATTERN.exec(line)) !== null) {
+      const tag = match[1];
+      if (!tags.includes(tag)) {
+        tags.push(tag);
+      }
+    }
+
+    return tags;
+  }
+
+  /**
+   * Extract message content from log line.
+   *
+   * Removes ALL metadata including timestamps, levels, tags, and source locations
+   * to return only the clean message content.
+   *
+   * @param line - Log line
+   * @param _timestamp - Extracted timestamp (unused, kept for API compatibility)
+   * @param _levelMatch - Level match string (unused, kept for API compatibility)
+   * @returns Message content
+   * @private
+   */
+  private extractMessage(line: string, _timestamp?: string, _levelMatch?: string): string {
+    let message = line;
+
+    // Remove ALL timestamps (multiple formats)
+    message = message
+      // Double timestamp: 2026-02-05T22:41:05.372991285Z 22:41:05.372
+      .replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?\s+\d{2}:\d{2}:\d{2}(?:\.\d+)?\s+/, '')
+      // ISO timestamp: 2026-02-05T22:41:05.372991285Z
+      .replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?\s*/, '')
+      // Time only: 22:41:05.372
+      .replace(/^\d{2}:\d{2}:\d{2}(?:\.\d+)?\s*/, '')
+      // Supervisord format: 2026-02-05 22:22:38,372
+      .replace(/^\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2},\d+\s+/, '')
+      // Unix timestamp: [1770328479225]
+      .replace(/^\[\d{13,}\]\s*/, '')
+      // Bracketed datetime: [2026-02-05 21:35:28]
+      .replace(/^\[\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\]\s*/, '')
+      // Syslog format: Feb  5 21:35:28
+      .replace(/^[A-Z][a-z]{2}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+/, '');
+
+    // Remove emoji + text level indicators: ℹ️ INFO, ⚠️ WARN, ❌ ERROR
+    message = message
+      .replace(/^\s*[ℹ️🔵💙📖📝]+\s+(?:INFO(?:RMATION)?\s*)?/i, '') // info
+      .replace(/^\s*[⚠️🟡⚡🔶]+\s*(?:WARN(?:ING)?\s*)?/i, '') // warn
+      .replace(/^\s*[❌🔴❗🚨⛔]+\s*(?:ERROR\s*)?/i, '') // error
+      .replace(/^\s*[🐛🔍🔬⚙️]+\s*(?:DEBUG\s*)?/i, '') // debug
+      .replace(/^\s*[💀🔥☠️⚰️]+\s*(?:FATAL|CRITICAL\s*)?/i, '') // fatal/critical
+      // Next.js/symbol patterns
+      .replace(/^\s*[▲✓✗⚡]+\s*/, '');
+
+    // Remove bracketed level indicators: [INFO], (WARN), <ERROR>, {INFO}
+    message = message
+      .replace(/^\s*\[(?:TRACE|DEBUG|INFO|WARN(?:ING)?|ERROR|FATAL|CRITICAL)\]\s*/i, '')
+      .replace(/^\s*(?:TRACE|DEBUG|INFO|WARN(?:ING)?|ERROR|FATAL|CRITICAL):\s*/i, '');
+
+    // Remove ALL bracketed tags: ⦗COMPONENT⦘ ⦗WORKSPACEMANAGERROUTES⦘
+    message = message.replace(/⦗[^⦘]+⦘\s*/g, '');
+
+    // Remove source location: (native:7:39) or (file.ts:42:10)
+    message = message.replace(/\([^)]+\d+:\d+\)\s*/, '');
+
+    // Remove colon-prefixed tags: [ContainerLogs]
+    message = message.replace(/^\[[\w\s]+\]\s*/, '');
+
+    // Remove leading emoji remnants
+    message = message.replace(/^\s*[ℹ️⚠️❌🐛💀🚨🔥☠️⚰️🔵🟡🔴💙📖📝🔍🔬⚙️🔶▲✓✗⚡]+\s*/, '');
+
+    // Clean up extra whitespace and trailing commas/braces
+    message = message
+      .replace(/^\s+/, '') // Leading whitespace
+      .replace(/\s+$/, '') // Trailing whitespace
+      .replace(/^[,\s]+/, '') // Leading commas/whitespace from multiline JSON
+      .trim();
+
+    return message;
+  }
+
+  /**
+   * Parse structured data (JSON) from log line.
+   *
+   * @param line - Log line
+   * @returns Parsed object or undefined
+   * @private
+   */
+  private parseStructured(line: string): Record<string, unknown> | undefined {
+    // Try to find JSON in the line
+    const jsonMatch = line.match(/\{[^{}]*\}/);
+    if (!jsonMatch) return undefined;
+
+    try {
+      return JSON.parse(jsonMatch[0]) as Record<string, unknown>;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * Get ANSI color code for log level.
+   *
+   * @param level - Log level
+   * @returns ANSI SGR color code
+   * @private
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  private _getAnsiColorForLevel(level: TLogLevel): number {
+    const colors: Record<TLogLevel, number> = {
+      trace: 90,    // Gray
+      debug: 36,    // Cyan
+      info: 34,     // Blue
+      warn: 33,     // Yellow
+      error: 31,    // Red
+      fatal: 35,    // Magenta
+      unknown: 37,  // White
+    };
+    return colors[level] ?? 37;
+  }
+}