unreal-engine-mcp-server 0.5.4 → 0.5.5

package/src/utils/command-validator.ts

@@ -1,139 +0,0 @@
-/**
- * Validates console commands before execution to prevent dangerous operations.
- * Blocks crash-inducing commands, shell injection, and Python execution.
- */
-export class CommandValidator {
-    /**
-     * Commands that can crash the engine or cause severe instability.
-     * These are blocked unconditionally.
-     */
-    private static readonly DANGEROUS_COMMANDS = [
-        // Engine termination commands
-        'quit', 'exit', 'kill', 'crash',
-        // Crash-inducing commands
-        'r.gpucrash', 'r.crash', 'debug crash', 'forcecrash', 'debug break',
-        'assert false', 'check(false)',
-        // View buffer commands that can crash on some hardware
-        'viewmode visualizebuffer basecolor',
-        'viewmode visualizebuffer worldnormal',
-        // Heavy operations that can cause access violations if systems not initialized
-        'buildpaths', 'rebuildnavigation',
-        // Heavy debug commands that can stall or crash
-        'obj garbage', 'obj list', 'memreport',
-        // Potentially destructive without proper setup
-        'delete', 'destroy'
-    ];
-
-    /**
-     * Tokens that indicate shell injection or external system access attempts.
-     * Any command containing these is blocked.
-     */
-    private static readonly FORBIDDEN_TOKENS = [
-        // Shell commands (Windows/Unix)
-        'rm ', 'rm-', 'del ', 'format ', 'shutdown', 'reboot',
-        'rmdir', 'mklink', 'copy ', 'move ', 'start "', 'system(',
-        // Python injection attempts
-        'import os', 'import subprocess', 'subprocess.', 'os.system',
-        'exec(', 'eval(', '__import__', 'import sys', 'import importlib',
-        'with open', 'open(', 'write(', 'read('
-    ];
-
-    /**
-     * Patterns that indicate obviously invalid commands.
-     * Used to warn about likely typos or invalid input.
-     */
-    private static readonly INVALID_PATTERNS = [
-        /^\d+$/,  // Just numbers
-        /^invalid_command/i,
-        /^this_is_not_a_valid/i,
-    ];
-
-    /**
-     * Pre-compiled patterns for dangerous commands using word boundaries.
-     * This prevents false positives like 'show exit menu' matching 'exit'.
-     */
-    private static readonly DANGEROUS_PATTERNS = CommandValidator.DANGEROUS_COMMANDS.map(
-        cmd => new RegExp(`(?:^|\\s)${cmd.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\s|$)`, 'i')
-    );
-
-    /**
-     * Validates a console command for safety before execution.
-     * @param command - The console command string to validate
-     * @throws Error if the command is dangerous, contains forbidden tokens, or is invalid
-     */
-    static validate(command: string): void {
-        if (!command || typeof command !== 'string') {
-            throw new Error('Invalid command: must be a non-empty string');
-        }
-
-        const cmdTrimmed = command.trim();
-        if (cmdTrimmed.length === 0) {
-            return; // Empty commands are technically valid (no-op)
-        }
-
-        if (cmdTrimmed.includes('\n') || cmdTrimmed.includes('\r')) {
-            throw new Error('Multi-line console commands are not allowed. Send one command per call.');
-        }
-
-        const cmdLower = cmdTrimmed.toLowerCase();
-
-        if (cmdLower === 'py' || cmdLower.startsWith('py ')) {
-            throw new Error('Python console commands are blocked from external calls for safety.');
-        }
-
-        // Use word-boundary matching to avoid false positives like 'show exit menu'
-        if (this.DANGEROUS_PATTERNS.some(pattern => pattern.test(cmdLower))) {
-            throw new Error(`Dangerous command blocked: ${command}`);
-        }
-
-        if (cmdLower.includes('&&') || cmdLower.includes('||')) {
-            throw new Error('Command chaining with && or || is blocked for safety.');
-        }
-
-        // Block semicolon and pipe which can also be used for command chaining/injection
-        if (cmdTrimmed.includes(';')) {
-            throw new Error('Command chaining with ; (semicolon) is blocked for safety.');
-        }
-        if (cmdTrimmed.includes('|')) {
-            throw new Error('Command piping with | is blocked for safety.');
-        }
-
-        if (this.FORBIDDEN_TOKENS.some(token => cmdLower.includes(token))) {
-            throw new Error(`Command contains unsafe token and was blocked: ${command}`);
-        }
-
-        // Block backticks which can be used for shell execution
-        if (cmdTrimmed.includes('`')) {
-            throw new Error('Backtick characters are blocked for safety.');
-        }
-    }
-
-    /**
-     * Check if a command looks like an obviously invalid or mistyped command.
-     * @param command - The command to check
-     * @returns true if the command matches known invalid patterns
-     */
-    static isLikelyInvalid(command: string): boolean {
-        const cmdTrimmed = command.trim();
-        return this.INVALID_PATTERNS.some(pattern => pattern.test(cmdTrimmed));
-    }
-
-    /**
-     * Get the priority level of a command for throttling purposes.
-     * Lower numbers indicate heavier operations that need more throttling.
-     * @param command - The command to evaluate
-     * @returns Priority level (1=heavy, 5=medium, 7=default, 8-9=light)
-     */
-    static getPriority(command: string): number {
-        if (command.includes('BuildLighting') || command.includes('BuildPaths')) {
-            return 1; // Heavy operation
-        } else if (command.includes('summon') || command.includes('spawn')) {
-            return 5; // Medium operation
-        } else if (command.startsWith('stat')) {
-            return 8; // Dedicated throttling for stat commands
-        } else if (command.startsWith('show')) {
-            return 9; // Light operation
-        }
-        return 7; // Default priority
-    }
-}

package/src/utils/elicitation.ts

@@ -1,132 +0,0 @@
-import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { Logger } from './logger.js';
-
-// Minimal helper to opportunistically use MCP Elicitation when available.
-// Safe across clients: validates schema shape and handles timeouts and -32601 errors.
-export type PrimitiveSchema =
-  | { type: 'string'; title?: string; description?: string; minLength?: number; maxLength?: number; pattern?: string; format?: 'email'|'uri'|'date'|'date-time'; default?: string }
-  | { type: 'number'|'integer'; title?: string; description?: string; minimum?: number; maximum?: number; default?: number }
-  | { type: 'boolean'; title?: string; description?: string; default?: boolean }
-  | { type: 'string'; enum: string[]; enumNames?: string[]; title?: string; description?: string; default?: string };
-
-export interface ElicitSchema {
-  type: 'object';
-  properties: Record<string, PrimitiveSchema>;
-  required?: string[];
-}
-
-export interface ElicitOptions {
-  timeoutMs?: number;
-  // Handler invoked when elicitation cannot be performed; previously named
-  // Handler invoked when elicitation cannot be performed.
-  alternate?: () => Promise<{ ok: boolean; value?: any; error?: string }>;
-}
-
-export function createElicitationHelper(server: Server, log: Logger) {
-  // We do not require explicit capability detection: we optimistically try once
-  // and disable on a Method-not-found (-32601) error for the session.
-  let supported = true; // optimistic; will be set false on first failure
-
-  const MIN_TIMEOUT_MS = 30_000;
-  const MAX_TIMEOUT_MS = 10 * 60 * 1000;
-  const DEFAULT_TIMEOUT_MS = 3 * 60 * 1000;
-
-  const timeoutEnvRaw = process.env.MCP_ELICITATION_TIMEOUT_MS ?? process.env.ELICITATION_TIMEOUT_MS ?? '';
-  const parsedEnvTimeout = Number.parseInt(timeoutEnvRaw, 10);
-  const defaultTimeoutMs = Number.isFinite(parsedEnvTimeout) && parsedEnvTimeout > 0
-    ? Math.min(Math.max(parsedEnvTimeout, MIN_TIMEOUT_MS), MAX_TIMEOUT_MS)
-    : DEFAULT_TIMEOUT_MS;
-
-  if (timeoutEnvRaw) {
-    log.debug('Configured elicitation timeout override detected', {
-      defaultTimeoutMs,
-      fromEnv: timeoutEnvRaw
-    });
-  }
-
-  function isSafeSchema(schema: ElicitSchema): boolean {
-    if (!schema || schema.type !== 'object' || typeof schema.properties !== 'object') return false;
-
-    const propertyEntries = Object.entries(schema.properties ?? {});
-    const propertyKeys = propertyEntries.map(([key]) => key);
-
-    if (schema.required) {
-      if (!Array.isArray(schema.required)) return false;
-      const invalidRequired = schema.required.some((key) => typeof key !== 'string' || !propertyKeys.includes(key));
-      if (invalidRequired) return false;
-    }
-
-    return propertyEntries.every(([, rawSchema]) => {
-      if (!rawSchema || typeof rawSchema !== 'object') return false;
-      const primitive = rawSchema as PrimitiveSchema & { properties?: unknown; items?: unknown }; // narrow for guards
-
-      if ('properties' in primitive || 'items' in primitive) return false; // nested schemas unsupported
-
-      if (Array.isArray((primitive as any).enum)) {
-        const enumValues = (primitive as any).enum;
-        const allStrings = enumValues.every((value: unknown) => typeof value === 'string');
-        if (!allStrings) return false;
-        return !('type' in primitive) || (primitive as any).type === 'string';
-      }
-
-      if ((primitive as any).type === 'string') return true;
-      if ((primitive as any).type === 'number' || (primitive as any).type === 'integer') return true;
-      if ((primitive as any).type === 'boolean') return true;
-
-      return false;
-    });
-  }
-
-  async function elicit(message: string, requestedSchema: ElicitSchema, opts: ElicitOptions = {}) {
-    if (!supported || !isSafeSchema(requestedSchema)) {
-      if (opts.alternate) return opts.alternate();
-      return { ok: false, error: 'elicitation-unsupported' };
-    }
-
-    const params = { message, requestedSchema } as any;
-
-    try {
-      const elicitMethod = (server as any)?.elicitInput;
-      if (typeof elicitMethod !== 'function') {
-        supported = false;
-        throw new Error('elicitInput-not-available');
-      }
-
-      const requestedTimeout = opts.timeoutMs;
-      const timeoutMs = Math.max(MIN_TIMEOUT_MS, requestedTimeout ?? defaultTimeoutMs);
-      const res: any = await elicitMethod.call(server, params, { timeout: timeoutMs });
-      const action = res?.action;
-      const content = res?.content;
-
-      if (action === 'accept') return { ok: true, value: content };
-      if (action === 'decline' || action === 'cancel') {
-        if (opts.alternate) return opts.alternate();
-        return { ok: false, error: action };
-      }
-      if (opts.alternate) return opts.alternate();
-      return { ok: false, error: 'unexpected-response' };
-    } catch (e: any) {
-      const msg = String(e?.message || e);
-      const code = (e as any)?.code ?? (e as any)?.error?.code;
-      // If client doesn't support it, don’t try again this session
-      if (
-        msg.includes('Method not found') ||
-        msg.includes('elicitInput-not-available') ||
-        msg.includes('request-not-available') ||
-        String(code) === '-32601'
-      ) {
-        supported = false;
-      }
-  // Use an alternate handler if provided when elicitation fails.
-  log.debug('Elicitation failed; using alternate handler', { error: msg, code });
-      if (opts.alternate) return opts.alternate();
-      return { ok: false, error: msg.includes('timeout') ? 'timeout' : 'rpc-failed' };
-    }
-  }
-
-  return {
-    supports: () => supported,
-    elicit,
-    getDefaultTimeoutMs: () => defaultTimeoutMs
-  };
-}

package/src/utils/error-handler.ts

@@ -1,287 +0,0 @@
-import { Logger } from './logger.js';
-import { BaseToolResponse } from '../types/tool-types.js';
-
-const log = new Logger('ErrorHandler');
-
-/**
- * Error types for categorization
- */
-export enum ErrorType {
-  VALIDATION = 'VALIDATION',
-  CONNECTION = 'CONNECTION',
-  UNREAL_ENGINE = 'UNREAL_ENGINE',
-  PARAMETER = 'PARAMETER',
-  EXECUTION = 'EXECUTION',
-  TIMEOUT = 'TIMEOUT',
-  UNKNOWN = 'UNKNOWN'
-}
-
-/**
- * Debug information attached to error responses in development mode
- */
-interface ErrorResponseDebug {
-  errorType: ErrorType;
-  originalError: string;
-  stack?: string;
-  context?: Record<string, unknown>;
-  retriable: boolean;
-  scope: string;
-}
-
-/**
- * Extended error response with optional debug info
- */
-interface ErrorToolResponse extends BaseToolResponse {
-  _debug?: ErrorResponseDebug;
-}
-
-/**
- * Represents any error object with common properties
- */
-interface ErrorLike {
-  message?: string;
-  code?: string;
-  type?: string;
-  errorType?: string;
-  stack?: string;
-  response?: { status?: number };
-}
-
-/**
- * Normalize any error type to ErrorLike interface
- */
-function normalizeErrorToLike(error: unknown): ErrorLike {
-  if (error instanceof Error) {
-    return {
-      message: error.message,
-      stack: error.stack,
-      code: (error as NodeJS.ErrnoException).code
-    };
-  }
-  if (typeof error === 'object' && error !== null) {
-    const obj = error as Record<string, unknown>;
-    return {
-      message: typeof obj.message === 'string' ? obj.message : undefined,
-      code: typeof obj.code === 'string' ? obj.code : undefined,
-      type: typeof obj.type === 'string' ? obj.type : undefined,
-      errorType: typeof obj.errorType === 'string' ? obj.errorType : undefined,
-      stack: typeof obj.stack === 'string' ? obj.stack : undefined,
-      response: typeof obj.response === 'object' && obj.response !== null
-        ? {
-          status: typeof (obj.response as Record<string, unknown>).status === 'number'
-            ? (obj.response as Record<string, unknown>).status as number
-            : undefined
-        }
-        : undefined
-    };
-  }
-  return { message: String(error) };
-}
-
-/**
- * Consistent error handling for all tools
- */
-export class ErrorHandler {
-  /**
-   * Create a standardized error response
-   * @param error - The error object (can be Error, string, object with message, or unknown)
-   * @param toolName - Name of the tool that failed
-   * @param context - Optional additional context for debugging
-   */
-  static createErrorResponse(
-    error: unknown,
-    toolName: string,
-    context?: Record<string, unknown>
-  ): ErrorToolResponse {
-    const errorObj = normalizeErrorToLike(error);
-    const errorType = this.categorizeError(errorObj);
-    const userMessage = this.getUserFriendlyMessage(errorType, errorObj);
-    const retriable = this.isRetriable(errorObj);
-    const scope = (context?.scope as string) || `tool-call/${toolName}`;
-    const errorMessage = errorObj.message || String(error);
-    const errorStack = errorObj.stack;
-
-    log.error(`Tool ${toolName} failed:`, {
-      type: errorType,
-      message: errorMessage,
-      retriable,
-      scope,
-      context
-    });
-
-    const response: ErrorToolResponse = {
-      success: false,
-      error: userMessage,
-      message: `Failed to execute ${toolName}: ${userMessage}`,
-      retriable,
-      scope
-    };
-
-    // Add debug info in development
-    if (process.env.NODE_ENV === 'development') {
-      response._debug = {
-        errorType,
-        originalError: errorMessage,
-        stack: errorStack,
-        context,
-        retriable,
-        scope
-      };
-    }
-
-    return response;
-  }
-
-  /**
-   * Categorize error by type
-   * @param error - The error to categorize
-   */
-  private static categorizeError(error: ErrorLike | Error | string): ErrorType {
-    const errorObj = typeof error === 'object' ? error as ErrorLike : null;
-    const explicitType = (errorObj?.type || errorObj?.errorType || '').toString().toUpperCase();
-    if (explicitType && Object.values(ErrorType).includes(explicitType as ErrorType)) {
-      return explicitType as ErrorType;
-    }
-
-    const errorMessage = (errorObj?.message || String(error)).toLowerCase();
-
-    // Connection errors
-    if (
-      errorMessage.includes('econnrefused') ||
-      errorMessage.includes('timeout') ||
-      errorMessage.includes('connection') ||
-      errorMessage.includes('network')
-    ) {
-      return ErrorType.CONNECTION;
-    }
-
-    // Validation errors
-    if (
-      errorMessage.includes('invalid') ||
-      errorMessage.includes('required') ||
-      errorMessage.includes('must be') ||
-      errorMessage.includes('validation')
-    ) {
-      return ErrorType.VALIDATION;
-    }
-
-    // Unreal Engine specific errors
-    if (
-      errorMessage.includes('unreal') ||
-      errorMessage.includes('connection failed') ||
-      errorMessage.includes('blueprint') ||
-      errorMessage.includes('actor') ||
-      errorMessage.includes('asset')
-    ) {
-      return ErrorType.UNREAL_ENGINE;
-    }
-
-    // Parameter errors
-    if (
-      errorMessage.includes('parameter') ||
-      errorMessage.includes('argument') ||
-      errorMessage.includes('missing')
-    ) {
-      return ErrorType.PARAMETER;
-    }
-
-    // Timeout errors
-    if (errorMessage.includes('timeout')) {
-      return ErrorType.TIMEOUT;
-    }
-
-    return ErrorType.UNKNOWN;
-  }
-
-  /**
-   * Get user-friendly error message
-   * @param type - The categorized error type
-   * @param error - The original error
-   */
-  private static getUserFriendlyMessage(type: ErrorType, error: ErrorLike | Error | string): string {
-    const originalMessage = (typeof error === 'object' && error !== null && 'message' in error)
-      ? (error as { message?: string }).message || String(error)
-      : String(error);
-
-    switch (type) {
-      case ErrorType.CONNECTION:
-        return 'Failed to connect to Unreal Engine. Please ensure the Automation Bridge plugin is active and the editor is running.';
-
-      case ErrorType.VALIDATION:
-        return `Invalid input: ${originalMessage}`;
-
-      case ErrorType.UNREAL_ENGINE:
-        return `Unreal Engine error: ${originalMessage}`;
-
-      case ErrorType.PARAMETER:
-        return `Invalid parameters: ${originalMessage}`;
-
-      case ErrorType.TIMEOUT:
-        return 'Operation timed out. Unreal Engine may be busy or unresponsive.';
-
-      case ErrorType.EXECUTION:
-        return `Execution failed: ${originalMessage}`;
-
-      default:
-        return originalMessage;
-    }
-  }
-
-  /**
-   * Determine if an error is likely retriable
-   * @param error - The error to check
-   */
-  private static isRetriable(error: ErrorLike | Error | string): boolean {
-    try {
-      const errorObj = typeof error === 'object' ? error as ErrorLike : null;
-      const code = (errorObj?.code || '').toString().toUpperCase();
-      const msg = (errorObj?.message || String(error) || '').toLowerCase();
-      const status = Number(errorObj?.response?.status);
-      if (['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EPIPE'].includes(code)) return true;
-      if (/timeout|timed out|network|connection|closed|unavailable|busy|temporar/.test(msg)) return true;
-      if (!isNaN(status) && (status === 429 || (status >= 500 && status < 600))) return true;
-    } catch (err) {
-      // Error checking retriability is uncommon; log at debug level
-      log.debug('isRetriable check failed', err instanceof Error ? err.message : String(err));
-    }
-    return false;
-  }
-
-  /**
-   * Retry a function with exponential backoff
-   * @param fn - The async function to retry
-   * @param options - Retry configuration options
-   */
-  static async retryWithBackoff<T>(
-    fn: () => Promise<T>,
-    options: {
-      maxRetries?: number;
-      initialDelay?: number;
-      maxDelay?: number;
-      backoffMultiplier?: number;
-      shouldRetry?: (error: ErrorLike | Error | unknown) => boolean;
-    } = {}
-  ): Promise<T> {
-    const maxRetries = options.maxRetries ?? 3;
-    const initialDelay = options.initialDelay ?? 1000;
-    const maxDelay = options.maxDelay ?? 10000;
-    const multiplier = options.backoffMultiplier ?? 2;
-    const shouldRetry = options.shouldRetry ?? ((err: unknown) => this.isRetriable(err as ErrorLike));
-
-    let delay = initialDelay;
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        return await fn();
-      } catch (error) {
-        if (attempt === maxRetries || !shouldRetry(error)) {
-          throw error;
-        }
-
-        await new Promise(resolve => setTimeout(resolve, delay));
-        delay = Math.min(delay * multiplier, maxDelay);
-      }
-    }
-    throw new Error('Max retries exceeded');
-  }
-}

package/src/utils/ini-reader.ts

@@ -1,86 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-
-export async function readIniFile(filePath: string): Promise<Record<string, Record<string, string>>> {
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    const result: Record<string, Record<string, string>> = {};
-    let currentSection = '';
-
-    const lines = content.split(/\r?\n/);
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith(';') || trimmed.startsWith('#')) {
-        continue;
-      }
-
-      if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
-        currentSection = trimmed.substring(1, trimmed.length - 1);
-        result[currentSection] = {};
-      } else if (currentSection) {
-        const parts = trimmed.split('=');
-        if (parts.length >= 2) {
-          const key = parts[0].trim();
-          const value = parts.slice(1).join('=').trim();
-          result[currentSection][key] = value;
-        }
-      }
-    }
-
-    return result;
-  } catch (error) {
-    throw new Error(`Failed to read INI file at ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-export async function getProjectSetting(projectPath: string, category: string, sectionName: string, key?: string): Promise<any> {
-    // Normalize project path to directory
-    let dirPath = projectPath;
-    if (dirPath.toLowerCase().endsWith('.uproject')) {
-        dirPath = path.dirname(dirPath);
-    }
-
-    // Possible file names/locations in order of preference (Config/DefaultX.ini, Saved/Config/WindowsEditor/X.ini)
-    // category is usually 'Project', 'Engine', 'Game', 'Input', etc.
-    const cleanCategory = category.replace(/^Default/, ''); // If caller passed 'DefaultEngine', normalize to 'Engine'
-    
-    const candidates = [
-        path.join(dirPath, 'Config', `Default${cleanCategory}.ini`),
-        path.join(dirPath, 'Saved', 'Config', 'WindowsEditor', `${cleanCategory}.ini`),
-        path.join(dirPath, 'Saved', 'Config', 'Windows', `${cleanCategory}.ini`),
-        path.join(dirPath, 'Saved', 'Config', 'Mac', `${cleanCategory}.ini`),
-        path.join(dirPath, 'Saved', 'Config', 'Linux', `${cleanCategory}.ini`)
-    ];
-
-    for (const configPath of candidates) {
-        try {
-            const iniData = await readIniFile(configPath);
-            // If we successfully read the file, check for the section
-            if (sectionName) {
-                const section = iniData[sectionName];
-                if (section) {
-                    if (key) {
-                        return section[key];
-                    }
-                    return section;
-                }
-                // If section not found in this file, continue to next candidate? 
-                // Usually we want the most authoritative, but if it's missing the section, maybe it's in another?
-                // For now, if we find the file, we return the data from it or null if section missing.
-                // Merging is complex without a proper config hierarchy implementation.
-                // We will assume if the file exists, it's the one we want, or if section is missing, we fail for this file.
-                // But 'Default' might lack user overrides.
-                // Given this is a simple reader, we'll return the first match that contains the section, 
-                // or if sectionName is empty, the first file found.
-            } else {
-                if (Object.keys(iniData).length > 0) {
-                    return iniData;
-                }
-            }
-        } catch (_e) {
-            // Continue to next candidate
-        }
-    }
-
-    return null;
-}

package/src/utils/logger.ts

@@ -1,35 +0,0 @@
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-
-export class Logger {
-  private level: LogLevel;
-
-  constructor(private scope: string, level: LogLevel = 'info') {
-    const envLevel = (process.env.LOG_LEVEL || process.env.LOGLEVEL || level).toString().toLowerCase();
-    this.level = (['debug', 'info', 'warn', 'error'] as LogLevel[]).includes(envLevel as LogLevel)
-      ? (envLevel as LogLevel)
-      : 'info';
-  }
-
-  private shouldLog(level: LogLevel) {
-    const order: LogLevel[] = ['debug', 'info', 'warn', 'error'];
-    return order.indexOf(level) >= order.indexOf(this.level);
-  }
-
-  debug(...args: any[]) {
-    if (!this.shouldLog('debug')) return;
-    // Write to stderr to avoid corrupting MCP stdout stream
-    console.error(`[${this.scope}]`, ...args);
-  }
-  info(...args: any[]) {
-    if (!this.shouldLog('info')) return;
-    // Write to stderr to avoid corrupting MCP stdout stream
-    console.error(`[${this.scope}]`, ...args);
-  }
-  warn(...args: any[]) {
-    if (!this.shouldLog('warn')) return;
-    console.warn(`[${this.scope}]`, ...args);
-  }
-  error(...args: any[]) {
-    if (this.shouldLog('error')) console.error(`[${this.scope}]`, ...args);
-  }
-}