mcp-booster/dist/modules/logger.js

Servidor MCP com CoConuT (Continuous Chain of Thought) para uso com Cursor IDE - Pacote Global NPM

"use strict";
/**
 * Sistema de log para o serviço CoConuT
 * Fornece logs formatados com diferentes níveis e timestamps
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.Logger = exports.LogLevel = void 0;
/**
 * Níveis de log
 */
var LogLevel;
(function (LogLevel) {
    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
    LogLevel[LogLevel["INFO"] = 1] = "INFO";
    LogLevel[LogLevel["WARN"] = 2] = "WARN";
    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
})(LogLevel || (exports.LogLevel = LogLevel = {}));
/**
 * Implementação do sistema de logs
 */
class Logger {
    /**
     * Construtor privado para implementação Singleton
     */
    constructor(options = {}) {
        this.minLevel = options.minLevel || LogLevel.INFO;
        this.enableConsole = options.enableConsole !== false;
        this.includeTimestamp = options.includeTimestamp !== false;
        this.logFilePath = options.logFilePath;
        // Carregar fs apenas se necessário
        if (this.logFilePath) {
            try {
                this.fs = require('fs');
            }
            catch {
                console.warn('Módulo fs não disponível. Logs serão enviados apenas para o console.');
                this.fs = null;
            }
        }
    }
    /**
     * Obtém a instância singleton do logger
     */
    static getInstance(options) {
        if (!Logger.instance) {
            Logger.instance = new Logger(options);
        }
        else if (options) {
            // Atualizar configurações existentes
            const instance = Logger.instance;
            instance.minLevel = options.minLevel !== undefined ? options.minLevel : instance.minLevel;
            instance.enableConsole = options.enableConsole !== undefined ? options.enableConsole : instance.enableConsole;
            instance.includeTimestamp = options.includeTimestamp !== undefined ? options.includeTimestamp : instance.includeTimestamp;
            if (options.logFilePath !== undefined) {
                instance.logFilePath = options.logFilePath;
                if (instance.logFilePath && !instance.fs) {
                    try {
                        instance.fs = require('fs');
                    }
                    catch {
                        console.warn('Módulo fs não disponível. Logs serão enviados apenas para o console.');
                        instance.fs = null;
                    }
                }
            }
        }
        return Logger.instance;
    }
    /**
     * Obtém o nível de log numérico a partir do nome
     */
    static getLevelFromName(levelName) {
        switch (levelName.toLowerCase()) {
            case 'debug': return LogLevel.DEBUG;
            case 'info': return LogLevel.INFO;
            case 'warn': return LogLevel.WARN;
            case 'error': return LogLevel.ERROR;
            default: return LogLevel.INFO;
        }
    }
    /**
     * Formatação base de mensagens de log
     */
    formatMessage(level, message, meta) {
        const timestamp = this.includeTimestamp ? new Date().toISOString() + ' - ' : '';
        const metaStr = meta ? ' ' + JSON.stringify(meta) : '';
        return `${timestamp}[${level.toUpperCase()}] ${message}${metaStr}`;
    }
    /**
     * Escreve um log no nível DEBUG
     */
    debug(message, meta) {
        if (this.minLevel <= LogLevel.DEBUG) {
            const formattedMessage = this.formatMessage('debug', message, meta);
            this.writeLog(formattedMessage);
        }
    }
    /**
     * Escreve um log no nível INFO
     */
    info(message, meta) {
        if (this.minLevel <= LogLevel.INFO) {
            const formattedMessage = this.formatMessage('info', message, meta);
            this.writeLog(formattedMessage);
        }
    }
    /**
     * Escreve um log no nível WARN
     */
    warn(message, meta) {
        if (this.minLevel <= LogLevel.WARN) {
            const formattedMessage = this.formatMessage('warn', message, meta);
            this.writeLog(formattedMessage);
        }
    }
    /**
     * Escreve um log no nível ERROR
     */
    error(message, meta) {
        if (this.minLevel <= LogLevel.ERROR) {
            const formattedMessage = this.formatMessage('error', message, meta);
            this.writeLog(formattedMessage);
        }
    }
    /**
     * Escreve o log no destino adequado (console e/ou arquivo)
     */
    writeLog(formattedMessage) {
        if (this.enableConsole) {
            console.log(formattedMessage);
        }
        if (this.logFilePath && this.fs) {
            try {
                this.fs.appendFileSync(this.logFilePath, formattedMessage + '\n');
            }
            catch (err) {
                console.error('Erro ao escrever no arquivo de log:', err);
            }
        }
    }
}
exports.Logger = Logger;