@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/utils/log-rotator.js

@@ -0,0 +1,306 @@
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * Manages log file rotation and cleanup for MCP Hub Lite.
+ *
+ * This class provides automated log rotation functionality that creates log files
+ * with timestamp-based naming on each startup and automatically cleans up old log files
+ * based on the configured retention period. It ensures that log storage doesn't grow
+ * indefinitely while maintaining a configurable history of log files for debugging
+ * and monitoring purposes.
+ *
+ * The log rotator works by:
+ * 1. Creating log files with format: `{logBaseName}.{YYYYMMDD_HHmmSSZZZ}.log` on each startup
+ * 2. Automatically cleaning up log files older than the configured retention period
+ * 3. Providing utilities to retrieve and manage existing log files
+ *
+ * @example
+ * ```typescript
+ * const logDir = path.join(os.homedir(), '.mcp-hub-lite', 'logs');
+ * const rotator = new LogRotator(logDir, 'mcp-hub');
+ *
+ * // Create a new log file with timestamp (for startup)
+ * const newLogPath = rotator.createNewLogFilePath();
+ *
+ * // Get the latest existing log file
+ * const latestLogPath = rotator.getLatestLogFilePath();
+ *
+ * // Perform log rotation (cleanup old files)
+ * rotator.rotateLogs();
+ *
+ * // Get all log files sorted by date (newest first)
+ * const logFiles = rotator.getLogFiles();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom configuration (independent from global config)
+ * const rotator = new LogRotator(logDir, 'dev-server', { rotationAge: '7d' });
+ * ```
+ *
+ * @class
+ * @since 1.0.0
+ */
+export class LogRotator {
+    logDir;
+    logBaseName;
+    customConfig;
+    configGetter;
+    /**
+     * Creates a new LogRotator instance.
+     *
+     * @param logDir - The directory where log files are stored
+     * @param logBaseName - The base name for log files (default: 'mcp-hub')
+     * @param customConfig - Optional custom configuration for independent rotation settings
+     * @param configGetter - Optional config getter function for global config access (for backward compatibility)
+     */
+    constructor(logDir, logBaseName = 'mcp-hub', customConfig, configGetter) {
+        this.logDir = logDir;
+        this.logBaseName = logBaseName;
+        this.customConfig = customConfig || null;
+        this.configGetter = configGetter || null;
+        // Ensure log directory exists
+        if (!fs.existsSync(this.logDir)) {
+            fs.mkdirSync(this.logDir, { recursive: true });
+        }
+    }
+    /**
+     * Calculates the retention period in days from the configured rotation age.
+     *
+     * Parses the rotation age configuration value which can be in
+     * various formats (e.g., "7d", "24h", "1440m") and converts it to days.
+     * Hours and minutes are converted to days using ceiling division to ensure
+     * proper retention behavior.
+     *
+     * If a customConfig was provided, it will be used; otherwise, falls back to
+     * the configGetter if provided; defaults to 7 days.
+     *
+     * @returns {number} The retention period in days. Defaults to 7 days if the
+     *                   configuration is invalid or cannot be parsed.
+     * @private
+     */
+    getRetentionDays() {
+        const maxAge = this.customConfig?.rotationAge ??
+            (this.configGetter ? this.configGetter().system.logging.rotationAge : null) ??
+            '7d';
+        // Parse maxAge like "7d", "30d", etc.
+        const match = maxAge.match(/^(\d+)([dhm])$/);
+        if (match) {
+            const value = parseInt(match[1], 10);
+            const unit = match[2];
+            switch (unit) {
+                case 'd':
+                    return value;
+                case 'h':
+                    return Math.ceil(value / 24);
+                case 'm':
+                    return Math.ceil(value / (24 * 60));
+                default:
+                    return 7;
+            }
+        }
+        return 7; // default to 7 days
+    }
+    /**
+     * Generates a timestamp string in YYYYMMDD_HHmmSSZZZ format.
+     *
+     * @param date - The date to format, defaults to current date/time
+     * @returns {string} Formatted timestamp string
+     * @private
+     */
+    formatTimestamp(date = new Date()) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+        return `${year}${month}${day}_${hours}${minutes}${seconds}${milliseconds}`;
+    }
+    /**
+     * Creates a new log file path with the current timestamp.
+     *
+     * This method generates a log file path using the configured log directory and base name,
+     * combined with the current timestamp in YYYYMMDD_HHmmSSZZZ format. The resulting path
+     * follows the pattern: `{logDir}/{logBaseName}.{YYYYMMDD_HHmmSSZZZ}.log`
+     *
+     * This method should be called on application startup to create a new log file
+     * for each session.
+     *
+     * @returns {string} The absolute file path for the new log file.
+     * @example
+     * ```typescript
+     * const rotator = new LogRotator('/var/log/mcp-hub', 'mcp-hub');
+     * const logPath = rotator.createNewLogFilePath();
+     * // Returns: '/var/log/mcp-hub/mcp-hub.20260301_143022123.log' (with current timestamp)
+     * ```
+     */
+    createNewLogFilePath() {
+        const timestamp = this.formatTimestamp();
+        return path.join(this.logDir, `${this.logBaseName}.${timestamp}.log`);
+    }
+    /**
+     * Gets the latest existing log file path.
+     *
+     * This method scans the log directory and returns the path to the most recent
+     * log file based on the timestamp in the filename. If no log files exist,
+     * it returns null.
+     *
+     * @returns {string | null} The absolute file path to the latest log file, or null if none exist.
+     * @example
+     * ```typescript
+     * const rotator = new LogRotator('/var/log/mcp-hub', 'mcp-hub');
+     * const latestLog = rotator.getLatestLogFilePath();
+     * // Returns: '/var/log/mcp-hub/mcp-hub.20260301_143022123.log' or null
+     * ```
+     */
+    getLatestLogFilePath() {
+        const logFiles = this.getLogFiles();
+        return logFiles.length > 0 ? logFiles[0] : null;
+    }
+    /**
+     * Gets the current log file path (backward compatibility).
+     *
+     * This method is maintained for backward compatibility. It first tries to get
+     * the latest existing log file. If none exists, it creates a new one.
+     *
+     * @returns {string} The absolute file path for the current log file.
+     * @deprecated Use createNewLogFilePath() or getLatestLogFilePath() instead
+     * @example
+     * ```typescript
+     * const rotator = new LogRotator('/var/log/mcp-hub', 'mcp-hub');
+     * const logPath = rotator.getCurrentLogFilePath();
+     * ```
+     */
+    getCurrentLogFilePath() {
+        const latest = this.getLatestLogFilePath();
+        return latest ?? this.createNewLogFilePath();
+    }
+    /**
+     * Performs log rotation by cleaning up old log files beyond the retention period.
+     *
+     * This method scans the configured log directory for files matching the pattern
+     * `{logBaseName}.{YYYY-MM-DD}.log` and removes any files that are older than
+     * the configured retention period (specified in the system configuration under
+     * `system.logging.rotationAge`).
+     *
+     * The retention period supports various time units:
+     * - 'd' for days (e.g., "7d" = 7 days)
+     * - 'h' for hours (e.g., "24h" = 1 day)
+     * - 'm' for minutes (e.g., "1440m" = 1 day)
+     *
+     * If no valid retention period is configured, it defaults to 7 days.
+     *
+     * This method should be called periodically (e.g., on application startup or
+     * via a scheduled task) to prevent log files from consuming excessive disk space.
+     *
+     * @returns {void}
+     * @throws {Error} If there's an error reading the log directory or deleting files,
+     *                 the error is caught and logged to console.error, but the method
+     *                 continues execution without throwing.
+     * @example
+     * ```typescript
+     * const rotator = new LogRotator('/var/log/mcp-hub', 'mcp-hub');
+     * rotator.rotateLogs(); // Cleans up log files older than configured retention period
+     * ```
+     */
+    rotateLogs() {
+        try {
+            const files = fs.readdirSync(this.logDir);
+            const logFiles = files.filter((file) => file.startsWith(`${this.logBaseName}.`) && file.endsWith('.log'));
+            const now = new Date();
+            const retentionThreshold = new Date();
+            retentionThreshold.setDate(now.getDate() - this.getRetentionDays());
+            for (const file of logFiles) {
+                const filePath = path.join(this.logDir, file);
+                const stats = fs.statSync(filePath);
+                if (stats.mtime < retentionThreshold) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to rotate logs:', error);
+        }
+    }
+    /**
+     * Retrieves all existing log files sorted by date (newest first).
+     *
+     * This method scans the configured log directory for files matching the pattern
+     * `{logBaseName}.{YYYY-MM-DD}.log`, extracts the date from each filename,
+     * and returns an array of absolute file paths sorted in descending order by date
+     * (newest files first).
+     *
+     * This is useful for log management interfaces, log viewing utilities, or any
+     * functionality that needs to present log files in chronological order.
+     *
+     * @returns {string[]} Array of absolute file paths to log files, sorted by date
+     *                     with newest files first. Returns an empty array if no log
+     *                     files are found or if an error occurs during scanning.
+     * @throws {Error} If there's an error reading the log directory, the error is
+     *                 caught and logged to console.error, but the method returns
+     *                 an empty array instead of throwing.
+     * @example
+     * ```typescript
+     * const rotator = new LogRotator('/var/log/mcp-hub', 'mcp-hub');
+     * const logFiles = rotator.getLogFiles();
+     * // Returns: [
+     * //   '/var/log/mcp-hub/mcp-hub.2026-02-16.log',
+     * //   '/var/log/mcp-hub/mcp-hub.2026-02-15.log',
+     * //   '/var/log/mcp-hub/mcp-hub.2026-02-14.log'
+     * // ]
+     * ```
+     */
+    getLogFiles() {
+        try {
+            const files = fs.readdirSync(this.logDir);
+            const logFiles = files
+                .filter((file) => file.startsWith(`${this.logBaseName}.`) && file.endsWith('.log'))
+                .map((file) => ({
+                name: file,
+                path: path.join(this.logDir, file),
+                date: this.extractDateFromFilename(file)
+            }))
+                .filter((item) => item.date !== null)
+                .sort((a, b) => b.date.getTime() - a.date.getTime())
+                .map((item) => item.path);
+            return logFiles;
+        }
+        catch (error) {
+            console.error('Failed to get log files:', error);
+            return [];
+        }
+    }
+    /**
+     * Extracts the date from a log filename.
+     *
+     * Parses filenames that match either:
+     * - New format: `{logBaseName}.{YYYYMMDD_HHmmSSZZZ}.log` (preferred)
+     * - Old format: `{logBaseName}.{YYYY-MM-DD}.log` (for backward compatibility)
+     *
+     * and extracts the date portion, converting it to a Date object.
+     *
+     * @param {string} filename - The log filename to parse
+     *                             (e.g., "mcp-hub.20260301_143022123.log" or "mcp-hub.2026-02-16.log")
+     * @returns {Date | null} A Date object representing the extracted date, or null
+     *                        if the filename doesn't match the expected pattern or
+     *                        contains an invalid date.
+     * @private
+     */
+    extractDateFromFilename(filename) {
+        // Try new format first: YYYYMMDD_HHmmSSZZZ
+        const newFormatMatch = filename.match(new RegExp(`${this.logBaseName}\\.(\\d{4})(\\d{2})(\\d{2})_(\\d{2})(\\d{2})(\\d{2})(\\d{3})\\.log$`));
+        if (newFormatMatch) {
+            const [, year, month, day, hours, minutes, seconds, ms] = newFormatMatch;
+            return new Date(parseInt(year, 10), parseInt(month, 10) - 1, // months are 0-indexed
+            parseInt(day, 10), parseInt(hours, 10), parseInt(minutes, 10), parseInt(seconds, 10), parseInt(ms, 10));
+        }
+        // Try old format: YYYY-MM-DD (backward compatibility)
+        const oldFormatMatch = filename.match(new RegExp(`${this.logBaseName}\\.(\\d{4}-\\d{2}-\\d{2})\\.log$`));
+        if (oldFormatMatch && oldFormatMatch[1]) {
+            return new Date(oldFormatMatch[1]);
+        }
+        return null;
+    }
+}

package/dist/server/src/utils/logger/dev-logger.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Development mode logging setup.
+ * This file contains development log initialization and management.
+ */
+import fs from 'fs';
+import { LogRotator, type RotatorConfig } from '../log-rotator.js';
+/**
+ * Development logger configuration and setup.
+ */
+export declare class DevLogger {
+    private logFileStream;
+    private devLogRotator;
+    /**
+     * Get the current log file stream.
+     */
+    get stream(): fs.WriteStream | null;
+    /**
+     * Get the dev log rotator (for testing only).
+     * @internal
+     */
+    get rotator(): LogRotator | null;
+    /**
+     * Enables development logging mode with file output and enhanced debugging.
+     *
+     * This method configures the logger to:
+     * - Write all log output to a file in the logs/ directory
+     * - Use timestamp-based log file naming (dev-server.YYYYMMDD_HHmmSSZZZ.log)
+     * - Automatically clean up old log files (default: 7 days retention)
+     *
+     * @param rotatorConfig - Optional custom rotation configuration (default: 7 days retention)
+     * @param onLogEnabled - Optional callback when log is enabled, receives the log file path
+     */
+    enableDevLog(rotatorConfig?: RotatorConfig, onLogEnabled?: (logFilePath: string) => void): void;
+    /**
+     * Close the dev log file stream if open.
+     */
+    close(): void;
+}
+//# sourceMappingURL=dev-logger.d.ts.map

package/dist/server/src/utils/logger/dev-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-logger.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/dev-logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEnE;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,aAAa,CAA2B;IAEhD;;OAEG;IACH,IAAI,MAAM,IAAI,EAAE,CAAC,WAAW,GAAG,IAAI,CAElC;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,UAAU,GAAG,IAAI,CAE/B;IAED;;;;;;;;;;OAUG;IACH,YAAY,CAAC,aAAa,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAoB/F;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}

package/dist/server/src/utils/logger/dev-logger.js

@@ -0,0 +1,63 @@
+/**
+ * Development mode logging setup.
+ * This file contains development log initialization and management.
+ */
+import fs from 'fs';
+import path from 'path';
+import { LogRotator } from '../log-rotator.js';
+/**
+ * Development logger configuration and setup.
+ */
+export class DevLogger {
+    logFileStream = null;
+    devLogRotator = null;
+    /**
+     * Get the current log file stream.
+     */
+    get stream() {
+        return this.logFileStream;
+    }
+    /**
+     * Get the dev log rotator (for testing only).
+     * @internal
+     */
+    get rotator() {
+        return this.devLogRotator;
+    }
+    /**
+     * Enables development logging mode with file output and enhanced debugging.
+     *
+     * This method configures the logger to:
+     * - Write all log output to a file in the logs/ directory
+     * - Use timestamp-based log file naming (dev-server.YYYYMMDD_HHmmSSZZZ.log)
+     * - Automatically clean up old log files (default: 7 days retention)
+     *
+     * @param rotatorConfig - Optional custom rotation configuration (default: 7 days retention)
+     * @param onLogEnabled - Optional callback when log is enabled, receives the log file path
+     */
+    enableDevLog(rotatorConfig, onLogEnabled) {
+        if (this.logFileStream)
+            return;
+        const logDir = path.join(process.cwd(), 'logs');
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+        const config = rotatorConfig || { rotationAge: '7d' };
+        this.devLogRotator = new LogRotator(logDir, 'dev-server', config);
+        this.devLogRotator.rotateLogs();
+        const logFile = this.devLogRotator.createNewLogFilePath();
+        this.logFileStream = fs.createWriteStream(logFile, { flags: 'a' });
+        if (onLogEnabled) {
+            onLogEnabled(logFile);
+        }
+    }
+    /**
+     * Close the dev log file stream if open.
+     */
+    close() {
+        if (this.logFileStream) {
+            this.logFileStream.end();
+            this.logFileStream = null;
+        }
+    }
+}

package/dist/server/src/utils/logger/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Logger module exports.
+ * This file provides backward-compatible exports for the refactored logger module.
+ */
+export type { LogContext, LogOptions } from './log-context.js';
+export { LOG_MODULES } from './log-modules.js';
+export type { LogModuleKey, LogModule } from './log-modules.js';
+export { COLORS, getColorCodeForLevel, getResetColor } from './log-colors.js';
+export { formatTimestamp, formatLogLevel, formatPid, createColoredLogMessage, createLogMessage, formatError } from './log-formatter.js';
+export { isToolsListResponse, simplifyToolsListResponse, hasImageContent, simplifyImageContent, formatMcpMessageForLogging, isNotificationMessage, logNotificationMessage } from './log-output.js';
+export { Logger } from './logger.js';
+import { Logger } from './logger.js';
+import type { LogContext } from './log-context.js';
+export declare const logger: Logger;
+/**
+ * Log a message with color formatting for console and plain text for file output.
+ *
+ * This function provides a convenient way to log messages that appear with
+ * ANSI color codes in the console but are written as plain text to log files.
+ * It uses the logger's internal formatting methods to ensure consistent output.
+ *
+ * @param coloredMessage - The message to display in the console with color formatting
+ * @param plainMessage - The message to write to log files in plain text format
+ * @param context - Optional logging context including PID, server name, trace ID, etc.
+ *
+ * @example
+ * ```typescript
+ * logWithColor(
+ *   '\x1b[32m[SUCCESS]\x1b[0m Server started',
+ *   '[SUCCESS] Server started',
+ *   { serverName: 'mcp-hub', pid: process.pid }
+ * );
+ * ```
+ */
+export declare function logWithColor(coloredMessage: string, plainMessage: string, context?: LogContext): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/src/utils/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG/D,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGhE,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAG9E,OAAO,EACL,eAAe,EACf,cAAc,EACd,SAAS,EACT,uBAAuB,EACvB,gBAAgB,EAChB,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,eAAe,EACf,oBAAoB,EACpB,0BAA0B,EAC1B,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,eAAO,MAAM,MAAM,QAAe,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,UAAU,GACnB,IAAI,CAQN"}

package/dist/server/src/utils/logger/index.js

@@ -0,0 +1,46 @@
+/**
+ * Logger module exports.
+ * This file provides backward-compatible exports for the refactored logger module.
+ */
+// Re-export log module constants
+export { LOG_MODULES } from './log-modules.js';
+// Re-export color utilities
+export { COLORS, getColorCodeForLevel, getResetColor } from './log-colors.js';
+// Re-export formatter utilities
+export { formatTimestamp, formatLogLevel, formatPid, createColoredLogMessage, createLogMessage, formatError } from './log-formatter.js';
+// Re-export output utilities
+export { isToolsListResponse, simplifyToolsListResponse, hasImageContent, simplifyImageContent, formatMcpMessageForLogging, isNotificationMessage, logNotificationMessage } from './log-output.js';
+// Re-export main Logger class
+export { Logger } from './logger.js';
+// Create and export the default logger instance
+import { Logger } from './logger.js';
+import { createColoredLogMessage, createLogMessage } from './log-formatter.js';
+export const logger = new Logger();
+/**
+ * Log a message with color formatting for console and plain text for file output.
+ *
+ * This function provides a convenient way to log messages that appear with
+ * ANSI color codes in the console but are written as plain text to log files.
+ * It uses the logger's internal formatting methods to ensure consistent output.
+ *
+ * @param coloredMessage - The message to display in the console with color formatting
+ * @param plainMessage - The message to write to log files in plain text format
+ * @param context - Optional logging context including PID, server name, trace ID, etc.
+ *
+ * @example
+ * ```typescript
+ * logWithColor(
+ *   '\x1b[32m[SUCCESS]\x1b[0m Server started',
+ *   '[SUCCESS] Server started',
+ *   { serverName: 'mcp-hub', pid: process.pid }
+ * );
+ * ```
+ */
+export function logWithColor(coloredMessage, plainMessage, context) {
+    const coloredLogMsg = createColoredLogMessage('info', coloredMessage, context);
+    console.info(coloredLogMsg);
+    if (logger.logFileStream) {
+        const plainLogMsg = createLogMessage('info', plainMessage, context);
+        logger.logFileStream.write(plainLogMsg + '\n');
+    }
+}

package/dist/server/src/utils/logger/log-colors.d.ts

@@ -0,0 +1,27 @@
+/**
+ * ANSI color codes for logging.
+ * This file contains all color-related constants and helpers.
+ */
+import type { LogLevel } from '../../../shared/types/common.types.js';
+export declare const COLORS: {
+    readonly reset: "\u001B[0m";
+    readonly cyan: "\u001B[36m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly red: "\u001B[31m";
+    readonly gray: "\u001B[90m";
+    readonly brightCyan: "\u001B[96m";
+    readonly brightMagenta: "\u001B[95m";
+};
+/**
+ * Get color code for a specific log level.
+ * @param level - The log level
+ * @returns ANSI color code string
+ */
+export declare function getColorCodeForLevel(level: LogLevel): string;
+/**
+ * Get reset color code.
+ * @returns ANSI reset color code
+ */
+export declare function getResetColor(): string;
+//# sourceMappingURL=log-colors.d.ts.map

package/dist/server/src/utils/logger/log-colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-colors.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-colors.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAG9D,eAAO,MAAM,MAAM;;;;;;;;;CAST,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAa5D;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC"}

package/dist/server/src/utils/logger/log-colors.js

@@ -0,0 +1,41 @@
+/**
+ * ANSI color codes for logging.
+ * This file contains all color-related constants and helpers.
+ */
+// ANSI color codes
+export const COLORS = {
+    reset: '\x1b[0m',
+    cyan: '\x1b[36m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    red: '\x1b[31m',
+    gray: '\x1b[90m',
+    brightCyan: '\x1b[96m',
+    brightMagenta: '\x1b[95m'
+};
+/**
+ * Get color code for a specific log level.
+ * @param level - The log level
+ * @returns ANSI color code string
+ */
+export function getColorCodeForLevel(level) {
+    switch (level) {
+        case 'debug':
+            return COLORS.cyan;
+        case 'info':
+            return COLORS.green;
+        case 'warn':
+            return COLORS.yellow;
+        case 'error':
+            return COLORS.red;
+        default:
+            return COLORS.reset;
+    }
+}
+/**
+ * Get reset color code.
+ * @returns ANSI reset color code
+ */
+export function getResetColor() {
+    return COLORS.reset;
+}

package/dist/server/src/utils/logger/log-context.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Log context types and interfaces.
+ * This file contains all type definitions for logging context.
+ */
+export interface LogContext {
+    pid?: number;
+    serverName?: string;
+    module?: string;
+    traceId?: string;
+    spanId?: string;
+}
+export type LogOptions = Omit<LogContext, 'pid' | 'serverName'>;
+//# sourceMappingURL=log-context.d.ts.map

package/dist/server/src/utils/logger/log-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-context.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE,KAAK,GAAG,YAAY,CAAC,CAAC"}

package/dist/server/src/utils/logger/log-context.js

@@ -0,0 +1,5 @@
+/**
+ * Log context types and interfaces.
+ * This file contains all type definitions for logging context.
+ */
+export {};

package/dist/server/src/utils/logger/log-formatter.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Log formatting utilities.
+ * This file contains all log message formatting logic.
+ */
+import type { LogLevel } from '../../../shared/types/common.types.js';
+import type { LogContext } from './log-context.js';
+/**
+ * Format a timestamp for logging.
+ * @param date - The date to format
+ * @returns Formatted timestamp string
+ */
+export declare function formatTimestamp(date: Date): string;
+/**
+ * Format a log level for display.
+ * @param level - The log level
+ * @returns Formatted log level string
+ */
+export declare function formatLogLevel(level: LogLevel): string;
+/**
+ * Format a PID for display.
+ * @param pid - The process ID
+ * @returns Formatted PID string
+ */
+export declare function formatPid(pid: number): string;
+/**
+ * Create a colored log message for console output.
+ * @param level - The log level
+ * @param message - The log message
+ * @param context - Optional log context
+ * @returns Colored log message string
+ */
+export declare function createColoredLogMessage(level: LogLevel, message: string, context?: LogContext): string;
+/**
+ * Create a plain text log message for file output.
+ * @param level - The log level
+ * @param message - The log message
+ * @param context - Optional log context
+ * @returns Plain text log message string
+ */
+export declare function createLogMessage(level: LogLevel, message: string, context?: LogContext): string;
+/**
+ * Format an error object for logging.
+ * @param error - The error to format
+ * @returns Formatted error string
+ */
+export declare function formatError(error: unknown): string;
+//# sourceMappingURL=log-formatter.d.ts.map

package/dist/server/src/utils/logger/log-formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-formatter.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-formatter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CASlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAatD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,UAAU,GACnB,MAAM,CAiCR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CAyB/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAiClD"}