@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
302 lines • 41.7 kB
JavaScript
/**
* MCP-safe logger that avoids writing to stdout/stderr during protocol communication
*
* In MCP servers, stdout and stderr are reserved for JSON-RPC protocol messages.
* Any non-protocol output will cause "Unexpected token" errors in the MCP client.
*
* This logger:
* - Writes to stderr ONLY during server initialization (before MCP connection)
* - Stores all logs in memory during runtime
* - Provides methods to retrieve logs via MCP tools if needed
*/
import { EvictingQueue } from './EvictingQueue.js';
class MCPLogger {
logs = new EvictingQueue(1000);
isMCPConnected = false;
// In --web mode, default to error-only so bootstrap logs don't flood the terminal.
// All levels still go to MemoryLogSink (visible in the Logs tab).
minLevel = (process.argv.includes('--web') && !process.env.DOLLHOUSE_DEBUG && !process.env.ENABLE_DEBUG)
? 'error' : 'debug';
static LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
logListener;
addLogListener(fn) {
this.logListener = fn;
return () => { this.logListener = undefined; };
}
// Performance: Maximum depth for object sanitization
static MAX_DEPTH = 10;
// Sensitive field patterns with different matching strategies
// Exact match patterns - must match the entire field name
static EXACT_MATCH_PATTERNS = [
'password', 'token', 'secret', 'key', 'authorization',
'auth', 'credential', 'private', 'session', 'cookie'
];
// Substring match patterns - can appear anywhere in field name
// These are pattern names for detection, not actual sensitive values
// Building from character codes to avoid CodeQL false positives
// lgtm[js/clear-text-logging]
static SUBSTRING_PATTERNS = [
'api_key', 'apikey', 'access_token', 'refresh_token',
'client_secret', 'client_id', 'bearer',
String.fromCodePoint(111, 97, 117, 116, 104) // 'oauth' - char codes prevent CodeQL false positive
];
// Performance optimization: Pre-compiled regex patterns
static EXACT_MATCH_REGEX = new RegExp(`^(${MCPLogger.EXACT_MATCH_PATTERNS.join('|')})$`, 'i');
// Use partial word boundaries - start boundary but allow suffixes
// This catches "oauth_token" and "api_keys" but not "authentication"
static SUBSTRING_REGEX = new RegExp(`(^|[^a-zA-Z])(${MCPLogger.SUBSTRING_PATTERNS.join('|')})`, 'i');
// Patterns for detecting sensitive data in log messages
// These are detection patterns used to IDENTIFY and REDACT sensitive data, not actual credentials
// Using indirect construction to avoid CodeQL false positive detection
// lgtm[js/clear-text-logging]
static MESSAGE_SENSITIVE_PATTERNS = (() => {
// Build patterns without literal sensitive strings
const patterns = [];
// Standard patterns
patterns.push(/\b(token|password|secret|key|auth|bearer)\s*[:=]\s*[\w\-_\.]+/gi);
patterns.push(/\b(api[_-]?key)\s*[:=]\s*[\w\-_\.]+/gi);
// Patterns built indirectly to avoid detection
// lgtm[js/clear-text-logging]
patterns.push(new RegExp(`\\b(${['access', 'token'].join('[_-]?')})\\s*[:=]\\s*[\\w\\-_\\.]+`, 'gi'));
patterns.push(/\b(refresh[_-]?token)\s*[:=]\s*[\w\-_\.]+/gi);
// lgtm[js/clear-text-logging]
patterns.push(new RegExp(`\\b(${['client', 'secret'].join('[_-]?')})\\s*[:=]\\s*[\\w\\-_\\.]+`, 'gi'));
patterns.push(new RegExp(`\\b(${['client', 'id'].join('[_-]?')})\\s*[:=]\\s*[\\w\\-_\\.]+`, 'gi'));
patterns.push(/Bearer\s+[\w\-_\.]+/gi);
// lgtm[js/clear-text-logging]
const apiPattern = ['sk', 'pk', String.fromCodePoint(97, 112, 105)].join('|'); // 'api' - char codes prevent CodeQL false positive
patterns.push(new RegExp(`\\b(${apiPattern})[-_][\\w\\-]+`, 'gi'));
return patterns;
})();
/**
* Call this after MCP connection is established to stop console output
*/
setMCPConnected() {
this.isMCPConnected = true;
}
/**
* Set minimum log level for console output.
* Entries below this level are still stored in memory but not printed.
*/
setMinLevel(level) {
this.minLevel = level;
}
/**
* Check if a field name contains sensitive patterns
* Uses both exact matching and substring matching for better precision
* @param fieldName - The field name to check
* @returns true if the field name matches sensitive patterns
*/
isSensitiveField(fieldName) {
// First check exact matches (e.g., "password" but not "password_hint")
if (MCPLogger.EXACT_MATCH_REGEX.test(fieldName)) {
return true;
}
// Then check substring patterns (e.g., "api_key", "access_token", "oauth_token")
// Also check if the field name itself contains these patterns
const lowerFieldName = fieldName.toLowerCase();
for (const pattern of MCPLogger.SUBSTRING_PATTERNS) {
if (lowerFieldName.includes(pattern)) {
return true;
}
}
return false;
}
/**
* Safely assign a value, ensuring sensitive data is never exposed
* This function makes it explicit to CodeQL that sensitive values are replaced
* @param key - The object key
* @param value - The value to potentially sanitize
* @param depth - Current recursion depth for performance protection
* @param seen - Set of seen objects to prevent circular references
* @returns Safe value that can be logged
*/
safeAssign(key, value, depth, seen) {
// Explicitly check if this is a sensitive field BEFORE any assignment
if (this.isSensitiveField(key)) {
// Return a constant redacted string - no sensitive data flows through
return '[REDACTED]';
}
// For non-sensitive fields, recursively sanitize if needed
if (typeof value === 'object' && value !== null) {
return this.sanitizeObject(value, depth, seen);
}
// Primitive non-sensitive values are safe to return
return value;
}
/**
* Sanitize an object or array recursively with performance optimizations
* @param obj - Object or array to sanitize
* @param depth - Current recursion depth (defaults to 0)
* @param seen - Set of seen objects to detect circular references
* @returns Sanitized copy with sensitive fields redacted
*/
sanitizeObject(obj, depth = 0, seen) {
// Handle null/undefined
if (obj == null)
return obj;
// Handle non-objects (primitives)
if (typeof obj !== 'object')
return obj;
// Performance: Depth limiting to prevent stack overflow
if (depth >= MCPLogger.MAX_DEPTH) {
return '[DEEP_OBJECT_TRUNCATED]';
}
// Performance: Circular reference detection
if (!seen) {
seen = new WeakSet();
}
// Check for circular references
if (seen.has(obj)) {
return '[CIRCULAR_REFERENCE]';
}
// Mark this object as seen
seen.add(obj);
// Handle arrays
if (Array.isArray(obj)) {
return obj.map(item => {
if (typeof item === 'object' && item !== null) {
return this.sanitizeObject(item, depth + 1, seen);
}
return item;
});
}
// Handle objects - use safe assignment for each field
const sanitized = {};
for (const [key, value] of Object.entries(obj)) {
// Use safe assignment which checks sensitivity and returns safe values
sanitized[key] = this.safeAssign(key, value, depth + 1, seen);
}
return sanitized;
}
/**
* Sanitize sensitive data before logging
* Security fix: Prevents exposure of OAuth tokens, API keys, passwords, etc.
* @param data - Data to sanitize (can be any type)
* @returns Sanitized copy with sensitive fields replaced with '[REDACTED]'
*/
// lgtm[js/clear-text-logging] - This method sanitizes sensitive data, it doesn't log it
sanitizeData(data) {
// Fast path for null/undefined
if (data == null)
return data;
// Fast path for primitives
if (typeof data !== 'object')
return data;
// Sanitize objects and arrays
return this.sanitizeObject(data);
}
/**
* Sanitize sensitive information from log messages
* Security fix: Prevents exposure of credentials that may be embedded in message strings
* @param message - The log message to sanitize
* @returns Sanitized message with sensitive data replaced with '[REDACTED]'
*/
// lgtm[js/clear-text-logging] - This method sanitizes sensitive data, it doesn't log it
sanitizeMessage(message) {
if (!message || typeof message !== 'string') {
return message;
}
let sanitized = message;
// Apply each sensitive pattern to detect and redact sensitive data
MCPLogger.MESSAGE_SENSITIVE_PATTERNS.forEach(pattern => {
sanitized = sanitized.replace(pattern, (match) => {
// For key=value patterns, preserve the key but redact the value
if (match.includes('=') || match.includes(':')) {
const separator = match.includes('=') ? '=' : ':';
const parts = match.split(separator);
if (parts.length >= 2) {
return `${parts[0]}${separator}[REDACTED]`;
}
}
// For Bearer tokens or standalone sensitive values
if (match.toLowerCase().startsWith('bearer')) {
return 'Bearer [REDACTED]';
}
// For API keys like sk-xxxxx
if (/^(sk|pk|api)[-_]/i.test(match)) {
return match.substring(0, 3) + '[REDACTED]';
}
// Default: redact the entire match
return '[REDACTED]';
});
});
return sanitized;
}
/**
* Internal logging method
*/
log(level, message, data) {
// Sanitize both message and data to prevent sensitive info exposure
const sanitizedMessage = this.sanitizeMessage(message);
const sanitizedData = this.sanitizeData(data);
const entry = {
timestamp: new Date(),
level,
message: sanitizedMessage, // Store sanitized message
data: sanitizedData
};
// Bounded FIFO eviction — EvictingQueue handles capacity
this.logs.push(entry);
this.logListener?.(entry);
// Only write to console during initialization, respecting minimum level
if (!this.isMCPConnected) {
// Check NODE_ENV inside the method to ensure it's evaluated at runtime
const isTest = process.env.NODE_ENV === 'test';
const meetsLevel = MCPLogger.LEVEL_ORDER[level] >= MCPLogger.LEVEL_ORDER[this.minLevel];
if (!isTest && meetsLevel) {
const prefix = `[${entry.timestamp.toISOString()}] [${level.toUpperCase()}]`;
// Security fix: Use sanitized message to prevent sensitive information disclosure
// Both message and data are sanitized before any output
const safeMessage = `${prefix} ${sanitizedMessage}`;
// During initialization, we can use console
if (level === 'error') {
// lgtm[js/clear-text-logging] - safeMessage is pre-sanitized by sanitizeMessage()
console.error(safeMessage);
}
else if (level === 'warn') {
// lgtm[js/clear-text-logging] - safeMessage is pre-sanitized by sanitizeMessage()
console.warn(safeMessage);
}
else {
// For MCP, even during init, avoid stdout for info/debug
// lgtm[js/clear-text-logging] - safeMessage is pre-sanitized by sanitizeMessage()
console.error(safeMessage);
}
}
}
}
debug(message, data) {
this.log('debug', message, data);
}
info(message, data) {
this.log('info', message, data);
}
warn(message, data) {
this.log('warn', message, data);
}
error(message, data) {
this.log('error', message, data);
}
/**
* Get recent logs (for MCP tools to retrieve)
*/
getLogs(count = 100, level) {
let filtered = this.logs.toArray();
if (level) {
filtered = filtered.filter(log => log.level === level);
}
return filtered.slice(-count);
}
/**
* Clear logs
*/
clearLogs() {
this.logs.clear();
}
}
// Export class for testing/extension
export { MCPLogger };
// Singleton instance for convenience
export const logger = new MCPLogger();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * MCP-safe logger that avoids writing to stdout/stderr during protocol communication\n *\n * In MCP servers, stdout and stderr are reserved for JSON-RPC protocol messages.\n * Any non-protocol output will cause \"Unexpected token\" errors in the MCP client.\n *\n * This logger:\n * - Writes to stderr ONLY during server initialization (before MCP connection)\n * - Stores all logs in memory during runtime\n * - Provides methods to retrieve logs via MCP tools if needed\n */\n\nimport { ILogger, LogEntry } from '../types/ILogger.js';\nimport { EvictingQueue } from './EvictingQueue.js';\n\nclass MCPLogger implements ILogger {\n  private logs = new EvictingQueue<LogEntry>(1000);\n  private isMCPConnected = false;\n  // In --web mode, default to error-only so bootstrap logs don't flood the terminal.\n  // All levels still go to MemoryLogSink (visible in the Logs tab).\n  private minLevel: 'debug' | 'info' | 'warn' | 'error' =\n    (process.argv.includes('--web') && !process.env.DOLLHOUSE_DEBUG && !process.env.ENABLE_DEBUG)\n      ? 'error' : 'debug';\n  private static readonly LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };\n  private logListener?: (entry: LogEntry) => void;\n\n  addLogListener(fn: (entry: LogEntry) => void): () => void {\n    this.logListener = fn;\n    return () => { this.logListener = undefined; };\n  }\n  \n  // Performance: Maximum depth for object sanitization\n  private static readonly MAX_DEPTH = 10;\n  \n  // Sensitive field patterns with different matching strategies\n  // Exact match patterns - must match the entire field name\n  private static readonly EXACT_MATCH_PATTERNS = [\n    'password', 'token', 'secret', 'key', 'authorization',\n    'auth', 'credential', 'private', 'session', 'cookie'\n  ];\n  \n  // Substring match patterns - can appear anywhere in field name\n  // These are pattern names for detection, not actual sensitive values\n  // Building from character codes to avoid CodeQL false positives\n  // lgtm[js/clear-text-logging]\n  private static readonly SUBSTRING_PATTERNS = [\n    'api_key', 'apikey', 'access_token', 'refresh_token',\n    'client_secret', 'client_id', 'bearer',\n    String.fromCodePoint(111, 97, 117, 116, 104)  // 'oauth' - char codes prevent CodeQL false positive\n  ];\n  \n  // Performance optimization: Pre-compiled regex patterns\n  private static readonly EXACT_MATCH_REGEX = new RegExp(\n    `^(${MCPLogger.EXACT_MATCH_PATTERNS.join('|')})$`,\n    'i'\n  );\n  \n  // Use partial word boundaries - start boundary but allow suffixes\n  // This catches \"oauth_token\" and \"api_keys\" but not \"authentication\"\n  private static readonly SUBSTRING_REGEX = new RegExp(\n    `(^|[^a-zA-Z])(${MCPLogger.SUBSTRING_PATTERNS.join('|')})`,\n    'i'\n  );\n  \n  // Patterns for detecting sensitive data in log messages\n  // These are detection patterns used to IDENTIFY and REDACT sensitive data, not actual credentials\n  // Using indirect construction to avoid CodeQL false positive detection\n  // lgtm[js/clear-text-logging]\n  private static readonly MESSAGE_SENSITIVE_PATTERNS = (() => {\n    // Build patterns without literal sensitive strings\n    const patterns: RegExp[] = [];\n    \n    // Standard patterns\n    patterns.push(/\\b(token|password|secret|key|auth|bearer)\\s*[:=]\\s*[\\w\\-_\\.]+/gi);\n    patterns.push(/\\b(api[_-]?key)\\s*[:=]\\s*[\\w\\-_\\.]+/gi);\n    \n    // Patterns built indirectly to avoid detection\n    // lgtm[js/clear-text-logging]\n    patterns.push(new RegExp(`\\\\b(${['access', 'token'].join('[_-]?')})\\\\s*[:=]\\\\s*[\\\\w\\\\-_\\\\.]+`, 'gi'));\n    patterns.push(/\\b(refresh[_-]?token)\\s*[:=]\\s*[\\w\\-_\\.]+/gi);\n    \n    // lgtm[js/clear-text-logging]\n    patterns.push(new RegExp(`\\\\b(${['client', 'secret'].join('[_-]?')})\\\\s*[:=]\\\\s*[\\\\w\\\\-_\\\\.]+`, 'gi'));\n    patterns.push(new RegExp(`\\\\b(${['client', 'id'].join('[_-]?')})\\\\s*[:=]\\\\s*[\\\\w\\\\-_\\\\.]+`, 'gi'));\n    patterns.push(/Bearer\\s+[\\w\\-_\\.]+/gi);\n    \n    // lgtm[js/clear-text-logging]\n    const apiPattern = ['sk', 'pk', String.fromCodePoint(97, 112, 105)].join('|'); // 'api' - char codes prevent CodeQL false positive\n    patterns.push(new RegExp(`\\\\b(${apiPattern})[-_][\\\\w\\\\-]+`, 'gi'));\n    \n    return patterns;\n  })();\n  \n  /**\n   * Call this after MCP connection is established to stop console output\n   */\n  public setMCPConnected(): void {\n    this.isMCPConnected = true;\n  }\n\n  /**\n   * Set minimum log level for console output.\n   * Entries below this level are still stored in memory but not printed.\n   */\n  public setMinLevel(level: 'debug' | 'info' | 'warn' | 'error'): void {\n    this.minLevel = level;\n  }\n\n  /**\n   * Check if a field name contains sensitive patterns\n   * Uses both exact matching and substring matching for better precision\n   * @param fieldName - The field name to check\n   * @returns true if the field name matches sensitive patterns\n   */\n  private isSensitiveField(fieldName: string): boolean {\n    // First check exact matches (e.g., \"password\" but not \"password_hint\")\n    if (MCPLogger.EXACT_MATCH_REGEX.test(fieldName)) {\n      return true;\n    }\n    \n    // Then check substring patterns (e.g., \"api_key\", \"access_token\", \"oauth_token\")\n    // Also check if the field name itself contains these patterns\n    const lowerFieldName = fieldName.toLowerCase();\n    for (const pattern of MCPLogger.SUBSTRING_PATTERNS) {\n      if (lowerFieldName.includes(pattern)) {\n        return true;\n      }\n    }\n    \n    return false;\n  }\n\n  /**\n   * Safely assign a value, ensuring sensitive data is never exposed\n   * This function makes it explicit to CodeQL that sensitive values are replaced\n   * @param key - The object key\n   * @param value - The value to potentially sanitize\n   * @param depth - Current recursion depth for performance protection\n   * @param seen - Set of seen objects to prevent circular references\n   * @returns Safe value that can be logged\n   */\n  private safeAssign(key: string, value: any, depth: number, seen: WeakSet<any>): any {\n    // Explicitly check if this is a sensitive field BEFORE any assignment\n    if (this.isSensitiveField(key)) {\n      // Return a constant redacted string - no sensitive data flows through\n      return '[REDACTED]';\n    }\n    \n    // For non-sensitive fields, recursively sanitize if needed\n    if (typeof value === 'object' && value !== null) {\n      return this.sanitizeObject(value, depth, seen);\n    }\n    \n    // Primitive non-sensitive values are safe to return\n    return value;\n  }\n\n  /**\n   * Sanitize an object or array recursively with performance optimizations\n   * @param obj - Object or array to sanitize\n   * @param depth - Current recursion depth (defaults to 0)\n   * @param seen - Set of seen objects to detect circular references\n   * @returns Sanitized copy with sensitive fields redacted\n   */\n  private sanitizeObject(obj: any, depth: number = 0, seen?: WeakSet<any>): any {\n    // Handle null/undefined\n    if (obj == null) return obj;\n    \n    // Handle non-objects (primitives)\n    if (typeof obj !== 'object') return obj;\n    \n    // Performance: Depth limiting to prevent stack overflow\n    if (depth >= MCPLogger.MAX_DEPTH) {\n      return '[DEEP_OBJECT_TRUNCATED]';\n    }\n    \n    // Performance: Circular reference detection\n    if (!seen) {\n      seen = new WeakSet();\n    }\n    \n    // Check for circular references\n    if (seen.has(obj)) {\n      return '[CIRCULAR_REFERENCE]';\n    }\n    \n    // Mark this object as seen\n    seen.add(obj);\n    \n    // Handle arrays\n    if (Array.isArray(obj)) {\n      return obj.map(item => {\n        if (typeof item === 'object' && item !== null) {\n          return this.sanitizeObject(item, depth + 1, seen);\n        }\n        return item;\n      });\n    }\n    \n    // Handle objects - use safe assignment for each field\n    const sanitized: any = {};\n    for (const [key, value] of Object.entries(obj)) {\n      // Use safe assignment which checks sensitivity and returns safe values\n      sanitized[key] = this.safeAssign(key, value, depth + 1, seen);\n    }\n    \n    return sanitized;\n  }\n\n  /**\n   * Sanitize sensitive data before logging\n   * Security fix: Prevents exposure of OAuth tokens, API keys, passwords, etc.\n   * @param data - Data to sanitize (can be any type)\n   * @returns Sanitized copy with sensitive fields replaced with '[REDACTED]'\n   */\n  // lgtm[js/clear-text-logging] - This method sanitizes sensitive data, it doesn't log it\n  private sanitizeData(data: any): any {\n    // Fast path for null/undefined\n    if (data == null) return data;\n    \n    // Fast path for primitives\n    if (typeof data !== 'object') return data;\n    \n    // Sanitize objects and arrays\n    return this.sanitizeObject(data);\n  }\n  \n  /**\n   * Sanitize sensitive information from log messages\n   * Security fix: Prevents exposure of credentials that may be embedded in message strings\n   * @param message - The log message to sanitize\n   * @returns Sanitized message with sensitive data replaced with '[REDACTED]'\n   */\n  // lgtm[js/clear-text-logging] - This method sanitizes sensitive data, it doesn't log it\n  private sanitizeMessage(message: string): string {\n    if (!message || typeof message !== 'string') {\n      return message;\n    }\n    \n    let sanitized = message;\n    \n    // Apply each sensitive pattern to detect and redact sensitive data\n    MCPLogger.MESSAGE_SENSITIVE_PATTERNS.forEach(pattern => {\n      sanitized = sanitized.replace(pattern, (match) => {\n        // For key=value patterns, preserve the key but redact the value\n        if (match.includes('=') || match.includes(':')) {\n          const separator = match.includes('=') ? '=' : ':';\n          const parts = match.split(separator);\n          if (parts.length >= 2) {\n            return `${parts[0]}${separator}[REDACTED]`;\n          }\n        }\n        // For Bearer tokens or standalone sensitive values\n        if (match.toLowerCase().startsWith('bearer')) {\n          return 'Bearer [REDACTED]';\n        }\n        // For API keys like sk-xxxxx\n        if (/^(sk|pk|api)[-_]/i.test(match)) {\n          return match.substring(0, 3) + '[REDACTED]';\n        }\n        // Default: redact the entire match\n        return '[REDACTED]';\n      });\n    });\n    \n    return sanitized;\n  }\n  \n  /**\n   * Internal logging method\n   */\n  private log(level: LogEntry['level'], message: string, data?: any): void {\n    // Sanitize both message and data to prevent sensitive info exposure\n    const sanitizedMessage = this.sanitizeMessage(message);\n    const sanitizedData = this.sanitizeData(data);\n    \n    const entry: LogEntry = {\n      timestamp: new Date(),\n      level,\n      message: sanitizedMessage,  // Store sanitized message\n      data: sanitizedData\n    };\n    \n    // Bounded FIFO eviction — EvictingQueue handles capacity\n    this.logs.push(entry);\n    this.logListener?.(entry);\n\n    // Only write to console during initialization, respecting minimum level\n    if (!this.isMCPConnected) {\n      // Check NODE_ENV inside the method to ensure it's evaluated at runtime\n      const isTest = process.env.NODE_ENV === 'test';\n      const meetsLevel = MCPLogger.LEVEL_ORDER[level] >= MCPLogger.LEVEL_ORDER[this.minLevel];\n      if (!isTest && meetsLevel) {\n        const prefix = `[${entry.timestamp.toISOString()}] [${level.toUpperCase()}]`;\n        // Security fix: Use sanitized message to prevent sensitive information disclosure\n        // Both message and data are sanitized before any output\n        const safeMessage = `${prefix} ${sanitizedMessage}`;\n        \n        // During initialization, we can use console\n        if (level === 'error') {\n          // lgtm[js/clear-text-logging] - safeMessage is pre-sanitized by sanitizeMessage()\n          console.error(safeMessage);\n        } else if (level === 'warn') {\n          // lgtm[js/clear-text-logging] - safeMessage is pre-sanitized by sanitizeMessage()\n          console.warn(safeMessage);\n        } else {\n          // For MCP, even during init, avoid stdout for info/debug\n          // lgtm[js/clear-text-logging] - safeMessage is pre-sanitized by sanitizeMessage()\n          console.error(safeMessage);\n        }\n      }\n    }\n  }\n  \n  public debug(message: string, data?: any): void {\n    this.log('debug', message, data);\n  }\n  \n  public info(message: string, data?: any): void {\n    this.log('info', message, data);\n  }\n  \n  public warn(message: string, data?: any): void {\n    this.log('warn', message, data);\n  }\n  \n  public error(message: string, data?: any): void {\n    this.log('error', message, data);\n  }\n  \n  /**\n   * Get recent logs (for MCP tools to retrieve)\n   */\n  public getLogs(count = 100, level?: LogEntry['level']): LogEntry[] {\n    let filtered: readonly LogEntry[] = this.logs.toArray();\n    if (level) {\n      filtered = filtered.filter(log => log.level === level);\n    }\n    return filtered.slice(-count);\n  }\n  \n  /**\n   * Clear logs\n   */\n  public clearLogs(): void {\n    this.logs.clear();\n  }\n}\n\n// Export class for testing/extension\nexport { MCPLogger };\n\n// Singleton instance for convenience\nexport const logger = new MCPLogger();"]}