@seliseblocks/mcp-server/dist/utils/logger.js

A Model Context Protocol (MCP) server for managing schemas in SELISE Blocks platform, built with TypeScript.

import * as fs from 'fs';
import * as path from 'path';
import { fileURLToPath } from 'url';
class Logger {
    constructor() {
        const __filename = fileURLToPath(import.meta.url);
        const __dirname = path.dirname(__filename);
        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();
export const debugLog = (level, message, data = null) => {
    logger.debugLog(level, message, data);
};
export { logger, };
export const logApiCall = (direction, url, data) => logger.logApiCall(direction, url, data);
export const logToolExecution = (toolName, status, data) => logger.logToolExecution(toolName, status, data);
export const getLogFilePaths = () => logger.getLogFilePaths();
export const cleanupOldLogs = (days) => logger.cleanupOldLogs(days);
//# sourceMappingURL=logger.js.map