mcp-server-blk/dist/utils/logger.js

MCP server for managing blocks schemas via API

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.cleanupOldLogs = exports.getLogFilePaths = exports.logToolExecution = exports.logApiCall = exports.logger = exports.debugLog = void 0;
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
class Logger {
    constructor() {
        this.logsDir = path.join(__dirname, '../../logs');
        this.ensureLogsDirectory();
        const today = new Date().toISOString().split('T')[0];
        this.logFile = path.join(this.logsDir, `mcp-server-${today}.log`);
        this.errorLogFile = path.join(this.logsDir, `mcp-server-error-${today}.log`);
        this.initializeLogFiles();
    }
    ensureLogsDirectory() {
        try {
            if (!fs.existsSync(this.logsDir)) {
                fs.mkdirSync(this.logsDir, { recursive: true });
                console.log(`Created logs directory: ${this.logsDir}`);
            }
        }
        catch (error) {
            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
            console.error(`Failed to create logs directory: ${errorMessage}`);
        }
    }
    initializeLogFiles() {
        const sessionHeader = `\\n${'='.repeat(80)}\\n📅 Session started at: ${new Date().toISOString()}\\n${'='.repeat(80)}\\n`;
        try {
            fs.appendFileSync(this.logFile, sessionHeader);
            fs.appendFileSync(this.errorLogFile, sessionHeader);
        }
        catch (error) {
            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
            console.error(`❌ Failed to initialize log files: ${errorMessage}`);
        }
    }
    writeToFile(filePath, logEntry) {
        try {
            fs.appendFileSync(filePath, logEntry + '\\n');
        }
        catch (error) {
            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
            console.error(`❌ Failed to write to log file ${filePath}: ${errorMessage}`);
        }
    }
    formatLogEntry(level, message, data = null) {
        const timestamp = new Date().toISOString();
        const logMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
        let logEntry = logMessage;
        if (data) {
            logEntry += '\\n' + JSON.stringify(data, null, 2);
        }
        return logEntry;
    }
    debugLog(level, message, data = null) {
        const logEntry = this.formatLogEntry(level, message, data);
        this.writeToFile(this.logFile, logEntry);
        if (level.toLowerCase() === 'error') {
            this.writeToFile(this.errorLogFile, logEntry);
        }
    }
    logApiCall(direction, url, data = null) {
        const message = `${direction}: ${url}`;
        this.debugLog('info', message, data);
    }
    logToolExecution(toolName, status, data = null) {
        const level = status === 'ERROR' ? 'error' : 'info';
        const message = `Tool ${toolName} - ${status}`;
        this.debugLog(level, message, data);
    }
    getLogFilePaths() {
        return {
            mainLog: this.logFile,
            errorLog: this.errorLogFile,
            logsDirectory: this.logsDir
        };
    }
    cleanupOldLogs(daysToKeep = 7) {
        try {
            const files = fs.readdirSync(this.logsDir);
            const cutoffDate = new Date();
            cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
            let deletedCount = 0;
            files.forEach(file => {
                const filePath = path.join(this.logsDir, file);
                const stats = fs.statSync(filePath);
                if (stats.mtime < cutoffDate && file.endsWith('.log')) {
                    fs.unlinkSync(filePath);
                    deletedCount++;
                    this.debugLog('info', `Deleted old log file: ${file}`);
                }
            });
            if (deletedCount > 0) {
                this.debugLog('info', `Cleaned up ${deletedCount} old log files`);
            }
        }
        catch (error) {
            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
            this.debugLog('error', 'Failed to cleanup old logs', { error: errorMessage });
        }
    }
}
const logger = new Logger();
exports.logger = logger;
const debugLog = (level, message, data = null) => {
    logger.debugLog(level, message, data);
};
exports.debugLog = debugLog;
const logApiCall = (direction, url, data) => logger.logApiCall(direction, url, data);
exports.logApiCall = logApiCall;
const logToolExecution = (toolName, status, data) => logger.logToolExecution(toolName, status, data);
exports.logToolExecution = logToolExecution;
const getLogFilePaths = () => logger.getLogFilePaths();
exports.getLogFilePaths = getLogFilePaths;
const cleanupOldLogs = (days) => logger.cleanupOldLogs(days);
exports.cleanupOldLogs = cleanupOldLogs;
//# sourceMappingURL=logger.js.map