@loop_ouroboros/mcp-hub-lite 1.0.0

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

@@ -0,0 +1,150 @@
+/**
+ * Log formatting utilities.
+ * This file contains all log message formatting logic.
+ */
+import { stringifyForLogging } from '../json-utils.js';
+import { getColorCodeForLevel, getResetColor, COLORS } from './log-colors.js';
+// PID formatting configuration
+const PID_WIDTH = 8;
+/**
+ * Format a timestamp for logging.
+ * @param date - The date to format
+ * @returns Formatted timestamp string
+ */
+export function formatTimestamp(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}`;
+}
+/**
+ * Format a log level for display.
+ * @param level - The log level
+ * @returns Formatted log level string
+ */
+export function formatLogLevel(level) {
+    switch (level) {
+        case 'debug':
+            return 'DBG';
+        case 'info':
+            return 'INF';
+        case 'warn':
+            return 'WRN';
+        case 'error':
+            return 'ERR';
+        default:
+            return 'UNK';
+    }
+}
+/**
+ * Format a PID for display.
+ * @param pid - The process ID
+ * @returns Formatted PID string
+ */
+export function formatPid(pid) {
+    const pidStr = pid.toString();
+    if (pidStr.length > PID_WIDTH) {
+        return `PID:${pidStr.substring(0, PID_WIDTH)}`;
+    }
+    return `PID:${pidStr.padStart(PID_WIDTH, ' ')}`;
+}
+/**
+ * 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 function createColoredLogMessage(level, message, context) {
+    const timestamp = formatTimestamp(new Date());
+    const processPid = context?.pid ?? process.pid;
+    const formattedLevel = formatLogLevel(level);
+    const formattedPid = formatPid(processPid);
+    const actualServerName = context?.serverName || 'mcp-hub';
+    const timestampColor = COLORS.gray;
+    const levelColor = getColorCodeForLevel(level);
+    const pidColor = COLORS.cyan;
+    const serverColor = COLORS.brightCyan;
+    const moduleColor = COLORS.brightMagenta;
+    const traceColor = COLORS.yellow;
+    const resetColor = getResetColor();
+    let result = `${timestampColor}[${timestamp}]${resetColor} ${levelColor}[${formattedLevel}]${resetColor} ${pidColor}[${formattedPid}]${resetColor}`;
+    if (context?.traceId) {
+        result += ` ${traceColor}[TID:${context.traceId}]${resetColor}`;
+    }
+    if (context?.spanId) {
+        result += ` ${traceColor}[SID:${context.spanId}]${resetColor}`;
+    }
+    result += ` ${serverColor}[${actualServerName}]${resetColor}`;
+    if (context?.module) {
+        result += ` ${moduleColor}[${context.module}]${resetColor}`;
+    }
+    result += ` ${message}`;
+    return result;
+}
+/**
+ * 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 function createLogMessage(level, message, context) {
+    const timestamp = formatTimestamp(new Date());
+    const processPid = context?.pid ?? process.pid;
+    const formattedLevel = formatLogLevel(level);
+    const pidStr = processPid.toString().padStart(PID_WIDTH, ' ');
+    const serverIdentifier = context?.serverName || 'mcp-hub';
+    let result = `[${timestamp}] [${formattedLevel}] [PID:${pidStr}]`;
+    if (context?.traceId) {
+        result += ` [TID:${context.traceId}]`;
+    }
+    if (context?.spanId) {
+        result += ` [SID:${context.spanId}]`;
+    }
+    result += ` [${serverIdentifier}]`;
+    if (context?.module) {
+        result += ` [${context.module}]`;
+    }
+    result += ` ${message}`;
+    return result;
+}
+/**
+ * Format an error object for logging.
+ * @param error - The error to format
+ * @returns Formatted error string
+ */
+export function formatError(error) {
+    if (error instanceof Error) {
+        let result = error.message;
+        if (error.stack) {
+            const stackLines = error.stack.split('\n').slice(1, 6);
+            if (stackLines.length > 0) {
+                result += '\n' + stackLines.join('\n');
+            }
+        }
+        return result;
+    }
+    if (typeof error === 'object' && error !== null) {
+        if ('module' in error || 'traceId' in error || 'spanId' in error) {
+            return '';
+        }
+        if (Array.isArray(error) && error.length === 0) {
+            return '';
+        }
+        if (Object.keys(error).length === 0) {
+            return '';
+        }
+        try {
+            return stringifyForLogging(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error);
+}

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

@@ -0,0 +1,141 @@
+/**
+ * Log module constants.
+ * This file contains predefined log module constants for consistent usage across the codebase.
+ */
+/**
+ * Log module constants for use with the logger.
+ * These constants provide type-safe module identifiers for consistent logging.
+ *
+ * @example
+ * ```typescript
+ * import { LOG_MODULES } from './logger/log-modules.js';
+ *
+ * logger.info('Server started', LOG_MODULES.SERVER);
+ * logger.debug('Processing request', LOG_MODULES.GATEWAY, requestData);
+ *
+ * // For dynamic module names
+ * logger.info('Dynamic module', LOG_MODULES.dynamic('MyCustomModule'));
+ * ```
+ */
+export declare const LOG_MODULES: {
+    readonly SERVER: {
+        module: string;
+    };
+    readonly DEV_SERVER: {
+        module: string;
+    };
+    readonly CONFIG_MANAGER: {
+        module: string;
+    };
+    readonly CONFIG_LOADER: {
+        module: string;
+    };
+    readonly CONFIG_CHANGES: {
+        module: string;
+    };
+    readonly SESSION_MANAGER: {
+        module: string;
+    };
+    readonly SESSION: {
+        module: string;
+    };
+    readonly SESSION_API: {
+        module: string;
+    };
+    readonly CONNECTION_MANAGER: {
+        module: string;
+    };
+    readonly HUB_MANAGER: {
+        module: string;
+    };
+    readonly GATEWAY: {
+        module: string;
+    };
+    readonly GATEWAY_SERVICE: {
+        module: string;
+    };
+    readonly HUB_TOOLS: {
+        module: string;
+    };
+    readonly SYSTEM_TOOL: {
+        module: string;
+    };
+    readonly TOOL_LIST: {
+        module: string;
+    };
+    readonly INITIALIZE_HANDLER: {
+        module: string;
+    };
+    readonly SYSTEM_TOOLS_HANDLER: {
+        module: string;
+    };
+    readonly RESOURCES_HANDLER: {
+        module: string;
+    };
+    readonly TOOLS_HANDLER: {
+        module: string;
+    };
+    readonly SEARCH: {
+        module: string;
+    };
+    readonly COMMUNICATION: {
+        module: string;
+    };
+    readonly CONTEXT: {
+        module: string;
+    };
+    readonly WEBSOCKET: {
+        module: string;
+    };
+    readonly HTTP_TRANSPORT: {
+        module: string;
+    };
+    readonly STDIO_TRANSPORT: {
+        module: string;
+    };
+    readonly SSE_TRANSPORT: {
+        module: string;
+    };
+    readonly PID_MANAGER: {
+        module: string;
+    };
+    readonly CLIENT_TRACKER: {
+        module: string;
+    };
+    readonly CLIENT_API: {
+        module: string;
+    };
+    readonly SERVER_API: {
+        module: string;
+    };
+    readonly MCP_STATUS: {
+        module: string;
+    };
+    readonly NOTIFICATIONS_MESSAGE: {
+        module: string;
+    };
+    /**
+     * Creates a dynamic log module for custom or runtime-generated module names.
+     * Use this for server-specific logging or other dynamic contexts.
+     *
+     * @param moduleName - The dynamic module name
+     * @returns A LogOptions object with the module name
+     *
+     * @example
+     * ```typescript
+     * logger.info('Server connected', LOG_MODULES.dynamic(serverId));
+     * ```
+     */
+    readonly dynamic: (moduleName: string) => {
+        module: string;
+    };
+};
+/**
+ * Type representing the keys of LOG_MODULES.
+ */
+export type LogModuleKey = keyof Omit<typeof LOG_MODULES, 'dynamic'>;
+/**
+ * Type representing a log module object.
+ */
+export type LogModule = (typeof LOG_MODULES)[LogModuleKey];
+//# sourceMappingURL=log-modules.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log-modules.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-modules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+DtB;;;;;;;;;;;OAWG;mCACmB,MAAM;;;CACpB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,OAAO,WAAW,EAAE,SAAS,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,YAAY,CAAC,CAAC"}

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

@@ -0,0 +1,81 @@
+/**
+ * Log module constants.
+ * This file contains predefined log module constants for consistent usage across the codebase.
+ */
+/**
+ * Log module constants for use with the logger.
+ * These constants provide type-safe module identifiers for consistent logging.
+ *
+ * @example
+ * ```typescript
+ * import { LOG_MODULES } from './logger/log-modules.js';
+ *
+ * logger.info('Server started', LOG_MODULES.SERVER);
+ * logger.debug('Processing request', LOG_MODULES.GATEWAY, requestData);
+ *
+ * // For dynamic module names
+ * logger.info('Dynamic module', LOG_MODULES.dynamic('MyCustomModule'));
+ * ```
+ */
+export const LOG_MODULES = {
+    // Core system modules
+    SERVER: { module: 'Server' },
+    DEV_SERVER: { module: 'DevServer' },
+    // Config management
+    CONFIG_MANAGER: { module: 'ConfigManager' },
+    CONFIG_LOADER: { module: 'ConfigLoader' },
+    CONFIG_CHANGES: { module: 'System Config Changes' },
+    // Session management
+    SESSION_MANAGER: { module: 'SessionManager' },
+    SESSION: { module: 'Session' },
+    SESSION_API: { module: 'Session API' },
+    // Connection management
+    CONNECTION_MANAGER: { module: 'ConnectionManager' },
+    HUB_MANAGER: { module: 'HubManager' },
+    // Gateway related
+    GATEWAY: { module: 'Gateway' },
+    GATEWAY_SERVICE: { module: 'GatewayService' },
+    // Tool handling
+    HUB_TOOLS: { module: 'HubTools' },
+    SYSTEM_TOOL: { module: 'SystemTool' },
+    TOOL_LIST: { module: 'ToolList' },
+    // Gateway request handlers
+    INITIALIZE_HANDLER: { module: 'Initialize' },
+    SYSTEM_TOOLS_HANDLER: { module: 'SystemTools' },
+    RESOURCES_HANDLER: { module: 'Resources' },
+    TOOLS_HANDLER: { module: 'Tools' },
+    // Search service
+    SEARCH: { module: 'Search' },
+    // Communication
+    COMMUNICATION: { module: 'Communication' },
+    CONTEXT: { module: 'Context' },
+    // WebSocket
+    WEBSOCKET: { module: 'WebSocket' },
+    // Transports
+    HTTP_TRANSPORT: { module: 'HTTPTransport' },
+    STDIO_TRANSPORT: { module: 'StdioTransport' },
+    SSE_TRANSPORT: { module: 'SSETransport' },
+    // PID management
+    PID_MANAGER: { module: 'PIDManager' },
+    // Client tracking
+    CLIENT_TRACKER: { module: 'ClientTracker' },
+    CLIENT_API: { module: 'ClientAPI' },
+    // Server API
+    SERVER_API: { module: 'ServerAPI' },
+    MCP_STATUS: { module: 'MCPStatus' },
+    // Notifications
+    NOTIFICATIONS_MESSAGE: { module: 'notifications/message' },
+    /**
+     * Creates a dynamic log module for custom or runtime-generated module names.
+     * Use this for server-specific logging or other dynamic contexts.
+     *
+     * @param moduleName - The dynamic module name
+     * @returns A LogOptions object with the module name
+     *
+     * @example
+     * ```typescript
+     * logger.info('Server connected', LOG_MODULES.dynamic(serverId));
+     * ```
+     */
+    dynamic: (moduleName) => ({ module: moduleName })
+};

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

@@ -0,0 +1,68 @@
+/**
+ * Log output management utilities.
+ * This file contains MCP response detection and simplification functions.
+ */
+/**
+ * Interface for notifications/message parameters.
+ */
+interface NotificationMessageParams {
+    level?: string;
+    logger?: string;
+    data?: unknown;
+}
+/**
+ * Interface for notifications/message.
+ */
+interface NotificationMessage {
+    method: string;
+    params?: NotificationMessageParams;
+}
+/**
+ * Check if a message is a notifications/message.
+ *
+ * @param message - The message to check
+ * @returns true if the message is a notifications/message
+ */
+export declare function isNotificationMessage(message: unknown): message is NotificationMessage;
+/**
+ * Log a notifications/message to the application logs.
+ *
+ * @param message - The notification message
+ * @param context - Optional context (server name, session ID, etc.)
+ * @param serverId - Optional server ID for log storage (for frontend display)
+ */
+export declare function logNotificationMessage(message: unknown, context: string, serverId?: string): void;
+/**
+ * Format an MCP message for logging, with simplification for tools/list,
+ * resources/list, capabilities responses, and image content.
+ *
+ * @param message - The MCP message object to format
+ * @returns Formatted log message string
+ */
+export declare function formatMcpMessageForLogging(message: unknown): string;
+/**
+ * Check if data contains image content with binary data.
+ * @param data - stdout or response data
+ * @returns true if it contains image content with data field
+ */
+export declare function hasImageContent(data: string): boolean;
+/**
+ * Simplify image content by replacing binary data with placeholder.
+ * @param data - Complete response data
+ * @returns Log information with binary image data replaced
+ */
+export declare function simplifyImageContent(data: string): string;
+/**
+ * Check if data is a tools/list response.
+ * @param data - stdout or response data
+ * @returns true if it's a tools/list response
+ */
+export declare function isToolsListResponse(data: string): boolean;
+/**
+ * Simplify tools/list response log information.
+ * @param data - Complete response data
+ * @returns Simplified log information
+ */
+export declare function simplifyToolsListResponse(data: string): string;
+export {};
+//# sourceMappingURL=log-output.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"log-output.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-output.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH;;GAEG;AACH,UAAU,yBAAyB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,UAAU,mBAAmB;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,yBAAyB,CAAC;CACpC;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI,mBAAmB,CAMtF;AAqBD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAiDjG;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAsBnE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAgCrD;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqDzD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAyCzD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAyE9D"}