@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.
128 lines • 5.4 kB
TypeScript
/**
* RetentionPolicyService - Generic retention policy enforcement (Issue #51)
*
* This service manages retention policies across ALL element types, ensuring that:
* 1. Nothing is auto-deleted without explicit user consent
* 2. Users have full visibility into what would be deleted
* 3. Each element type can have its own retention strategy
* 4. Compliance use cases (legal, GDPR, etc.) are supported when enabled
*
* IMPORTANT: Retention enforcement is DISABLED by default.
* Users must explicitly enable it in config.yml if they want automatic cleanup.
*
* Architecture:
* - This service is element-type agnostic
* - Element-specific logic is delegated to IRetentionStrategy implementations
* - Strategies are registered per element type
* - Designed to support 50+ element types
*
* @module RetentionPolicyService
*/
import { ConfigManager, RetentionPolicyConfig } from '../../config/ConfigManager.js';
import { ElementType } from '../../portfolio/types.js';
import { IRetentionStrategy, IRetainableItem, ElementRetentionConfig, RetentionEnforcementResult, RetentionSummary, EnforcementOptions } from './types.js';
/**
* Generic retention policy service supporting multiple element types
*/
export declare class RetentionPolicyService {
private configManager;
private strategies;
constructor(configManager: ConfigManager);
/**
* Register a retention strategy for an element type
* Call this during DI setup for each element type that supports retention
*/
registerStrategy(strategy: IRetentionStrategy): void;
/**
* Get the strategy for an element type
*/
getStrategy(elementType: ElementType | string): IRetentionStrategy | undefined;
/**
* Get registered element types
*/
getRegisteredTypes(): string[];
/**
* Get the global retention policy configuration
*/
getGlobalConfig(): RetentionPolicyConfig;
/**
* Get retention configuration for a specific element type
* Merges global defaults with any type-specific overrides
*/
getElementConfig(elementType: ElementType | string): ElementRetentionConfig;
/**
* Check if retention enforcement is globally enabled
*/
isEnabled(): boolean;
/**
* Check if enforcement should happen on load for a given element type
*/
shouldEnforceOnLoad(elementType?: ElementType | string): boolean;
/**
* Check if enforcement requires confirmation
*/
requiresConfirmation(): boolean;
/**
* Check if dry run should be performed first
*/
shouldDryRunFirst(): boolean;
/**
* Check items for retention status without modifying anything
* Works with any element type that has a registered strategy
*/
checkItems<T extends IRetainableItem>(elementType: ElementType | string, items: Map<string, T>): RetentionSummary;
/**
* Preview what would be deleted (dry run)
* Works with any element type
*/
preview(elementType: ElementType | string, element: unknown): RetentionEnforcementResult;
/**
* Enforce retention policy on an element
* Works with any element type that has a registered strategy
*
* @param elementType - The type of element (e.g., 'memory', 'agent')
* @param element - The element instance to enforce retention on
* @param options - Enforcement options including force, failFast, and callbacks
* @returns Result including items checked/removed, affected items, and any warnings
*
* ## Partial Failure Behavior
*
* By default, the method continues processing after individual item removal failures:
* - Failed items are logged and added to `result.warnings[]`
* - Successfully removed items are counted in `result.itemsRemoved`
* - `result.success` remains true unless all items fail
*
* This allows maximum cleanup even when some items cannot be removed (e.g., file locks).
*
* ### Atomic Mode (failFast: true)
*
* For scenarios requiring all-or-nothing behavior, use `options.failFast: true`:
* - Stops immediately on first removal error
* - Sets `result.success = false` and `result.error` with details
* - No further items are processed after the failure
*
* **WARNING**: With failFast, any items removed before the failure will NOT be rolled back.
* True transactional semantics are not supported.
*
* @example
* // Default: continue on errors
* const result = await service.enforce('memory', myMemory, { force: true });
* if (result.warnings.length > 0) console.log('Some items failed:', result.warnings);
*
* @example
* // Fail fast: stop on first error
* const result = await service.enforce('memory', myMemory, { force: true, failFast: true });
* if (!result.success) console.log('Failed:', result.error);
*/
enforce(elementType: ElementType | string, element: unknown, options?: EnforcementOptions): Promise<RetentionEnforcementResult>;
/**
* Get a human-readable status message about retention
*/
getStatusMessage(elementType?: ElementType | string): string;
/**
* Normalize element type to consistent string key
* SECURITY: Applies Unicode normalization to prevent bypass attacks
*/
private normalizeElementType;
}
//# sourceMappingURL=RetentionPolicyService.d.ts.map