@loop_ouroboros/mcp-hub-lite 1.0.1 → 1.1.0

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/parameter-validator.d.ts

@@ -0,0 +1,10 @@
+import type { JsonSchema } from '../../shared/models/tool.model.js';
+/**
+ * Validates tool arguments against the provided JSON schema
+ *
+ * @param args - The tool arguments to validate
+ * @param schema - The JSON schema to validate against
+ * @returns null if valid, or an error message string if invalid
+ */
+export declare function validateParameters(args: Record<string, unknown>, schema: JsonSchema): string | null;
+//# sourceMappingURL=parameter-validator.d.ts.map

package/dist/server/src/utils/parameter-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-validator.d.ts","sourceRoot":"","sources":["../../../../src/utils/parameter-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,UAAU,GACjB,MAAM,GAAG,IAAI,CAyBf"}

package/dist/server/src/utils/parameter-validator.js

@@ -0,0 +1,53 @@
+/**
+ * Validates tool arguments against the provided JSON schema
+ *
+ * @param args - The tool arguments to validate
+ * @param schema - The JSON schema to validate against
+ * @returns null if valid, or an error message string if invalid
+ */
+export function validateParameters(args, schema) {
+    // Check required fields
+    if (schema.required && Array.isArray(schema.required)) {
+        for (const requiredField of schema.required) {
+            if (!(requiredField in args)) {
+                return `Missing required parameter: '${requiredField}'. Required parameters: [${schema.required.join(', ')}]`;
+            }
+        }
+    }
+    // Check parameter types (basic validation)
+    if (schema.properties) {
+        for (const [paramName, paramSchema] of Object.entries(schema.properties)) {
+            if (paramName in args) {
+                const argValue = args[paramName];
+                const expectedType = paramSchema.type;
+                if (expectedType && !isValidType(argValue, expectedType)) {
+                    return `Invalid type for parameter '${paramName}'. Expected: ${expectedType}, got: ${typeof argValue}`;
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Validates if a value matches the expected type
+ *
+ * @param value - The value to validate
+ * @param expectedType - The expected JSON schema type
+ * @returns true if valid, false otherwise
+ */
+function isValidType(value, expectedType) {
+    switch (expectedType) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number';
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        default:
+            return true; // Cannot validate unknown types, so pass by default
+    }
+}

package/dist/server/src/utils/process-tree.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Windows Process Tree Utility Module
+ *
+ * This module provides process tree management utilities specifically for Windows.
+ * It handles the case where shell: true spawns cmd.exe which then spawns
+ * the actual working process (like node.exe, python.exe, etc.).
+ *
+ * On non-Windows platforms, all methods return safe default values
+ * and don't perform any actual operations.
+ */
+/**
+ * Gets all child process IDs for a given parent PID on Windows.
+ *
+ * @param pid - Parent process ID
+ @returns Promise resolving to array of child PID
+ */
+export declare function getChildren(pid: number): Promise<number[]>;
+/**
+ * Gets the entire process tree (all descendants) for a given PID.
+ * Includes the original PID at the beginning of the array.
+ *
+ * @param pid - Root process ID
+ * @returns Array of all process IDs in the tree
+ */
+export declare function getProcessTree(pid: number): Promise<number[]>;
+/**
+ * Checks if any process in the process tree is still running.
+ *
+ * @param pid - Root process ID
+ * @returns True if any process in the tree is running
+ */
+export declare function isAnyInTreeRunning(pid: number): Promise<boolean>;
+/**
+ * Tries to find the actual working process PID in the tree.
+ * This looks for processes that are likely the actual worker
+ * (node.exe, python.exe, etc.) rather than shell processes.
+ *
+ * @param pid - Root process ID
+ * @returns Working process PID if found, undefined otherwise
+ */
+export declare function getWorkingProcessPid(pid: number): Promise<number | undefined>;
+/**
+ * Kills the entire process tree.
+ *
+ * @param pid - Root process ID
+ * @param signal - Signal to send (default: SIGTERM)
+ */
+export declare function killProcessTree(pid: number, signal?: NodeJS.Signals): Promise<void>;
+//# sourceMappingURL=process-tree.d.ts.map

package/dist/server/src/utils/process-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-tree.d.ts","sourceRoot":"","sources":["../../../../src/utils/process-tree.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBhE;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAqBnE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBtE;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAkCnF;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,MAAM,CAAC,OAAmB,GACjC,OAAO,CAAC,IAAI,CAAC,CAgCf"}

package/dist/server/src/utils/process-tree.js

@@ -0,0 +1,285 @@
+import { spawn } from 'child_process';
+import { logger, LOG_MODULES } from './logger.js';
+/**
+ * Windows Process Tree Utility Module
+ *
+ * This module provides process tree management utilities specifically for Windows.
+ * It handles the case where shell: true spawns cmd.exe which then spawns
+ * the actual working process (like node.exe, python.exe, etc.).
+ *
+ * On non-Windows platforms, all methods return safe default values
+ * and don't perform any actual operations.
+ */
+/**
+ * Gets all child process IDs for a given parent PID on Windows.
+ *
+ * @param pid - Parent process ID
+ @returns Promise resolving to array of child PID
+ */
+export async function getChildren(pid) {
+    if (process.platform !== 'win32') {
+        return [];
+    }
+    try {
+        const result = await executePowerShellCommand(`Get-CimInstance Win32_Process | Where-Object { $_.ParentProcessId -eq ${pid} } | Select-Object -ExpandProperty ProcessId`);
+        const pids = parsePidList(result);
+        return pids;
+    }
+    catch (error) {
+        logger.debug(`Failed to get children for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        return [];
+    }
+}
+/**
+ * Gets the entire process tree (all descendants) for a given PID.
+ * Includes the original PID at the beginning of the array.
+ *
+ * @param pid - Root process ID
+ * @returns Array of all process IDs in the tree
+ */
+export async function getProcessTree(pid) {
+    if (process.platform !== 'win32') {
+        return [pid];
+    }
+    const tree = [pid];
+    const queue = [pid];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const children = await getChildren(current);
+        for (const child of children) {
+            if (!tree.includes(child)) {
+                tree.push(child);
+                queue.push(child);
+            }
+        }
+    }
+    return tree;
+}
+/**
+ * Checks if any process in the process tree is still running.
+ *
+ * @param pid - Root process ID
+ * @returns True if any process in the tree is running
+ */
+export async function isAnyInTreeRunning(pid) {
+    if (process.platform !== 'win32') {
+        return isProcessRunning(pid);
+    }
+    try {
+        const tree = await getProcessTree(pid);
+        for (const processId of tree) {
+            if (isProcessRunning(processId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        logger.debug(`Error checking process tree for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        return isProcessRunning(pid);
+    }
+}
+/**
+ * Tries to find the actual working process PID in the tree.
+ * This looks for processes that are likely the actual worker
+ * (node.exe, python.exe, etc.) rather than shell processes.
+ *
+ * @param pid - Root process ID
+ * @returns Working process PID if found, undefined otherwise
+ */
+export async function getWorkingProcessPid(pid) {
+    if (process.platform !== 'win32') {
+        return pid;
+    }
+    try {
+        const tree = await getProcessTree(pid);
+        // If only the root process is in the tree, return it
+        if (tree.length === 1) {
+            return pid;
+        }
+        // Get process names for all PIDs in the tree
+        const processInfo = await getProcessInfo(tree);
+        // Filter out shell processes (cmd.exe, powershell.exe, etc.)
+        const workerProcesses = processInfo.filter((info) => !isShellProcess(info.name));
+        if (workerProcesses.length > 0) {
+            // Prefer the deepest (last) worker process in the tree
+            return workerProcesses[workerProcesses.length - 1].pid;
+        }
+        // If no worker processes found, return the last process in the tree
+        return tree[tree.length - 1];
+    }
+    catch (error) {
+        logger.debug(`Error finding working process for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        return pid;
+    }
+}
+/**
+ * Kills the entire process tree.
+ *
+ * @param pid - Root process ID
+ * @param signal - Signal to send (default: SIGTERM)
+ */
+export async function killProcessTree(pid, signal = 'SIGTERM') {
+    if (process.platform !== 'win32') {
+        // On non-Windows, just kill the single process
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Process might already be dead
+        }
+        return;
+    }
+    try {
+        const tree = await getProcessTree(pid);
+        // Kill processes in reverse order (children first, parent last)
+        for (let i = tree.length - 1; i >= 0; i--) {
+            const processId = tree[i];
+            try {
+                process.kill(processId, signal);
+            }
+            catch {
+                // Process might already be dead
+            }
+        }
+    }
+    catch (error) {
+        logger.debug(`Error killing process tree for PID ${pid}:`, error, LOG_MODULES.STDIO_TRANSPORT);
+        // Fallback: try to kill just the root process
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // Process might already be dead
+        }
+    }
+}
+// ==================== Internal Helper Functions ====================
+/**
+ * Checks if a single process is running.
+ *
+ * @param pid - Process ID
+ * @returns True if process is running
+ */
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Executes a PowerShell command and returns the output.
+ *
+ * @param command - PowerShell command
+ * @returns Command output
+ */
+async function executePowerShellCommand(command) {
+    return new Promise((resolve, reject) => {
+        const ps = spawn('powershell.exe', ['-Command', command], {
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        ps.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        ps.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        ps.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout.trim());
+            }
+            else {
+                reject(new Error(`PowerShell command failed: ${stderr || stdout}`));
+            }
+        });
+        ps.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+/**
+ * Parses a list of PIDs from command output.
+ *
+ * @param output - Command output
+ * * @returns Array of PIDs
+ */
+function parsePidList(output) {
+    const lines = output
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    const pids = [];
+    for (const line of lines) {
+        const pid = parseInt(line, 10);
+        if (!isNaN(pid) && pid > 0) {
+            pids.push(pid);
+        }
+    }
+    return pids;
+}
+/**
+ * Gets process information for multiple PIDs.
+ *
+ * @param pids - Array of process IDs
+ * @returns Array of process info objects
+ */
+async function getProcessInfo(pids) {
+    if (pids.length === 0) {
+        return [];
+    }
+    const result = await executePowerShellCommand(`Get-CimInstance Win32_Process | Where-Object { ${pids.map((pid) => `$_.ProcessId -eq ${pid}`).join(' -or ')} } | Select-Object ProcessId, Name | ConvertTo-Csv -NoTypeInformation`);
+    return parseProcessInfoCsv(result);
+}
+/**
+ * Parses process info from CSV output.
+ *
+ * @param csvOutput - CSV output from PowerShell
+ * @ *returns Array of process info
+ */
+function parseProcessInfoCsv(csvOutput) {
+    const lines = csvOutput
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length < 2) {
+        return [];
+    }
+    const info = [];
+    // Skip header line
+    for (let i = 1; i < lines.length; i++) {
+        const parts = lines[i].split(',').map((p) => p.trim().replace(/^"|"$/g, ''));
+        if (parts.length >= 2) {
+            const pid = parseInt(parts[0], 10);
+            if (!isNaN(pid) && pid > 0) {
+                info.push({
+                    pid,
+                    name: parts[1].toLowerCase()
+                });
+            }
+        }
+    }
+    return info;
+}
+/**
+ * Checks if a process name is a shell process.
+ *
+ * @param processName - Process name (should be lowercase)
+ * @returns True if it's a shell process
+ */
+function isShellProcess(processName) {
+    const shellProcesses = [
+        'cmd.exe',
+        'powershell.exe',
+        'pwsh.exe',
+        'command.com',
+        'sh.exe',
+        'bash.exe'
+    ];
+    return shellProcesses.includes(processName.toLowerCase());
+}

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

@@ -6,66 +6,48 @@
  * 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;
-/**
- * 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.
- *
- * @returns {string | undefined} The current request's working directory, or undefined if not available
- *
- * @example
- * ```typescript
- * const cwd = getClientCwd();
- * if (cwd) {
- *   const fullPath = path.join(cwd, relativePath);
- * }
- * ```
- */
-export declare function getClientCwd(): string | undefined;
+export declare function getSessionContext(): SessionContext | 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"}

package/dist/server/src/utils/request-context.js

@@ -6,7 +6,7 @@
  * 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.
  *
@@ -16,58 +16,38 @@ import { AsyncLocalStorage } from 'async_hooks';
 /**
  * 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 const requestContext = new AsyncLocalStorage();
 /**
- * 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 function getClientContext() {
+export function getSessionContext() {
     return requestContext.getStore();
 }
-/**
- * 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.
- *
- * @returns {string | undefined} The current request's working directory, or undefined if not available
- *
- * @example
- * ```typescript
- * const cwd = getClientCwd();
- * if (cwd) {
- *   const fullPath = path.join(cwd, relativePath);
- * }
- * ```
- */
-export function getClientCwd() {
-    return requestContext.getStore()?.cwd;
-}