@od-oneapp/config 2026.2.2001-canary.1

package/typescript/dist/src/server/resource-lifecycle-manager.js

@@ -0,0 +1,839 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { EventEmitter } from 'node:events';
+import { logDebug, logError } from '@repo/shared/logs';
+import { globalAdvancedMemoryMonitor } from './advanced-memory-monitor';
+import { ErrorPatterns } from './error-handling';
+export class ResourceLifecycleManager extends EventEmitter {
+    resources = new Map();
+    cleanupCallbacks = new Map();
+    weakRefs = new Map();
+    finalizationRegistry;
+    hooks = {};
+    cleanupStrategies = [];
+    leakPatterns = [];
+    asyncLocalStorage = new AsyncLocalStorage();
+    monitoringInterval = null;
+    isMonitoring = false;
+    lastCleanupCheck = 0;
+    cleanupCheckInterval = 60000;
+    stats = {
+        totalCreated: 0,
+        totalCleaned: 0,
+        totalLeaks: 0,
+        cleanupFailures: 0,
+        averageLifetime: 0,
+    };
+    constructor(options = {}) {
+        super();
+        this.hooks = options.hooks ?? {};
+        this.cleanupCheckInterval = options.cleanupInterval ?? 60000;
+        this.finalizationRegistry = new FinalizationRegistry((resourceId) => {
+            this.handleResourceFinalization(resourceId);
+        });
+        this.initializeDefaultStrategies();
+        this.initializeLeakPatterns();
+        if (options.enableMonitoring !== false) {
+            this.startMonitoring();
+        }
+    }
+    initializeDefaultStrategies() {
+        this.addCleanupStrategy({
+            name: 'age-based',
+            description: 'Clean up resources older than threshold',
+            condition: resource => {
+                const age = Date.now() - resource.createdAt;
+                const maxAge = this.getMaxAgeForPriority(resource.priority);
+                return age > maxAge;
+            },
+            priority: 3,
+            action: async (resource) => {
+                logDebug(`Age-based cleanup for resource ${resource.id}`, {
+                    resourceId: resource.id,
+                    resourceType: resource.type,
+                });
+            },
+        });
+        this.addCleanupStrategy({
+            name: 'inactivity-based',
+            description: 'Clean up inactive resources',
+            condition: resource => {
+                const inactivity = Date.now() - resource.lastUsed;
+                const maxInactivity = this.getMaxInactivityForPriority(resource.priority);
+                return inactivity > maxInactivity;
+            },
+            priority: 2,
+            action: async (resource) => {
+                logDebug(`Inactivity-based cleanup for resource ${resource.id}`, {
+                    resourceId: resource.id,
+                    resourceType: resource.type,
+                });
+            },
+        });
+        this.addCleanupStrategy({
+            name: 'memory-pressure',
+            description: 'Clean up resources during high memory pressure',
+            condition: resource => {
+                const pressure = globalAdvancedMemoryMonitor.getMemoryPressure();
+                if (pressure.level === 'critical' || pressure.level === 'emergency') {
+                    return resource.priority !== 'critical';
+                }
+                if (pressure.level === 'high') {
+                    return resource.priority === 'low';
+                }
+                return false;
+            },
+            priority: 1,
+            action: async (resource) => {
+                logDebug(`Memory pressure cleanup for resource ${resource.id}`, {
+                    resourceId: resource.id,
+                    resourceType: resource.type,
+                });
+            },
+        });
+        this.addCleanupStrategy({
+            name: 'orphaned-dependencies',
+            description: 'Clean up resources with no active dependencies',
+            condition: resource => {
+                if (resource.dependencies.length === 0)
+                    return false;
+                return resource.dependencies.every(depId => !this.resources.has(depId));
+            },
+            priority: 4,
+            action: async (resource) => {
+                logDebug(`Orphaned dependency cleanup for resource ${resource.id}`, {
+                    resourceId: resource.id,
+                    resourceType: resource.type,
+                });
+            },
+        });
+    }
+    initializeLeakPatterns() {
+        this.leakPatterns.push({
+            pattern: 'long-lived-inactive',
+            description: "Resources that are old and haven't been used recently",
+            severity: 'medium',
+            detectionLogic: (resources) => {
+                return resources.some(r => {
+                    const age = Date.now() - r.createdAt;
+                    const inactivity = Date.now() - r.lastUsed;
+                    return age > 3600000 && inactivity > 1800000;
+                });
+            },
+            recommendedAction: 'Review resource usage patterns and implement proper cleanup',
+        });
+        const detectCircularDeps = resources => {
+            return this.detectCircularDependencies(resources);
+        };
+        this.leakPatterns.push({
+            pattern: 'circular-dependencies',
+            description: 'Resources with circular dependency chains',
+            severity: 'high',
+            detectionLogic: detectCircularDeps,
+            recommendedAction: 'Break circular dependencies or implement WeakRef patterns',
+        });
+        this.leakPatterns.push({
+            pattern: 'exponential-growth',
+            description: 'Rapid increase in resource count of same type',
+            severity: 'critical',
+            detectionLogic: (resources) => {
+                const typeGroups = this.groupResourcesByType(resources);
+                return Object.values(typeGroups).some(group => group.length > 100);
+            },
+            recommendedAction: 'Implement resource pooling or stricter cleanup policies',
+        });
+        this.leakPatterns.push({
+            pattern: 'memory-heavy-accumulation',
+            description: 'Accumulation of large resources',
+            severity: 'high',
+            detectionLogic: (resources) => {
+                const totalSize = resources.reduce((sum, r) => sum + r.size, 0);
+                const largeResources = resources.filter(r => r.size > 10 * 1024 * 1024);
+                return largeResources.length > 5 || totalSize > 100 * 1024 * 1024;
+            },
+            recommendedAction: 'Implement streaming or pagination for large data resources',
+        });
+    }
+    registerResource(object, metadata, cleanupCallbacks) {
+        const id = `${metadata.type}-${Date.now()}-${crypto.randomUUID().substring(0, 8)}`;
+        const resource = {
+            ...metadata,
+            id,
+            createdAt: Date.now(),
+            lastUsed: Date.now(),
+            dependents: [],
+        };
+        this.resources.set(id, resource);
+        if (cleanupCallbacks && cleanupCallbacks.length > 0) {
+            this.cleanupCallbacks.set(id, cleanupCallbacks);
+        }
+        this.weakRefs.set(id, new WeakRef(object));
+        this.finalizationRegistry.register(object, id, object);
+        globalAdvancedMemoryMonitor.trackObject(object, `lifecycle-${metadata.type}`, {
+            resourceId: id,
+            resourceType: metadata.type,
+            resourceName: metadata.name,
+        });
+        for (const depId of resource.dependencies) {
+            const dep = this.resources.get(depId);
+            if (dep) {
+                dep.dependents.push(id);
+            }
+        }
+        this.stats.totalCreated++;
+        if (this.hooks.onResourceCreated) {
+            this.hooks.onResourceCreated(resource);
+        }
+        this.emit('resourceCreated', resource);
+        return id;
+    }
+    touchResource(resourceId) {
+        const resource = this.resources.get(resourceId);
+        if (!resource)
+            return false;
+        resource.lastUsed = Date.now();
+        if (this.hooks.onResourceAccessed) {
+            this.hooks.onResourceAccessed(resource);
+        }
+        this.emit('resourceAccessed', resource);
+        return true;
+    }
+    updateResource(resourceId, changes) {
+        const resource = this.resources.get(resourceId);
+        if (!resource)
+            return false;
+        const immutableFields = ['id', 'createdAt'];
+        const allowedChanges = Object.fromEntries(Object.entries(changes).filter(([key]) => !immutableFields.includes(key)));
+        Object.assign(resource, allowedChanges);
+        if (this.hooks.onResourceUpdated) {
+            this.hooks.onResourceUpdated(resource, allowedChanges);
+        }
+        this.emit('resourceUpdated', resource, allowedChanges);
+        return true;
+    }
+    getResource(resourceId) {
+        return this.resources.get(resourceId);
+    }
+    getResourcesByType(type) {
+        return Array.from(this.resources.values()).filter(r => r.type === type);
+    }
+    getResourcesByTags(tags) {
+        return Array.from(this.resources.values()).filter(resource => tags.some(tag => resource.tags.includes(tag)));
+    }
+    startMonitoring() {
+        if (this.isMonitoring)
+            return;
+        this.isMonitoring = true;
+        this.monitoringInterval = setInterval(() => {
+            void this.performMonitoringCycle().catch(error => {
+                logError('[ResourceLifecycleManager] Monitoring cycle error', { error });
+            });
+        }, this.cleanupCheckInterval);
+        this.monitoringInterval.unref();
+        logDebug('Resource lifecycle monitoring started');
+    }
+    stopMonitoring() {
+        if (!this.isMonitoring)
+            return;
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+            this.monitoringInterval = null;
+        }
+        this.isMonitoring = false;
+        logDebug('Resource lifecycle monitoring stopped');
+    }
+    async performMonitoringCycle() {
+        const now = Date.now();
+        if (now - this.lastCleanupCheck < this.cleanupCheckInterval * 0.5) {
+            return;
+        }
+        this.lastCleanupCheck = now;
+        try {
+            await this.cleanupDeadReferences();
+            await this.detectLeaks();
+            await this.applyCleanupStrategies();
+            this.updateStatistics();
+        }
+        catch (error) {
+            logError('Error in resource monitoring cycle', { error });
+            this.emit('monitoringError', error);
+        }
+    }
+    async cleanupDeadReferences() {
+        let cleaned = 0;
+        for (const [resourceId, weakRef] of this.weakRefs.entries()) {
+            if (weakRef.deref() === undefined) {
+                await this.cleanupResource(resourceId, 'garbage-collected');
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            logDebug(`Cleaned up ${cleaned} dead resource references`, { cleanedCount: cleaned });
+        }
+    }
+    async detectLeaks() {
+        const resources = Array.from(this.resources.values());
+        const detectedLeaks = [];
+        for (const pattern of this.leakPatterns) {
+            if (pattern.detectionLogic(resources)) {
+                const matchingResources = this.findResourcesMatchingPattern(pattern, resources);
+                for (const resource of matchingResources) {
+                    const leak = {
+                        resourceId: resource.id,
+                        pattern: pattern.pattern,
+                        severity: pattern.severity,
+                        description: pattern.description,
+                        detectedAt: Date.now(),
+                        ageMs: Date.now() - resource.createdAt,
+                        inactivityMs: Date.now() - resource.lastUsed,
+                        suspectedCause: this.determineSuspectedCause(resource),
+                        recommendedAction: pattern.recommendedAction,
+                    };
+                    detectedLeaks.push(leak);
+                    if (this.hooks.onLeakDetected) {
+                        void this.hooks.onLeakDetected(leak);
+                    }
+                    this.emit('leakDetected', leak);
+                }
+            }
+        }
+        this.stats.totalLeaks += detectedLeaks.length;
+    }
+    findResourcesMatchingPattern(pattern, resources) {
+        const now = Date.now();
+        switch (pattern.pattern) {
+            case 'long-lived-inactive':
+                return resources.filter(r => {
+                    const age = now - r.createdAt;
+                    const inactivity = now - r.lastUsed;
+                    return age > 3600000 && inactivity > 1800000;
+                });
+            case 'memory-heavy-accumulation':
+                return resources.filter(r => r.size > 10 * 1024 * 1024);
+            default:
+                return [];
+        }
+    }
+    determineSuspectedCause(resource) {
+        const age = Date.now() - resource.createdAt;
+        const inactivity = Date.now() - resource.lastUsed;
+        if (inactivity > age * 0.9) {
+            return 'Resource created but rarely used - possible over-allocation';
+        }
+        if (resource.dependencies.length > 0) {
+            return 'Resource with dependencies not properly cleaned up';
+        }
+        if (resource.size > 5 * 1024 * 1024) {
+            return 'Large resource not released - possible memory leak';
+        }
+        return 'Long-lived resource without recent activity';
+    }
+    async applyCleanupStrategies() {
+        const resources = Array.from(this.resources.values());
+        const sortedStrategies = [...this.cleanupStrategies].sort((a, b) => a.priority - b.priority);
+        for (const strategy of sortedStrategies) {
+            const candidateResources = resources.filter(strategy.condition);
+            for (const resource of candidateResources) {
+                try {
+                    await strategy.action(resource);
+                    await this.cleanupResource(resource.id, strategy.name);
+                }
+                catch (error) {
+                    logError(`Cleanup strategy '${strategy.name}' failed for resource ${resource.id}`, {
+                        error,
+                        strategyName: strategy.name,
+                        resourceId: resource.id,
+                    });
+                    this.stats.cleanupFailures++;
+                    if (this.hooks.onCleanupFailed) {
+                        void this.hooks.onCleanupFailed(resource, error);
+                    }
+                }
+            }
+        }
+    }
+    async cleanupResource(resourceId, reason) {
+        const resource = this.resources.get(resourceId);
+        if (!resource)
+            return;
+        try {
+            const callbacks = this.cleanupCallbacks.get(resourceId);
+            if (callbacks) {
+                for (const callback of callbacks) {
+                    await callback(resource);
+                }
+            }
+            for (const dependentId of resource.dependents) {
+                await this.cleanupResource(dependentId, `dependency-${reason}`);
+            }
+            this.resources.delete(resourceId);
+            this.cleanupCallbacks.delete(resourceId);
+            this.weakRefs.delete(resourceId);
+            this.stats.totalCleaned++;
+            const lifetime = Date.now() - resource.createdAt;
+            const previousAverage = this.stats.averageLifetime;
+            const previousCount = this.stats.totalCleaned - 1;
+            const numerator = previousAverage * previousCount + lifetime;
+            const denominator = this.stats.totalCleaned;
+            const newAverage = numerator / denominator;
+            this.stats.averageLifetime = newAverage;
+            if (this.hooks.onResourceCleaned) {
+                void this.hooks.onResourceCleaned(resource);
+            }
+            this.emit('resourceCleaned', resource, reason);
+            logDebug(`Resource ${resourceId} cleaned up`, {
+                resourceId,
+                resourceType: resource.type,
+                reason,
+            });
+        }
+        catch (error) {
+            logError(`Failed to cleanup resource ${resourceId}`, { error, resourceId, reason });
+            this.stats.cleanupFailures++;
+        }
+    }
+    handleResourceFinalization(resourceId) {
+        void this.cleanupResource(resourceId, 'finalization');
+    }
+    updateStatistics() {
+        const activeResources = Array.from(this.resources.values());
+        if (activeResources.length > 0) {
+            const now = Date.now();
+            const totalLifetime = activeResources.reduce((sum, r) => sum + (now - r.createdAt), 0);
+            const currentAverageLifetime = totalLifetime / activeResources.length;
+            this.stats.averageLifetime = this.stats.averageLifetime * 0.8 + currentAverageLifetime * 0.2;
+        }
+    }
+    detectCircularDependencies(resources) {
+        const visited = new Set();
+        const recursionStack = new Set();
+        const hasCycle = (resourceId) => {
+            if (recursionStack.has(resourceId))
+                return true;
+            if (visited.has(resourceId))
+                return false;
+            visited.add(resourceId);
+            recursionStack.add(resourceId);
+            const resource = this.resources.get(resourceId);
+            if (resource) {
+                for (const depId of resource.dependencies) {
+                    if (hasCycle(depId))
+                        return true;
+                }
+            }
+            recursionStack.delete(resourceId);
+            return false;
+        };
+        return resources.some(resource => hasCycle(resource.id));
+    }
+    groupResourcesByType(resources) {
+        return resources.reduce((groups, resource) => {
+            const { type } = resource;
+            if (!groups[type]) {
+                groups[type] = [];
+            }
+            groups[type].push(resource);
+            return groups;
+        }, {});
+    }
+    getMaxAgeForPriority(priority) {
+        switch (priority) {
+            case 'low':
+                return 1800000;
+            case 'medium':
+                return 3600000;
+            case 'high':
+                return 7200000;
+            case 'critical':
+                return 86400000;
+            default:
+                return 3600000;
+        }
+    }
+    getMaxInactivityForPriority(priority) {
+        switch (priority) {
+            case 'low':
+                return 600000;
+            case 'medium':
+                return 1800000;
+            case 'high':
+                return 3600000;
+            case 'critical':
+                return 7200000;
+            default:
+                return 1800000;
+        }
+    }
+    addCleanupStrategy(strategy) {
+        this.cleanupStrategies.push(strategy);
+    }
+    addLeakPattern(pattern) {
+        this.leakPatterns.push(pattern);
+    }
+    async forceCleanup(criteria = {}) {
+        const resources = Array.from(this.resources.values());
+        const toCleanup = [];
+        const now = Date.now();
+        for (const resource of resources) {
+            let shouldCleanup = true;
+            if (criteria.type && resource.type !== criteria.type) {
+                shouldCleanup = false;
+            }
+            if (criteria.tags && !criteria.tags.some(tag => resource.tags.includes(tag))) {
+                shouldCleanup = false;
+            }
+            if (criteria.olderThan && now - resource.createdAt < criteria.olderThan) {
+                shouldCleanup = false;
+            }
+            if (criteria.inactiveLongerThan && now - resource.lastUsed < criteria.inactiveLongerThan) {
+                shouldCleanup = false;
+            }
+            if (criteria.priority && resource.priority !== criteria.priority) {
+                shouldCleanup = false;
+            }
+            if (shouldCleanup) {
+                toCleanup.push(resource);
+            }
+        }
+        let cleaned = 0;
+        let failed = 0;
+        const errors = [];
+        for (const resource of toCleanup) {
+            try {
+                await this.cleanupResource(resource.id, 'forced-cleanup');
+                cleaned++;
+            }
+            catch (error) {
+                failed++;
+                errors.push(`${resource.id}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        return { cleaned, failed, errors };
+    }
+    getStatistics() {
+        const resources = Array.from(this.resources.values());
+        const now = Date.now();
+        const byType = {};
+        const byPriority = {};
+        let totalAge = 0;
+        let totalInactivity = 0;
+        let totalSize = 0;
+        for (const resource of resources) {
+            byType[resource.type] = (byType[resource.type] || 0) + 1;
+            byPriority[resource.priority] = (byPriority[resource.priority] || 0) + 1;
+            totalAge += now - resource.createdAt;
+            totalInactivity += now - resource.lastUsed;
+            totalSize += resource.size;
+        }
+        const leakPatternMatches = this.leakPatterns.map(pattern => ({
+            pattern: pattern.pattern,
+            matches: this.findResourcesMatchingPattern(pattern, resources).length,
+        }));
+        return {
+            resources: {
+                total: resources.length,
+                byType,
+                byPriority,
+                averageAge: resources.length > 0 ? totalAge / resources.length : 0,
+                averageInactivity: resources.length > 0 ? totalInactivity / resources.length : 0,
+                totalSize,
+            },
+            lifecycle: { ...this.stats },
+            leakPatterns: leakPatternMatches,
+        };
+    }
+    async dispose() {
+        this.stopMonitoring();
+        await this.forceCleanup();
+        this.resources.clear();
+        this.cleanupCallbacks.clear();
+        this.weakRefs.clear();
+        this.removeAllListeners();
+        logDebug('Resource lifecycle manager disposed');
+    }
+}
+export const globalResourceLifecycleManager = new ResourceLifecycleManager({
+    enableMonitoring: true,
+});
+export const resourceLifecycleManagerTool = {
+    name: 'resource_lifecycle_manager',
+    description: 'Advanced resource lifecycle management with leak detection and automatic cleanup',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'register',
+                    'touch',
+                    'update',
+                    'get',
+                    'getByType',
+                    'getByTags',
+                    'startMonitoring',
+                    'stopMonitoring',
+                    'forceCleanup',
+                    'getStatistics',
+                ],
+                description: 'Action to perform',
+            },
+            resourceId: {
+                type: 'string',
+                description: 'Resource ID for operations on specific resources',
+            },
+            objectType: {
+                type: 'string',
+                description: 'Type of resource being registered',
+            },
+            resourceName: {
+                type: 'string',
+                description: 'Name of the resource',
+            },
+            size: {
+                type: 'number',
+                description: 'Size of the resource in bytes',
+            },
+            priority: {
+                type: 'string',
+                enum: ['low', 'medium', 'high', 'critical'],
+                description: 'Priority of the resource',
+            },
+            tags: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Tags for the resource',
+            },
+            metadata: {
+                type: 'object',
+                description: 'Additional metadata for the resource',
+            },
+            dependencies: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Resource IDs this resource depends on',
+            },
+            changes: {
+                type: 'object',
+                description: 'Changes to apply to the resource',
+            },
+            type: {
+                type: 'string',
+                description: 'Resource type to query',
+            },
+            queryTags: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Tags to query for',
+            },
+            cleanupCriteria: {
+                type: 'object',
+                description: 'Criteria for forced cleanup',
+            },
+        },
+        required: ['action'],
+    },
+    async execute(args) {
+        try {
+            const { action } = args;
+            switch (action) {
+                case 'register': {
+                    if (!args.objectType || !args.resourceName) {
+                        throw new Error('objectType and resourceName are required for register action');
+                    }
+                    const dummyObject = {
+                        type: args.objectType,
+                        name: args.resourceName,
+                        timestamp: Date.now(),
+                    };
+                    const resourceId = globalResourceLifecycleManager.registerResource(dummyObject, {
+                        type: args.objectType,
+                        name: args.resourceName,
+                        size: args.size ?? 0,
+                        priority: args.priority ?? 'medium',
+                        tags: args.tags ?? [],
+                        metadata: args.metadata ?? {},
+                        dependencies: args.dependencies ?? [],
+                    });
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    resourceId,
+                                    message: `Resource registered: ${args.resourceName} (${args.objectType})`,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'touch': {
+                    if (!args.resourceId) {
+                        throw new Error('resourceId is required for touch action');
+                    }
+                    const touched = globalResourceLifecycleManager.touchResource(args.resourceId);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: touched,
+                                    resourceId: args.resourceId,
+                                    message: touched ? 'Resource touched' : 'Resource not found',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'update': {
+                    if (!args.resourceId || !args.changes) {
+                        throw new Error('resourceId and changes are required for update action');
+                    }
+                    const updated = globalResourceLifecycleManager.updateResource(args.resourceId, args.changes);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: updated,
+                                    resourceId: args.resourceId,
+                                    changes: args.changes,
+                                    message: updated ? 'Resource updated' : 'Resource not found',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'get': {
+                    if (!args.resourceId) {
+                        throw new Error('resourceId is required for get action');
+                    }
+                    const resource = globalResourceLifecycleManager.getResource(args.resourceId);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    found: resource !== undefined,
+                                    resource,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'getByType': {
+                    if (!args.type) {
+                        throw new Error('type is required for getByType action');
+                    }
+                    const resources = globalResourceLifecycleManager.getResourcesByType(args.type);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    type: args.type,
+                                    count: resources.length,
+                                    resources,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'getByTags': {
+                    if (!args.queryTags) {
+                        throw new Error('queryTags is required for getByTags action');
+                    }
+                    const resources = globalResourceLifecycleManager.getResourcesByTags(args.queryTags);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    tags: args.queryTags,
+                                    count: resources.length,
+                                    resources,
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'startMonitoring': {
+                    globalResourceLifecycleManager.startMonitoring();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    message: 'Resource lifecycle monitoring started',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'stopMonitoring': {
+                    globalResourceLifecycleManager.stopMonitoring();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    message: 'Resource lifecycle monitoring stopped',
+                                }),
+                            },
+                        ],
+                    };
+                }
+                case 'forceCleanup': {
+                    const result = await globalResourceLifecycleManager.forceCleanup(args.cleanupCriteria ?? {});
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(result),
+                            },
+                        ],
+                    };
+                }
+                case 'getStatistics': {
+                    const statistics = globalResourceLifecycleManager.getStatistics();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(statistics),
+                            },
+                        ],
+                    };
+                }
+                default:
+                    throw ErrorPatterns.unknownAction(action, [
+                        'register',
+                        'touch',
+                        'update',
+                        'get',
+                        'getByType',
+                        'getByTags',
+                        'startMonitoring',
+                        'stopMonitoring',
+                        'forceCleanup',
+                        'getStatistics',
+                    ]);
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Resource lifecycle manager error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    },
+};
+//# sourceMappingURL=resource-lifecycle-manager.js.map