@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
126 lines • 12 kB
JavaScript
/**
* Context Tracking for LLM Request Detection
*
* Part of Issue #1321 Phase 2: Memory Security Architecture
*
* PURPOSE:
* Tracks execution context to detect if code is running within an LLM request
* handler. Uses AsyncLocalStorage to maintain context across async operations.
*
* SECURITY:
* - Prevents pattern decryption in LLM contexts
* - Ensures patterns never leak to LLM responses
* - Provides audit trail for context checks
*
* REFACTOR NOTE:
* Converted from static class to instance-based for DI architecture compatibility.
* ContextTracker now uses instance methods instead of static methods, allowing
* proper lifecycle management and testability within DI container.
*
* @module ContextTracker
*/
import { AsyncLocalStorage } from 'node:async_hooks';
import { randomBytes } from 'node:crypto';
import { logger } from '../../utils/logger.js';
/**
* Context tracker using AsyncLocalStorage
*
* Maintains execution context across async operations to detect
* LLM request handling and prevent pattern decryption in those contexts.
*
* DI-COMPATIBLE: Instance-based service for dependency injection.
*/
export class ContextTracker {
storage = new AsyncLocalStorage();
/**
* Create a new ContextTracker instance
*/
constructor() {
logger.debug('ContextTracker initialized');
}
/**
* Run a function within a specific execution context
*
* @param context - Execution context to set
* @param fn - Function to run within the context
* @returns Result of the function
*/
run(context, fn) {
return this.storage.run(context, fn);
}
/**
* Run an async function within a specific execution context
*
* @param context - Execution context to set
* @param fn - Async function to run within the context
* @returns Promise resolving to the function result
*/
async runAsync(context, fn) {
return this.storage.run(context, fn);
}
/**
* Get the current execution context
*
* @returns Current context or undefined if no context is set
*/
getContext() {
return this.storage.getStore();
}
/**
* Check if currently in an LLM request context
*
* @returns true if in LLM request context, false otherwise
*/
isLLMContext() {
const context = this.getContext();
return context?.type === 'llm-request';
}
/**
* Create a new execution context object
*
* @param type - Context type
* @param metadata - Optional metadata
* @returns New execution context
*/
createContext(type, metadata) {
return {
type,
requestId: this.generateRequestId(),
timestamp: Date.now(),
metadata,
};
}
/**
* Generate a unique request ID using cryptographically secure random bytes
*
* @returns Unique request ID
*/
generateRequestId() {
// Use cryptographically secure random bytes instead of Math.random()
const randomId = randomBytes(4).toString('hex');
return `${Date.now()}-${randomId}`;
}
/**
* Get the current correlation ID (request-level identifier).
* Returns undefined when no context is active (e.g. background timers).
*/
getCorrelationId() {
return this.getContext()?.requestId;
}
/**
* Clear the current context (useful for testing)
*/
clearContext() {
// AsyncLocalStorage doesn't have a direct clear method
// Context is automatically cleared when execution exits
}
/**
* Dispose of the context tracker and clean up resources
* Implements cleanup for proper DI lifecycle management
*/
async dispose() {
this.clearContext();
logger.debug('ContextTracker disposed');
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ContextTracker.js","sourceRoot":"","sources":["../../../src/security/encryption/ContextTracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAmB/C;;;;;;;GAOG;AACH,MAAM,OAAO,cAAc;IACR,OAAO,GAAG,IAAI,iBAAiB,EAAoB,CAAC;IAErE;;OAEG;IACH;QACE,MAAM,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAI,OAAyB,EAAE,EAAW;QAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,CACZ,OAAyB,EACzB,EAAoB;QAEpB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,UAAU;QACR,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC;IACjC,CAAC;IAED;;;;OAIG;IACH,YAAY;QACV,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,OAAO,OAAO,EAAE,IAAI,KAAK,aAAa,CAAC;IACzC,CAAC;IAED;;;;;;OAMG;IACH,aAAa,CACX,IAA8B,EAC9B,QAAkC;QAElC,OAAO;YACL,IAAI;YACJ,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE;YACnC,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,QAAQ;SACT,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,iBAAiB;QACvB,qEAAqE;QACrE,MAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QAChD,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI,QAAQ,EAAE,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,UAAU,EAAE,EAAE,SAAS,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,YAAY;QACV,uDAAuD;QACvD,wDAAwD;IAC1D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,MAAM,CAAC,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAC1C,CAAC;CACF","sourcesContent":["/**\n * Context Tracking for LLM Request Detection\n *\n * Part of Issue #1321 Phase 2: Memory Security Architecture\n *\n * PURPOSE:\n * Tracks execution context to detect if code is running within an LLM request\n * handler. Uses AsyncLocalStorage to maintain context across async operations.\n *\n * SECURITY:\n * - Prevents pattern decryption in LLM contexts\n * - Ensures patterns never leak to LLM responses\n * - Provides audit trail for context checks\n *\n * REFACTOR NOTE:\n * Converted from static class to instance-based for DI architecture compatibility.\n * ContextTracker now uses instance methods instead of static methods, allowing\n * proper lifecycle management and testability within DI container.\n *\n * @module ContextTracker\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\nimport { randomBytes } from 'node:crypto';\nimport { logger } from '../../utils/logger.js';\n\n/**\n * Execution context information\n */\nexport interface ExecutionContext {\n  /** Context type (llm-request, background-task, test, etc.) */\n  type: 'llm-request' | 'background-task' | 'test' | 'unknown';\n\n  /** Request ID for correlation */\n  requestId?: string;\n\n  /** Timestamp when context was created */\n  timestamp: number;\n\n  /** Additional context metadata */\n  metadata?: Record<string, unknown>;\n}\n\n/**\n * Context tracker using AsyncLocalStorage\n *\n * Maintains execution context across async operations to detect\n * LLM request handling and prevent pattern decryption in those contexts.\n *\n * DI-COMPATIBLE: Instance-based service for dependency injection.\n */\nexport class ContextTracker {\n  private readonly storage = new AsyncLocalStorage<ExecutionContext>();\n\n  /**\n   * Create a new ContextTracker instance\n   */\n  constructor() {\n    logger.debug('ContextTracker initialized');\n  }\n\n  /**\n   * Run a function within a specific execution context\n   *\n   * @param context - Execution context to set\n   * @param fn - Function to run within the context\n   * @returns Result of the function\n   */\n  run<T>(context: ExecutionContext, fn: () => T): T {\n    return this.storage.run(context, fn);\n  }\n\n  /**\n   * Run an async function within a specific execution context\n   *\n   * @param context - Execution context to set\n   * @param fn - Async function to run within the context\n   * @returns Promise resolving to the function result\n   */\n  async runAsync<T>(\n    context: ExecutionContext,\n    fn: () => Promise<T>\n  ): Promise<T> {\n    return this.storage.run(context, fn);\n  }\n\n  /**\n   * Get the current execution context\n   *\n   * @returns Current context or undefined if no context is set\n   */\n  getContext(): ExecutionContext | undefined {\n    return this.storage.getStore();\n  }\n\n  /**\n   * Check if currently in an LLM request context\n   *\n   * @returns true if in LLM request context, false otherwise\n   */\n  isLLMContext(): boolean {\n    const context = this.getContext();\n    return context?.type === 'llm-request';\n  }\n\n  /**\n   * Create a new execution context object\n   *\n   * @param type - Context type\n   * @param metadata - Optional metadata\n   * @returns New execution context\n   */\n  createContext(\n    type: ExecutionContext['type'],\n    metadata?: Record<string, unknown>\n  ): ExecutionContext {\n    return {\n      type,\n      requestId: this.generateRequestId(),\n      timestamp: Date.now(),\n      metadata,\n    };\n  }\n\n  /**\n   * Generate a unique request ID using cryptographically secure random bytes\n   *\n   * @returns Unique request ID\n   */\n  private generateRequestId(): string {\n    // Use cryptographically secure random bytes instead of Math.random()\n    const randomId = randomBytes(4).toString('hex');\n    return `${Date.now()}-${randomId}`;\n  }\n\n  /**\n   * Get the current correlation ID (request-level identifier).\n   * Returns undefined when no context is active (e.g. background timers).\n   */\n  getCorrelationId(): string | undefined {\n    return this.getContext()?.requestId;\n  }\n\n  /**\n   * Clear the current context (useful for testing)\n   */\n  clearContext(): void {\n    // AsyncLocalStorage doesn't have a direct clear method\n    // Context is automatically cleared when execution exits\n  }\n\n  /**\n   * Dispose of the context tracker and clean up resources\n   * Implements cleanup for proper DI lifecycle management\n   */\n  async dispose(): Promise<void> {\n    this.clearContext();\n    logger.debug('ContextTracker disposed');\n  }\n}\n"]}