@bratcliffe909/mcp-server-segmind/dist/utils/logger.js

Model Context Protocol server for Segmind API - Generate images and videos using AI models

import winston from 'winston';
import { config } from './config.js';
const SENSITIVE_KEYS = [
    'apikey',
    'api_key',
    'apiKey',
    'password',
    'token',
    'secret',
    'authorization',
    'auth',
    'key',
    'credential',
    'private',
];
function sanitizeObject(obj, depth = 0) {
    if (depth > 10)
        return '[MAX_DEPTH]';
    if (obj === null || obj === undefined) {
        return obj;
    }
    if (typeof obj === 'string') {
        if (obj.startsWith('sg_') && obj.length > 20) {
            return '[REDACTED_API_KEY]';
        }
        return obj;
    }
    if (Array.isArray(obj)) {
        return obj.map(item => sanitizeObject(item, depth + 1));
    }
    if (typeof obj === 'object') {
        const sanitized = {};
        for (const [key, value] of Object.entries(obj)) {
            const lowerKey = key.toLowerCase();
            if (SENSITIVE_KEYS.some(sensitive => lowerKey.includes(sensitive))) {
                sanitized[key] = '[REDACTED]';
            }
            else if (typeof value === 'string' && value.length > 50) {
                sanitized[key] = value.substring(0, 50) + '...[TRUNCATED]';
            }
            else {
                sanitized[key] = sanitizeObject(value, depth + 1);
            }
        }
        return sanitized;
    }
    return obj;
}
const sanitizeFormat = winston.format((info) => {
    if (config.security.sanitizeLogs) {
        if (typeof info.message === 'object') {
            info.message = sanitizeObject(info.message);
        }
        const { level, message, timestamp, ...rest } = info;
        const sanitizedRest = sanitizeObject(rest);
        return {
            level,
            message,
            timestamp,
            ...sanitizedRest,
        };
    }
    return info;
});
function createLogger() {
    const formats = [
        winston.format.timestamp({
            format: 'YYYY-MM-DD HH:mm:ss.SSS',
        }),
        winston.format.errors({ stack: true }),
        sanitizeFormat(),
    ];
    if (config.nodeEnv === 'development') {
        formats.push(winston.format.printf(({ timestamp, level, message, ...rest }) => {
            const extra = Object.keys(rest).length > 0 ? `\n${JSON.stringify(rest, null, 2)}` : '';
            return `${timestamp} [${level}]: ${message}${extra}`;
        }));
    }
    else {
        formats.push(winston.format.json());
    }
    const logger = winston.createLogger({
        level: config.logLevel,
        format: winston.format.combine(...formats),
        defaultMeta: { service: 'segmind-mcp' },
        transports: [
            new winston.transports.Console({
                silent: config.nodeEnv === 'test' || process.env.MCP_MODE === 'true',
            }),
        ],
    });
    if (config.nodeEnv === 'production') {
        logger.add(new winston.transports.File({
            filename: 'error.log',
            level: 'error',
            maxsize: 5242880,
            maxFiles: 5,
        }));
        logger.add(new winston.transports.File({
            filename: 'combined.log',
            maxsize: 5242880,
            maxFiles: 5,
        }));
    }
    return logger;
}
let _logger = null;
export const logger = new Proxy({}, {
    get(_target, prop) {
        if (!_logger) {
            _logger = createLogger();
        }
        return _logger[prop];
    }
});
export function logWithContext(level, message, context) {
    logger[level](message, context || {});
}
export function createChildLogger(context) {
    return logger.child(context);
}
//# sourceMappingURL=logger.js.map