@loop_ouroboros/mcp-hub-lite 1.0.0 → 1.0.2

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

@@ -6,6 +6,204 @@ import { stringifyForLogging } from '../json-utils.js';
 import { getColorCodeForLevel, getResetColor, COLORS } from './log-colors.js';
 // PID formatting configuration
 const PID_WIDTH = 8;
+/**
+ * Check if we're running via tsx (development mode).
+ * In tsx mode, stack traces already show TypeScript file names and line numbers.
+ *
+ * @returns true if running via tsx
+ */
+function isTsxMode() {
+    return (process.argv.some((arg) => arg.includes('tsx')) ||
+        process.execArgv.some((arg) => arg.includes('tsx')) ||
+        !!process.env.TSX ||
+        (process.mainModule?.filename.includes('tsx') ?? false));
+}
+/**
+ * Check if a file path is a project source file.
+ *
+ * @param filePath - The file path to check
+ * @returns true if the file is within the project's src directory
+ */
+function isProjectSourceFile(filePath) {
+    return filePath.includes('/src/') || filePath.includes('\\src\\');
+}
+/**
+ * Clean up a file path to make it more readable.
+ * Extracts the relative path from the src directory if present.
+ * In tsx mode, keeps the .ts extension; in compiled mode, converts .js to .ts.
+ *
+ * @param filePath - The full file path to clean
+ * @returns Cleaned file path
+ */
+function cleanFilePath(filePath) {
+    let cleanFileName = filePath;
+    // If it's a full path, try to extract just the file name or relative path
+    if (cleanFileName.includes('/')) {
+        // Extract everything after the last /src/ if present
+        const srcIndex = cleanFileName.lastIndexOf('/src/');
+        if (srcIndex !== -1) {
+            cleanFileName = 'src' + cleanFileName.substring(srcIndex + 4);
+        }
+        else {
+            // Otherwise just take the base name
+            cleanFileName = cleanFileName.substring(cleanFileName.lastIndexOf('/') + 1);
+        }
+    }
+    else if (cleanFileName.includes('\\')) {
+        // Handle Windows paths
+        const srcIndex = cleanFileName.lastIndexOf('\\src\\');
+        if (srcIndex !== -1) {
+            cleanFileName = 'src' + cleanFileName.substring(srcIndex + 4);
+        }
+        else {
+            cleanFileName = cleanFileName.substring(cleanFileName.lastIndexOf('\\') + 1);
+        }
+    }
+    // In non-tsx mode (compiled JS), convert .js to .ts for TypeScript source files
+    if (!isTsxMode() && cleanFileName.endsWith('.js')) {
+        // Check if there's likely a .ts source file
+        // For our project, all .js files in src/ are compiled from .ts
+        if (cleanFileName.startsWith('src/') || cleanFileName.startsWith('src\\')) {
+            cleanFileName = cleanFileName.replace(/\.js$/, '.ts');
+        }
+    }
+    return cleanFileName;
+}
+/**
+ * Get caller information from stack trace.
+ * Extracts the file name, line number, and column number from the call stack.
+ * This method traverses the stack to find the first project source file (in src/),
+ * skipping external dependencies and Node.js internals.
+ *
+ * In tsx (development) mode: Parses default stack string for accurate .ts line numbers
+ * In production mode: Shows .ts file names but without line numbers (inaccurate)
+ *
+ * @param skipFrames - Number of stack frames to skip before starting the search (default: 3 to skip logger internal frames)
+ * @returns CallerInfo with fileName, lineNumber, columnNumber or null if cannot be determined
+ */
+export function getCallerInfo(skipFrames = 3) {
+    // In tsx mode, parse the default stack string for accurate line numbers
+    if (isTsxMode()) {
+        return getCallerInfoFromStackString(skipFrames);
+    }
+    // In production mode, use structured stack frames but without line numbers
+    return getCallerInfoFromStructuredStack(skipFrames);
+}
+/**
+ * Parse caller information from default stack string (for tsx mode).
+ * In tsx mode, the default stack string already contains accurate TypeScript
+ * file names and line numbers, so we parse it directly.
+ *
+ * @param skipFrames - Number of stack frames to skip
+ * @returns CallerInfo or null if cannot be determined
+ */
+function getCallerInfoFromStackString(skipFrames) {
+    const err = new Error();
+    const stackStr = err.stack;
+    if (!stackStr)
+        return null;
+    const lines = stackStr.split('\n').slice(1); // Skip first line ("Error")
+    // Find the first project source file in the stack
+    for (let i = skipFrames; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        // Match patterns like:
+        // at ... (file:///D:/path/src/file.ts:123:45)
+        // at ... (D:\path\src\file.ts:123:45)
+        // at file:///D:/path/src/file.ts:123:45
+        const match = line.match(/(?:\(|at\s+)([^:\s]+\/src\/[^:\s)]+|\S+\\src\\[^:\s)]+):(\d+)(?::(\d+))?/);
+        if (match) {
+            let filePath = match[1];
+            const lineNumber = parseInt(match[2], 10) || 0;
+            const columnNumber = match[3] ? parseInt(match[3], 10) : 0;
+            // Remove file:// prefix if present
+            if (filePath.startsWith('file://')) {
+                filePath = filePath.replace('file://', '');
+                // On Windows, file:///D:/path becomes /D:/path - fix that
+                if (filePath.startsWith('/') && filePath.length > 2 && filePath[2] === ':') {
+                    filePath = filePath.substring(1);
+                }
+            }
+            const cleanFileName = cleanFilePath(filePath);
+            return {
+                fileName: cleanFileName,
+                lineNumber,
+                columnNumber
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Get caller information from structured stack frames (for production mode).
+ * In production mode, we show the .ts file name but without line numbers
+ * since they would be inaccurate.
+ *
+ * @param skipFrames - Number of stack frames to skip
+ * @returns CallerInfo or null if cannot be determined
+ */
+function getCallerInfoFromStructuredStack(skipFrames) {
+    const originalPrepareStackTrace = Error.prepareStackTrace;
+    let callerInfo = null;
+    try {
+        // Override prepareStackTrace to get structured stack frames
+        Error.prepareStackTrace = (_err, stack) => stack;
+        const err = new Error();
+        const stack = err.stack;
+        if (stack && stack.length > skipFrames) {
+            let selectedFrame = null;
+            // Traverse stack frames starting from skipFrames
+            // Look for the first project source file (contains /src/ or \src\)
+            for (let i = skipFrames; i < stack.length; i++) {
+                const frame = stack[i];
+                if (!frame)
+                    continue;
+                const fileName = frame.getFileName() || '';
+                // If this is a project source file, use it
+                if (isProjectSourceFile(fileName)) {
+                    selectedFrame = frame;
+                    break;
+                }
+            }
+            // If no project source file found, fall back to the original skipFrames approach
+            if (!selectedFrame) {
+                selectedFrame = stack[skipFrames] || null;
+            }
+            if (selectedFrame) {
+                const fileName = selectedFrame.getFileName() || 'unknown';
+                // Clean up file path to make it more readable
+                const cleanFileName = cleanFilePath(fileName);
+                // In production mode, line numbers are inaccurate - don't show them
+                callerInfo = {
+                    fileName: cleanFileName,
+                    lineNumber: 0,
+                    columnNumber: 0
+                };
+            }
+        }
+    }
+    catch {
+        // Ignore errors - caller info is best effort
+    }
+    finally {
+        // Restore original prepareStackTrace
+        Error.prepareStackTrace = originalPrepareStackTrace;
+    }
+    return callerInfo;
+}
+/**
+ * Format caller information for display.
+ *
+ * @param callerInfo - Caller info to format
+ * @returns Formatted string like "file.ts:123" or just "file.ts" in production
+ */
+export function formatCallerInfo(callerInfo) {
+    if (callerInfo.lineNumber > 0) {
+        return `${callerInfo.fileName}:${callerInfo.lineNumber}`;
+    }
+    return callerInfo.fileName;
+}
 /**
  * Format a timestamp for logging.
  * @param date - The date to format
@@ -71,6 +269,7 @@ export function createColoredLogMessage(level, message, context) {
     const serverColor = COLORS.brightCyan;
     const moduleColor = COLORS.brightMagenta;
     const traceColor = COLORS.yellow;
+    const callerColor = COLORS.brightBlue;
     const resetColor = getResetColor();
     let result = `${timestampColor}[${timestamp}]${resetColor} ${levelColor}[${formattedLevel}]${resetColor} ${pidColor}[${formattedPid}]${resetColor}`;
     if (context?.traceId) {
@@ -83,6 +282,9 @@ export function createColoredLogMessage(level, message, context) {
     if (context?.module) {
         result += ` ${moduleColor}[${context.module}]${resetColor}`;
     }
+    if (context?.caller) {
+        result += ` ${callerColor}[${context.caller}]${resetColor}`;
+    }
     result += ` ${message}`;
     return result;
 }
@@ -110,6 +312,9 @@ export function createLogMessage(level, message, context) {
     if (context?.module) {
         result += ` [${context.module}]`;
     }
+    if (context?.caller) {
+        result += ` [${context.caller}]`;
+    }
     result += ` ${message}`;
     return result;
 }

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

@@ -42,6 +42,9 @@ export declare const LOG_MODULES: {
     readonly SESSION_API: {
         module: string;
     };
+    readonly SESSION_TRACKER: {
+        module: string;
+    };
     readonly CONNECTION_MANAGER: {
         module: string;
     };
@@ -99,12 +102,6 @@ export declare const LOG_MODULES: {
     readonly PID_MANAGER: {
         module: string;
     };
-    readonly CLIENT_TRACKER: {
-        module: string;
-    };
-    readonly CLIENT_API: {
-        module: string;
-    };
     readonly SERVER_API: {
         module: string;
     };

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4DtB;;;;;;;;;;;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

@@ -29,6 +29,7 @@ export const LOG_MODULES = {
     SESSION_MANAGER: { module: 'SessionManager' },
     SESSION: { module: 'Session' },
     SESSION_API: { module: 'Session API' },
+    SESSION_TRACKER: { module: 'SessionTracker' },
     // Connection management
     CONNECTION_MANAGER: { module: 'ConnectionManager' },
     HUB_MANAGER: { module: 'HubManager' },
@@ -57,9 +58,6 @@ export const LOG_MODULES = {
     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' },

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

@@ -61,8 +61,8 @@ export declare function isToolsListResponse(data: string): boolean;
 /**
  * Simplify tools/list response log information.
  * @param data - Complete response data
- * @returns Simplified log information
+ * @returns Simplified log information, or null if cannot be simplified
  */
-export declare function simplifyToolsListResponse(data: string): string;
+export declare function simplifyToolsListResponse(data: string): string | null;
 export {};
 //# sourceMappingURL=log-output.d.ts.map

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

@@ -1 +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"}
+{"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,CA4BnE;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,GAAG,IAAI,CAuFrE"}

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

@@ -99,7 +99,14 @@ export function formatMcpMessageForLogging(message) {
         const rawJson = JSON.stringify(message);
         let logMessage;
         if (isToolsListResponse(rawJson)) {
-            logMessage = simplifyToolsListResponse(rawJson);
+            const simplified = simplifyToolsListResponse(rawJson);
+            if (simplified === null) {
+                // Could not simplify, use pretty JSON formatting
+                logMessage = stringifyForLogging(message);
+            }
+            else {
+                logMessage = simplified;
+            }
         }
         else if (hasImageContent(rawJson)) {
             const simplified = simplifyImageContent(rawJson);
@@ -256,7 +263,7 @@ export function isToolsListResponse(data) {
 /**
  * Simplify tools/list response log information.
  * @param data - Complete response data
- * @returns Simplified log information
+ * @returns Simplified log information, or null if cannot be simplified
  */
 export function simplifyToolsListResponse(data) {
     try {
@@ -266,6 +273,9 @@ export function simplifyToolsListResponse(data) {
             if (dataMatch) {
                 const jsonData = dataMatch[1].trim();
                 const simplified = simplifyToolsListResponse(jsonData);
+                if (simplified === null) {
+                    return null;
+                }
                 return `event: message\ndata: ${simplified}`;
             }
         }
@@ -277,11 +287,19 @@ export function simplifyToolsListResponse(data) {
                     const result = msg.result;
                     if ('tools' in result) {
                         const toolsCount = Array.isArray(result.tools) ? result.tools.length : 0;
-                        return `Returned ${toolsCount} tools`;
+                        if (toolsCount > 0) {
+                            return `Returned ${toolsCount} tools`;
+                        }
+                        // No tools, don't simplify
+                        return null;
                     }
                     if ('resources' in result) {
                         const resourcesCount = Array.isArray(result.resources) ? result.resources.length : 0;
-                        return `Returned ${resourcesCount} resources`;
+                        if (resourcesCount > 0) {
+                            return `Returned ${resourcesCount} resources`;
+                        }
+                        // No resources, don't simplify
+                        return null;
                     }
                     if ('capabilities' in result &&
                         typeof result.capabilities === 'object' &&
@@ -308,13 +326,16 @@ export function simplifyToolsListResponse(data) {
                         else if (resourcesCount > 0) {
                             return `Returned ${resourcesCount} resources`;
                         }
+                        // No tools or resources, don't simplify
+                        return null;
                     }
                 }
             }
         }
     }
     catch {
-        // Parsing failed, return truncated version of original data
+        // Parsing failed, don't simplify
     }
-    return data.length > 200 ? data.substring(0, 200) + '...' : data;
+    // Could not simplify
+    return null;
 }

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

@@ -10,6 +10,7 @@
  * - Error formatting with stack trace truncation to prevent overly verbose logs
  * - MCP server-specific logging with serverName context
  * - Log rotation with date-based file naming and automatic cleanup
+ * - Caller location information (file name and line number)
  *
  * The logger supports four log levels: debug, info, warn, and error, with configurable
  * minimum log level threshold.
@@ -33,8 +34,20 @@ export declare class Logger {
     private level;
     private useStderr;
     private useColor;
+    private showCaller;
     private devLogger;
     constructor(level?: LogLevel);
+    /**
+     * Enable or disable caller information in logs.
+     * When enabled, logs will show the file name and line number where the log was called.
+     *
+     * @param show - Whether to show caller information
+     * @example
+     * ```typescript
+     * logger.setShowCaller(false); // Disable caller info
+     * ```
+     */
+    setShowCaller(show: boolean): void;
     /**
      * Enables development logging mode with file output and enhanced debugging.
      *

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

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAY5C,qBAAa,MAAM;IACjB,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,SAAS,CAA8B;gBAEnC,KAAK,GAAE,QAAiB;IAcpC;;;;;;;;;;;;OAYG;IACI,YAAY,CAAC,aAAa,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAO5E,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIvC;;;;;;;;;OASG;IACI,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAItC;;;OAGG;IACH,SAAS,CAAC,YAAY,EAAE,QAAQ,GAAG,OAAO;IAK1C;;OAEG;IACH,OAAO,CAAC,GAAG;IAgDX;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAKhD;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAK/C;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAK/C;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAKhD,OAAO,CAAC,qBAAqB;IAkB7B,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B;;;OAGG;IACH,SAAS,CACP,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,GACvC,IAAI;IAuBP;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IA4C3B;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;OAGG;IACH,uBAAuB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM;IAIvF;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM;IAIhF;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAInC;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAInC;;;OAGG;IACH,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAIvC;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;CAG/B"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/logger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,kBAAkB,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAc5C,qBAAa,MAAM;IACjB,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,QAAQ,CAAiB;IACjC,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,SAAS,CAA8B;gBAEnC,KAAK,GAAE,QAAiB;IAoBpC;;;;;;;;;OASG;IACI,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAIzC;;;;;;;;;;;;OAYG;IACI,YAAY,CAAC,aAAa,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAO5E,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIvC;;;;;;;;;OASG;IACI,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAItC;;;OAGG;IACH,SAAS,CAAC,YAAY,EAAE,QAAQ,GAAG,OAAO;IAK1C;;OAEG;IACH,OAAO,CAAC,GAAG;IAuDX;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAKhD;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAK/C;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAK/C;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAKhD,OAAO,CAAC,qBAAqB;IAkB7B,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B;;;OAGG;IACH,SAAS,CACP,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,YAAY,CAAC,GACvC,IAAI;IAuBP;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAuD3B;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;OAGG;IACH,uBAAuB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM;IAIvF;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM;IAIhF;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAInC;;;OAGG;IACH,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAInC;;;OAGG;IACH,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM;IAIvC;;;OAGG;IACH,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;CAG/B"}

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

@@ -10,6 +10,7 @@
  * - Error formatting with stack trace truncation to prevent overly verbose logs
  * - MCP server-specific logging with serverName context
  * - Log rotation with date-based file naming and automatic cleanup
+ * - Caller location information (file name and line number)
  *
  * The logger supports four log levels: debug, info, warn, and error, with configurable
  * minimum log level threshold.
@@ -28,12 +29,13 @@
  */
 import { DevLogger } from './dev-logger.js';
 import { LOG_MODULES } from './log-modules.js';
-import { createColoredLogMessage, createLogMessage, formatError, formatTimestamp, formatLogLevel, formatPid } from './log-formatter.js';
+import { createColoredLogMessage, createLogMessage, formatError, formatTimestamp, formatLogLevel, formatPid, getCallerInfo, formatCallerInfo } from './log-formatter.js';
 import { setDevModeEnabled } from '../json-utils.js';
 export class Logger {
     level = 'info';
     useStderr = false;
     useColor = true;
+    showCaller = true;
     devLogger = new DevLogger();
     constructor(level = 'info') {
         this.level = level;
@@ -45,6 +47,24 @@ export class Logger {
         if (noColorEnv === 'true' || noColorEnv === '1' || noColorEnv === '') {
             this.setUseColor(false);
         }
+        // Check LOG_CALLER environment variable
+        const logCallerEnv = process.env.LOG_CALLER;
+        if (logCallerEnv === 'false' || logCallerEnv === '0') {
+            this.setShowCaller(false);
+        }
+    }
+    /**
+     * Enable or disable caller information in logs.
+     * When enabled, logs will show the file name and line number where the log was called.
+     *
+     * @param show - Whether to show caller information
+     * @example
+     * ```typescript
+     * logger.setShowCaller(false); // Disable caller info
+     * ```
+     */
+    setShowCaller(show) {
+        this.showCaller = show;
     }
     /**
      * Enables development logging mode with file output and enhanced debugging.
@@ -101,13 +121,19 @@ export class Logger {
             const formattedArgs = args.map((arg) => formatError(arg)).join(' ');
             fullMessage = `${message} ${formattedArgs}`;
         }
-        const context = options
-            ? {
-                module: options.module,
-                traceId: options.traceId,
-                spanId: options.spanId
+        // Build context object
+        const context = {
+            ...(options?.module && { module: options.module }),
+            ...(options?.traceId && { traceId: options.traceId }),
+            ...(options?.spanId && { spanId: options.spanId })
+        };
+        // Add caller info if enabled
+        if (this.showCaller) {
+            const callerInfo = getCallerInfo(4); // Skip 4 frames to get to the actual caller
+            if (callerInfo) {
+                context.caller = formatCallerInfo(callerInfo);
             }
-            : undefined;
+        }
         const coloredLogMsg = createColoredLogMessage(level, fullMessage, context);
         const plainLogMsg = createLogMessage(level, fullMessage, context);
         const consoleLogMsg = this.useColor ? coloredLogMsg : plainLogMsg;
@@ -256,10 +282,19 @@ export class Logger {
      * Contains the core logging logic originally in serverLog.
      */
     logSingleServerLine(level, serverName, message, context) {
+        // Build log context with server name
         const logContext = {
             ...context,
             serverName
         };
+        // Add caller info if enabled (only once per serverLog call would be better,
+        // but for consistency with multi-line logging, we add it for each line)
+        if (this.showCaller) {
+            const callerInfo = getCallerInfo(5); // Skip 5 frames to get to the actual caller
+            if (callerInfo) {
+                logContext.caller = formatCallerInfo(callerInfo);
+            }
+        }
         const coloredLogMsg = createColoredLogMessage(level, message, logContext);
         const plainLogMsg = createLogMessage(level, message, logContext);
         const consoleLogMsg = this.useColor ? coloredLogMsg : plainLogMsg;

package/dist/server/src/utils/request-context.d.ts

@@ -6,66 +6,66 @@
  * every function call. It uses Node.js AsyncLocalStorage to maintain context
  * throughout the request lifecycle.
  *
- * The primary use case is storing client context information (sessionId, clientName,
+ * The primary use case is storing session context information (sessionId, clientName,
  * cwd, project, etc.) that needs to be accessible from any part of the application
  * during request processing.
  *
  * @module utils/request-context
  */
 import { AsyncLocalStorage } from 'async_hooks';
-import type { ClientContext } from '../../shared/types/client.types.js';
+import type { SessionContext } from '../../shared/types/session-context.types.js';
 /**
  * AsyncLocalStorage instance for storing request context.
  *
- * This storage holds the ClientContext object for the current request and
+ * This storage holds the SessionContext object for the current request and
  * makes it available throughout the entire request processing chain,
  * including asynchronous operations and nested function calls.
  *
  * @example
  * ```typescript
  * // In route handler
- * await requestContext.run(clientContext, async () => {
- *   // Any code executed here can access the client context
- *   const ctx = getClientContext();
+ * await requestContext.run(sessionContext, async () => {
+ *   // Any code executed here can access the session context
+ *   const ctx = getSessionContext();
  *   console.log(ctx.sessionId);
  * });
  * ```
  */
-export declare const requestContext: AsyncLocalStorage<ClientContext>;
+export declare const requestContext: AsyncLocalStorage<SessionContext>;
 /**
- * Retrieves the current request's client context.
+ * Retrieves the current request's session context.
  *
- * This function returns the ClientContext object stored in the AsyncLocalStorage
+ * This function returns the SessionContext object stored in the AsyncLocalStorage
  * for the current request. It should only be called within a request context
  * that has been established using requestContext.run().
  *
- * @returns {ClientContext | undefined} The current request's client context, or undefined if not in a request context
+ * @returns {SessionContext | undefined} The current request's session context, or undefined if not in a request context
  *
  * @example
  * ```typescript
- * const context = getClientContext();
+ * const context = getSessionContext();
  * if (context) {
  *   console.log(`Processing request for session: ${context.sessionId}`);
  * }
  * ```
  */
-export declare function getClientContext(): ClientContext | undefined;
+export declare function getSessionContext(): SessionContext | undefined;
 /**
  * Retrieves the current request's working directory (cwd).
  *
  * This is a convenience function that extracts the cwd property from the
- * current request's client context. It's commonly used in file operations
- * that need to respect the client's current working directory.
+ * current request's session context. It's commonly used in file operations
+ * that need to respect the session's current working directory.
  *
  * @returns {string | undefined} The current request's working directory, or undefined if not available
  *
  * @example
  * ```typescript
- * const cwd = getClientCwd();
+ * const cwd = getSessionCwd();
  * if (cwd) {
  *   const fullPath = path.join(cwd, relativePath);
  * }
  * ```
  */
-export declare function getClientCwd(): string | undefined;
+export declare function getSessionCwd(): string | undefined;
 //# sourceMappingURL=request-context.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../../../src/utils/request-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,kCAAyC,CAAC;AAErE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,IAAI,aAAa,GAAG,SAAS,CAE5D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,IAAI,MAAM,GAAG,SAAS,CAEjD"}
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../../../../src/utils/request-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAE7E;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,mCAA0C,CAAC;AAEtE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,GAAG,SAAS,CAE9D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,SAAS,CAElD"}