@mks2508/mks-ui 0.5.7 → 0.5.8

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

@@ -1,686 +0,0 @@
-/**
- * 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;
-  }
-}