route-claudecode/dist/utils/logger.js

Advanced routing and transformation system for Claude Code outputs to multiple AI providers

"use strict";
/**
 * 临时日志兼容层
 * 为了保持构建兼容性，提供旧日志接口的兼容实现
 * 项目所有者: Jason Zhang
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.ToolCallErrorClass = exports.PipelineDebugger = exports.logger = void 0;
exports.createLogger = createLogger;
const logging_1 = require("../logging");
// 创建兼容的logger实例 - 延迟初始化以获取正确的端口
let compatLogger = null;
function getCompatLogger() {
    if (!compatLogger) {
        // 🔧 修复硬编码：智能获取端口配置，支持多种来源
        const portFromEnv = process.env.RCC_PORT ? parseInt(process.env.RCC_PORT) : null;
        // 如果环境变量未设置，尝试从全局默认端口获取
        let port = portFromEnv;
        if (!port) {
            // 检查是否有全局默认端口（由server.ts设置）
            try {
                const { getDefaultPort } = require('../logging/default-port');
                port = getDefaultPort();
            }
            catch {
                // 如果无法获取默认端口，使用日志专用的备用端口
                port = 3456; // 仅用于日志系统，不影响服务器端口
            }
        }
        // 智能初始化logger - 处理manager尚未设置默认端口的情况
        try {
            const { getLogger, setDefaultPort } = require('../logging');
            if (port) {
                // 如果有端口，先设置为默认端口，然后创建logger
                setDefaultPort(port);
                compatLogger = getLogger();
            }
            else {
                // 仍然没有端口，使用3456作为fallback
                setDefaultPort(3456);
                compatLogger = getLogger(3456);
                console.warn('⚠️  Logger initialized with fallback port 3456 - this is for logging compatibility only');
            }
        }
        catch (error) {
            console.error('Failed to initialize logger:', error);
            throw error;
        }
    }
    return compatLogger;
}
exports.logger = {
    error: (message, data, requestId, stage) => {
        const logger = getCompatLogger();
        if (logger)
            logger.error(message, data, requestId, stage);
    },
    warn: (message, data, requestId, stage) => {
        const logger = getCompatLogger();
        if (logger)
            logger.warn(message, data, requestId, stage);
    },
    info: (message, data, requestId, stage) => {
        const logger = getCompatLogger();
        if (logger)
            logger.info(message, data, requestId, stage);
    },
    debug: (message, data, requestId, stage) => {
        const logger = getCompatLogger();
        if (logger)
            logger.debug(message, data, requestId, stage);
    },
    logFinishReason: (finishReason, data, requestId, stage) => {
        const logger = getCompatLogger();
        if (logger)
            logger.logFinishReason(finishReason, data, requestId, stage);
    },
    logStopReason: (stopReason, data, requestId, stage) => {
        const logger = getCompatLogger();
        if (logger)
            logger.logStopReason(stopReason, data, requestId, stage);
    },
    logDualFinishReason: (originalReason, convertedReason, provider, data, requestId, stage) => {
        const logger = getCompatLogger();
        if (logger)
            logger.logDualFinishReason(originalReason, convertedReason, provider, data, requestId, stage);
    },
    trace: (requestId, stage, message, data) => {
        const logger = getCompatLogger();
        if (logger)
            logger.debug(`[TRACE] ${message}`, data, requestId, stage);
    },
    setConfig: (_options) => {
        // 兼容旧的setConfig调用，但实际不做任何操作
    },
    setQuietMode: (_enabled) => {
        // 兼容旧的setQuietMode调用，但实际不做任何操作
    }
};
// PipelineDebugger 兼容类 - 映射到新的日志系统
class PipelineDebugger {
    errorTracker;
    requestTracker;
    logger;
    constructor(port) {
        this.errorTracker = (0, logging_1.createErrorTracker)(port);
        this.requestTracker = (0, logging_1.createRequestTracker)(port);
        this.logger = (0, logging_1.getLogger)(port);
    }
    // 检测工具调用错误
    detectToolCallError(text, requestId, stage = 'unknown', provider = 'unknown', model = 'unknown') {
        return this.errorTracker.detectToolCallInText(text, requestId, stage, provider, model);
    }
    // 记录工具调用错误
    logToolCallError(error) {
        this.errorTracker.logToolCallError(error);
    }
    // 添加原始流数据
    addRawStreamData(requestId, data) {
        this.requestTracker.logStage(requestId, 'raw_stream_data', {
            rawData: data
        });
    }
    // 记录失败
    logFailure(failureData) {
        this.errorTracker.logStandardizedError({
            requestId: failureData.requestId || 'unknown',
            reason: failureData.reason || 'Unknown failure',
            provider: failureData.provider || 'unknown',
            model: failureData.model || 'unknown',
            errorCode: failureData.errorCode || 'PIPELINE_FAILURE',
            key: failureData.key || 'unknown',
            port: failureData.port // 🔧 移除fallback：必须明确指定端口
        });
    }
}
exports.PipelineDebugger = PipelineDebugger;
// ToolCallError 兼容类
class ToolCallErrorClass {
    requestId;
    errorMessage;
    transformationStage;
    provider;
    model;
    context;
    port;
    constructor(errorMessage, requestId, transformationStage = 'unknown', provider = 'unknown', model = 'unknown', context = {}, port) {
        this.requestId = requestId;
        this.errorMessage = errorMessage;
        this.transformationStage = transformationStage;
        this.provider = provider;
        this.model = model;
        this.context = context;
        this.port = port;
    }
}
exports.ToolCallErrorClass = ToolCallErrorClass;
// 工厂函数兼容
function createLogger(_logDir, _serverType) {
    return exports.logger;
}
//# sourceMappingURL=logger.js.map