@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.
321 lines • 38.7 kB
JavaScript
/**
* Background Validation Service for Memory Security
*
* Part of Issue #1314 Phase 1: Memory Security Architecture
*
* PURPOSE:
* Asynchronously validates UNTRUSTED memory entries and updates their trust levels
* without blocking memory creation. Runs outside the LLM request path to avoid
* token costs and latency.
*
* ARCHITECTURE:
* - Layer 2 in the Memory Security Architecture (see docs/development/MEMORY_SECURITY_ARCHITECTURE.md)
* - Runs server-side, not in LLM context
* - No token cost for validation
* - Updates trust levels in-place
*
* TRUST LEVEL TRANSITIONS:
* UNTRUSTED → VALIDATED (clean content, no patterns)
* UNTRUSTED → FLAGGED (dangerous patterns detected, needs encryption)
* UNTRUSTED → QUARANTINED (explicitly malicious, critical threat)
*
* @module BackgroundValidator
*/
import { logger } from '../../utils/logger.js';
import { ContentValidator } from '../contentValidator.js';
import { TRUST_LEVELS } from '../../elements/memories/constants.js';
/**
* Default configuration for background validation
*/
const DEFAULT_CONFIG = {
enabled: true,
intervalSeconds: 300, // 5 minutes
batchSize: 10,
validationTimeoutMs: 5000,
};
/**
* Background validation service for memory entries
*
* This service runs outside the LLM request path to validate UNTRUSTED
* memory entries and update their trust levels based on security analysis.
*
* REFACTOR NOTE:
* Converted to full DI architecture. Removed singleton export.
* PatternExtractor is now injected as a dependency instead of static calls.
*/
export class BackgroundValidator {
patternExtractor;
memoryManager;
config;
intervalHandle;
isProcessing = false;
constructor(patternExtractor, memoryManager, // MemoryManager - using any to avoid circular import
config) {
this.patternExtractor = patternExtractor;
this.memoryManager = memoryManager;
this.config = { ...DEFAULT_CONFIG, ...config };
logger.info('BackgroundValidator initialized', {
enabled: this.config.enabled,
intervalSeconds: this.config.intervalSeconds,
batchSize: this.config.batchSize,
});
}
/**
* Start the background validation service
* Begins periodic validation of UNTRUSTED memories
*/
start() {
if (!this.config.enabled) {
logger.info('Background validation disabled in config');
return;
}
if (this.intervalHandle) {
logger.warn('Background validation already running');
return;
}
logger.info('Starting background validation service', {
intervalSeconds: this.config.intervalSeconds,
});
// Run immediately on start
void this.processUntrustedMemories();
// Then run periodically
this.intervalHandle = setInterval(() => {
void this.processUntrustedMemories();
}, this.config.intervalSeconds * 1000);
}
/**
* Stop the background validation service
*/
stop() {
if (this.intervalHandle) {
clearInterval(this.intervalHandle);
this.intervalHandle = undefined;
logger.info('Background validation service stopped');
}
}
/**
* Process all UNTRUSTED memory entries
* This is the main background validation loop
*/
async processUntrustedMemories() {
if (this.isProcessing) {
logger.debug('Validation already in progress, skipping this run');
return;
}
this.isProcessing = true;
try {
// PHASE 1 INCOMPLETE: Memory discovery integration pending
// Issue #1314 Phase 1 - This will be connected to Memory loading system
// in a follow-up PR once Memory.find() API is available
const untrustedMemories = await this.findMemoriesWithUntrustedEntries();
if (untrustedMemories.length === 0) {
return;
}
logger.info('Found untrusted memories to validate', {
count: untrustedMemories.length,
batchSize: this.config.batchSize,
});
// Process in batches
const batches = this.createBatches(untrustedMemories, this.config.batchSize);
for (const batch of batches) {
await this.processBatch(batch);
}
logger.info('Validation pass complete');
}
catch (error) {
logger.error('Error during background validation', { error });
}
finally {
this.isProcessing = false;
}
}
/**
* Find all memories that have UNTRUSTED entries
*
* DI REFACTOR: Use injected MemoryManager instead of static Memory methods
* Loads memories from filesystem and filters by trust level
*/
async findMemoriesWithUntrustedEntries() {
// Load all memories using the injected MemoryManager
const allMemories = await this.memoryManager.list();
// Filter to only memories with UNTRUSTED entries
const untrustedMemories = [];
const limit = this.config.batchSize * 10;
for (const memory of allMemories) {
const hasUntrustedEntries = memory.getEntriesByTrustLevel(TRUST_LEVELS.UNTRUSTED).length > 0;
if (hasUntrustedEntries) {
untrustedMemories.push(memory);
// Apply limit
if (untrustedMemories.length >= limit) {
break;
}
}
}
if (untrustedMemories.length > 0) {
logger.debug('Found memories with untrusted entries', {
count: untrustedMemories.length,
limit
});
}
return untrustedMemories;
}
/**
* Process a batch of memories for validation
*/
async processBatch(memories) {
logger.debug('Processing batch', { size: memories.length });
for (const memory of memories) {
try {
await this.validateMemory(memory);
}
catch (error) {
logger.error('Error validating memory', {
memoryId: memory.id,
error,
});
}
}
}
/**
* Validate all UNTRUSTED entries in a memory
* FIX #1320: Now uses public Memory API and saves changes
* FIX (Claude Bot Review): Removed type casting for memory.id
*/
async validateMemory(memory) {
logger.debug('Validating memory', { memoryId: memory.id });
let updatedCount = 0;
// FIX #1320: Use public API instead of casting to any
const entries = memory.getEntriesByTrustLevel(TRUST_LEVELS.UNTRUSTED);
for (const entry of entries) {
try {
const updated = await this.validateEntry(entry);
if (updated) {
updatedCount++;
}
}
catch (error) {
logger.error('Error validating entry', {
entryId: entry.id,
error,
});
}
}
if (updatedCount > 0) {
logger.info('Updated trust levels in memory', {
memoryId: memory.id,
updatedCount,
});
// DI REFACTOR: Use injected MemoryManager to save
try {
await this.memoryManager.save(memory);
logger.debug('Memory saved successfully', {
memoryId: memory.id
});
}
catch (error) {
logger.error('Failed to save memory after validation', {
memoryId: memory.id,
error
});
// Don't throw - continue with other memories
}
}
}
/**
* Validate a single memory entry and update its trust level
*
* @param entry - The memory entry to validate
* @returns true if the entry was updated, false otherwise
*/
async validateEntry(entry) {
logger.debug('Validating entry', { entryId: entry.id });
// Validate content using ContentValidator
const validationResult = ContentValidator.validateAndSanitize(entry.content, {
skipSizeCheck: true,
});
// Determine new trust level based on validation results
const newTrustLevel = this.determineTrustLevel(validationResult);
if (newTrustLevel === entry.trustLevel) {
logger.debug('Trust level unchanged', {
entryId: entry.id,
trustLevel: entry.trustLevel,
});
return false;
}
// Update trust level
entry.trustLevel = newTrustLevel;
logger.info('Updated entry trust level', {
entryId: entry.id,
oldTrustLevel: TRUST_LEVELS.UNTRUSTED,
newTrustLevel,
detectedPatterns: validationResult.detectedPatterns?.length || 0,
});
// If FLAGGED, extract patterns and create sanitized content
if (newTrustLevel === TRUST_LEVELS.FLAGGED) {
logger.debug('Entry flagged, extracting patterns', {
entryId: entry.id,
patterns: validationResult.detectedPatterns,
});
// Phase 1: Extract patterns and create sanitized content
const extractionResult = this.patternExtractor.extractPatterns(entry.content, validationResult);
// Store sanitized patterns and content in entry metadata
// Phase 2 will add encryption to these patterns
entry.sanitizedPatterns = extractionResult.patterns;
entry.sanitizedContent = extractionResult.sanitizedContent;
logger.info('Patterns extracted from entry', {
entryId: entry.id,
patternCount: extractionResult.patternCount,
});
}
return true;
}
/**
* Determine the appropriate trust level based on validation results
*/
determineTrustLevel(validationResult) {
// If validation passed with no patterns, mark as VALIDATED
if (validationResult.isValid && (!validationResult.detectedPatterns || validationResult.detectedPatterns.length === 0)) {
return TRUST_LEVELS.VALIDATED;
}
// If critical/high severity threats detected, mark as FLAGGED
if (validationResult.severity === 'critical' || validationResult.severity === 'high') {
// PHASE 1 INCOMPLETE: QUARANTINED trust level logic deferred (Issue #1314)
// Will add distinction between FLAGGED (dangerous) vs QUARANTINED (malicious)
// For now, all high/critical severity goes to FLAGGED
return TRUST_LEVELS.FLAGGED;
}
// Medium/low severity or minor issues - keep as UNTRUSTED for now
// (Could be VALIDATED in a more lenient policy)
return TRUST_LEVELS.UNTRUSTED;
}
/**
* Split an array into batches of specified size
*/
createBatches(items, batchSize) {
const batches = [];
for (let i = 0; i < items.length; i += batchSize) {
batches.push(items.slice(i, i + batchSize));
}
return batches;
}
/**
* Get current validation statistics
*/
getStats() {
return {
enabled: this.config.enabled,
isProcessing: this.isProcessing,
intervalSeconds: this.config.intervalSeconds,
batchSize: this.config.batchSize,
};
}
/**
* Dispose of the validator and clean up resources
* Implements cleanup for proper DI lifecycle management
*/
async dispose() {
this.stop();
logger.debug('BackgroundValidator disposed');
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BackgroundValidator.js","sourceRoot":"","sources":["../../../src/security/validation/BackgroundValidator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Background Validation Service for Memory Security\n *\n * Part of Issue #1314 Phase 1: Memory Security Architecture\n *\n * PURPOSE:\n * Asynchronously validates UNTRUSTED memory entries and updates their trust levels\n * without blocking memory creation. Runs outside the LLM request path to avoid\n * token costs and latency.\n *\n * ARCHITECTURE:\n * - Layer 2 in the Memory Security Architecture (see docs/development/MEMORY_SECURITY_ARCHITECTURE.md)\n * - Runs server-side, not in LLM context\n * - No token cost for validation\n * - Updates trust levels in-place\n *\n * TRUST LEVEL TRANSITIONS:\n * UNTRUSTED → VALIDATED (clean content, no patterns)\n * UNTRUSTED → FLAGGED (dangerous patterns detected, needs encryption)\n * UNTRUSTED → QUARANTINED (explicitly malicious, critical threat)\n *\n * @module BackgroundValidator\n */\n\nimport { logger } from '../../utils/logger.js';\nimport { ContentValidator, type ContentValidationResult } from '../contentValidator.js';\nimport { TRUST_LEVELS } from '../../elements/memories/constants.js';\nimport { PatternExtractor } from './PatternExtractor.js';\nimport type { Memory } from '../../elements/memories/Memory.js';\n\n/**\n * Configuration for background validation behavior\n */\nexport interface BackgroundValidatorConfig {\n  /** Enable background validation (default: true) */\n  enabled: boolean;\n\n  /** Interval in seconds between validation runs (default: 300 = 5 minutes) */\n  intervalSeconds: number;\n\n  /** Maximum number of memories to process per batch (default: 10) */\n  batchSize: number;\n\n  /** Maximum time in ms for a single validation operation (default: 5000) */\n  validationTimeoutMs: number;\n}\n\n/**\n * Default configuration for background validation\n */\nconst DEFAULT_CONFIG: BackgroundValidatorConfig = {\n  enabled: true,\n  intervalSeconds: 300,  // 5 minutes\n  batchSize: 10,\n  validationTimeoutMs: 5000,\n};\n\n/**\n * Pattern information for encrypted storage\n */\nexport interface SanitizedPattern {\n  /** Unique reference ID for this pattern */\n  ref: string;\n\n  /** Human-readable description of the pattern */\n  description: string;\n\n  /** Severity level of the pattern */\n  severity: 'critical' | 'high' | 'medium' | 'low';\n\n  /** Location in original content (offset and length) */\n  location: string;\n\n  /** Encrypted pattern (AES-256-GCM) - Phase 2 */\n  encryptedPattern?: string;\n\n  /** Encryption algorithm used - Phase 2 */\n  algorithm?: string;\n\n  /** Initialization vector for decryption - Phase 2 */\n  iv?: string;\n\n  /** GCM authentication tag for integrity verification - Phase 2 */\n  authTag?: string;\n\n  /** Safety instruction for pattern usage */\n  safetyInstruction: string;\n}\n\n/**\n * Background validation service for memory entries\n *\n * This service runs outside the LLM request path to validate UNTRUSTED\n * memory entries and update their trust levels based on security analysis.\n *\n * REFACTOR NOTE:\n * Converted to full DI architecture. Removed singleton export.\n * PatternExtractor is now injected as a dependency instead of static calls.\n */\nexport class BackgroundValidator {\n  private readonly config: BackgroundValidatorConfig;\n  private intervalHandle?: NodeJS.Timeout;\n  private isProcessing: boolean = false;\n\n  constructor(\n    private readonly patternExtractor: PatternExtractor,\n    private readonly memoryManager: any, // MemoryManager - using any to avoid circular import\n    config?: Partial<BackgroundValidatorConfig>\n  ) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n    logger.info('BackgroundValidator initialized', {\n      enabled: this.config.enabled,\n      intervalSeconds: this.config.intervalSeconds,\n      batchSize: this.config.batchSize,\n    });\n  }\n\n  /**\n   * Start the background validation service\n   * Begins periodic validation of UNTRUSTED memories\n   */\n  start(): void {\n    if (!this.config.enabled) {\n      logger.info('Background validation disabled in config');\n      return;\n    }\n\n    if (this.intervalHandle) {\n      logger.warn('Background validation already running');\n      return;\n    }\n\n    logger.info('Starting background validation service', {\n      intervalSeconds: this.config.intervalSeconds,\n    });\n\n    // Run immediately on start\n    void this.processUntrustedMemories();\n\n    // Then run periodically\n    this.intervalHandle = setInterval(() => {\n      void this.processUntrustedMemories();\n    }, this.config.intervalSeconds * 1000);\n  }\n\n  /**\n   * Stop the background validation service\n   */\n  stop(): void {\n    if (this.intervalHandle) {\n      clearInterval(this.intervalHandle);\n      this.intervalHandle = undefined;\n      logger.info('Background validation service stopped');\n    }\n  }\n\n  /**\n   * Process all UNTRUSTED memory entries\n   * This is the main background validation loop\n   */\n  async processUntrustedMemories(): Promise<void> {\n    if (this.isProcessing) {\n      logger.debug('Validation already in progress, skipping this run');\n      return;\n    }\n\n    this.isProcessing = true;\n\n    try {\n      // PHASE 1 INCOMPLETE: Memory discovery integration pending\n      // Issue #1314 Phase 1 - This will be connected to Memory loading system\n      // in a follow-up PR once Memory.find() API is available\n      const untrustedMemories = await this.findMemoriesWithUntrustedEntries();\n\n      if (untrustedMemories.length === 0) {\n        return;\n      }\n\n      logger.info('Found untrusted memories to validate', {\n        count: untrustedMemories.length,\n        batchSize: this.config.batchSize,\n      });\n\n      // Process in batches\n      const batches = this.createBatches(untrustedMemories, this.config.batchSize);\n\n      for (const batch of batches) {\n        await this.processBatch(batch);\n      }\n\n      logger.info('Validation pass complete');\n    } catch (error) {\n      logger.error('Error during background validation', { error });\n    } finally {\n      this.isProcessing = false;\n    }\n  }\n\n  /**\n   * Find all memories that have UNTRUSTED entries\n   *\n   * DI REFACTOR: Use injected MemoryManager instead of static Memory methods\n   * Loads memories from filesystem and filters by trust level\n   */\n  private async findMemoriesWithUntrustedEntries(): Promise<Memory[]> {\n    // Load all memories using the injected MemoryManager\n    const allMemories = await this.memoryManager.list();\n\n    // Filter to only memories with UNTRUSTED entries\n    const untrustedMemories: Memory[] = [];\n    const limit = this.config.batchSize * 10;\n\n    for (const memory of allMemories) {\n      const hasUntrustedEntries = memory.getEntriesByTrustLevel(TRUST_LEVELS.UNTRUSTED).length > 0;\n      if (hasUntrustedEntries) {\n        untrustedMemories.push(memory);\n\n        // Apply limit\n        if (untrustedMemories.length >= limit) {\n          break;\n        }\n      }\n    }\n\n    if (untrustedMemories.length > 0) {\n      logger.debug('Found memories with untrusted entries', {\n        count: untrustedMemories.length,\n        limit\n      });\n    }\n\n    return untrustedMemories;\n  }\n\n  /**\n   * Process a batch of memories for validation\n   */\n  private async processBatch(memories: Memory[]): Promise<void> {\n    logger.debug('Processing batch', { size: memories.length });\n\n    for (const memory of memories) {\n      try {\n        await this.validateMemory(memory);\n      } catch (error) {\n        logger.error('Error validating memory', {\n          memoryId: memory.id,\n          error,\n        });\n      }\n    }\n  }\n\n  /**\n   * Validate all UNTRUSTED entries in a memory\n   * FIX #1320: Now uses public Memory API and saves changes\n   * FIX (Claude Bot Review): Removed type casting for memory.id\n   */\n  private async validateMemory(memory: Memory): Promise<void> {\n    logger.debug('Validating memory', { memoryId: memory.id });\n\n    let updatedCount = 0;\n\n    // FIX #1320: Use public API instead of casting to any\n    const entries = memory.getEntriesByTrustLevel(TRUST_LEVELS.UNTRUSTED);\n\n    for (const entry of entries) {\n      try {\n        const updated = await this.validateEntry(entry);\n        if (updated) {\n          updatedCount++;\n        }\n      } catch (error) {\n        logger.error('Error validating entry', {\n          entryId: entry.id,\n          error,\n        });\n      }\n    }\n\n    if (updatedCount > 0) {\n      logger.info('Updated trust levels in memory', {\n        memoryId: memory.id,\n        updatedCount,\n      });\n\n      // DI REFACTOR: Use injected MemoryManager to save\n      try {\n        await this.memoryManager.save(memory);\n        logger.debug('Memory saved successfully', {\n          memoryId: memory.id\n        });\n      } catch (error) {\n        logger.error('Failed to save memory after validation', {\n          memoryId: memory.id,\n          error\n        });\n        // Don't throw - continue with other memories\n      }\n    }\n  }\n\n  /**\n   * Validate a single memory entry and update its trust level\n   *\n   * @param entry - The memory entry to validate\n   * @returns true if the entry was updated, false otherwise\n   */\n  private async validateEntry(entry: any): Promise<boolean> {\n    logger.debug('Validating entry', { entryId: entry.id });\n\n    // Validate content using ContentValidator\n    const validationResult = ContentValidator.validateAndSanitize(entry.content, {\n      skipSizeCheck: true,\n    });\n\n    // Determine new trust level based on validation results\n    const newTrustLevel = this.determineTrustLevel(validationResult);\n\n    if (newTrustLevel === entry.trustLevel) {\n      logger.debug('Trust level unchanged', {\n        entryId: entry.id,\n        trustLevel: entry.trustLevel,\n      });\n      return false;\n    }\n\n    // Update trust level\n    entry.trustLevel = newTrustLevel;\n\n    logger.info('Updated entry trust level', {\n      entryId: entry.id,\n      oldTrustLevel: TRUST_LEVELS.UNTRUSTED,\n      newTrustLevel,\n      detectedPatterns: validationResult.detectedPatterns?.length || 0,\n    });\n\n    // If FLAGGED, extract patterns and create sanitized content\n    if (newTrustLevel === TRUST_LEVELS.FLAGGED) {\n      logger.debug('Entry flagged, extracting patterns', {\n        entryId: entry.id,\n        patterns: validationResult.detectedPatterns,\n      });\n\n      // Phase 1: Extract patterns and create sanitized content\n      const extractionResult = this.patternExtractor.extractPatterns(\n        entry.content,\n        validationResult\n      );\n\n      // Store sanitized patterns and content in entry metadata\n      // Phase 2 will add encryption to these patterns\n      entry.sanitizedPatterns = extractionResult.patterns;\n      entry.sanitizedContent = extractionResult.sanitizedContent;\n\n      logger.info('Patterns extracted from entry', {\n        entryId: entry.id,\n        patternCount: extractionResult.patternCount,\n      });\n    }\n\n    return true;\n  }\n\n  /**\n   * Determine the appropriate trust level based on validation results\n   */\n  private determineTrustLevel(validationResult: ContentValidationResult): string {\n    // If validation passed with no patterns, mark as VALIDATED\n    if (validationResult.isValid && (!validationResult.detectedPatterns || validationResult.detectedPatterns.length === 0)) {\n      return TRUST_LEVELS.VALIDATED;\n    }\n\n    // If critical/high severity threats detected, mark as FLAGGED\n    if (validationResult.severity === 'critical' || validationResult.severity === 'high') {\n      // PHASE 1 INCOMPLETE: QUARANTINED trust level logic deferred (Issue #1314)\n      // Will add distinction between FLAGGED (dangerous) vs QUARANTINED (malicious)\n      // For now, all high/critical severity goes to FLAGGED\n      return TRUST_LEVELS.FLAGGED;\n    }\n\n    // Medium/low severity or minor issues - keep as UNTRUSTED for now\n    // (Could be VALIDATED in a more lenient policy)\n    return TRUST_LEVELS.UNTRUSTED;\n  }\n\n  /**\n   * Split an array into batches of specified size\n   */\n  private createBatches<T>(items: T[], batchSize: number): T[][] {\n    const batches: T[][] = [];\n    for (let i = 0; i < items.length; i += batchSize) {\n      batches.push(items.slice(i, i + batchSize));\n    }\n    return batches;\n  }\n\n  /**\n   * Get current validation statistics\n   */\n  getStats() {\n    return {\n      enabled: this.config.enabled,\n      isProcessing: this.isProcessing,\n      intervalSeconds: this.config.intervalSeconds,\n      batchSize: this.config.batchSize,\n    };\n  }\n\n  /**\n   * Dispose of the validator and clean up resources\n   * Implements cleanup for proper DI lifecycle management\n   */\n  async dispose(): Promise<void> {\n    this.stop();\n    logger.debug('BackgroundValidator disposed');\n  }\n}\n"]}