@objectstack/core 0.9.0 → 0.9.2

package/dist/dependency-resolver.test.js

@@ -0,0 +1,241 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { SemanticVersionManager, DependencyResolver } from './dependency-resolver.js';
+import { createLogger } from './logger.js';
+describe('SemanticVersionManager', () => {
+    describe('parse', () => {
+        it('should parse standard semver', () => {
+            const version = SemanticVersionManager.parse('1.2.3');
+            expect(version).toEqual({
+                major: 1,
+                minor: 2,
+                patch: 3,
+                preRelease: undefined,
+                build: undefined,
+            });
+        });
+        it('should parse semver with pre-release', () => {
+            const version = SemanticVersionManager.parse('1.2.3-alpha.1');
+            expect(version).toEqual({
+                major: 1,
+                minor: 2,
+                patch: 3,
+                preRelease: 'alpha.1',
+                build: undefined,
+            });
+        });
+        it('should parse semver with build metadata', () => {
+            const version = SemanticVersionManager.parse('1.2.3+build.123');
+            expect(version).toEqual({
+                major: 1,
+                minor: 2,
+                patch: 3,
+                preRelease: undefined,
+                build: 'build.123',
+            });
+        });
+        it('should parse semver with both pre-release and build', () => {
+            const version = SemanticVersionManager.parse('1.2.3-beta.2+build.456');
+            expect(version).toEqual({
+                major: 1,
+                minor: 2,
+                patch: 3,
+                preRelease: 'beta.2',
+                build: 'build.456',
+            });
+        });
+        it('should handle v prefix', () => {
+            const version = SemanticVersionManager.parse('v1.2.3');
+            expect(version.major).toBe(1);
+            expect(version.minor).toBe(2);
+            expect(version.patch).toBe(3);
+        });
+    });
+    describe('compare', () => {
+        it('should compare major versions', () => {
+            const v1 = SemanticVersionManager.parse('2.0.0');
+            const v2 = SemanticVersionManager.parse('1.0.0');
+            expect(SemanticVersionManager.compare(v1, v2)).toBeGreaterThan(0);
+            expect(SemanticVersionManager.compare(v2, v1)).toBeLessThan(0);
+        });
+        it('should compare minor versions', () => {
+            const v1 = SemanticVersionManager.parse('1.2.0');
+            const v2 = SemanticVersionManager.parse('1.1.0');
+            expect(SemanticVersionManager.compare(v1, v2)).toBeGreaterThan(0);
+        });
+        it('should compare patch versions', () => {
+            const v1 = SemanticVersionManager.parse('1.0.2');
+            const v2 = SemanticVersionManager.parse('1.0.1');
+            expect(SemanticVersionManager.compare(v1, v2)).toBeGreaterThan(0);
+        });
+        it('should handle equal versions', () => {
+            const v1 = SemanticVersionManager.parse('1.2.3');
+            const v2 = SemanticVersionManager.parse('1.2.3');
+            expect(SemanticVersionManager.compare(v1, v2)).toBe(0);
+        });
+        it('should treat pre-release as lower than release', () => {
+            const v1 = SemanticVersionManager.parse('1.0.0-alpha');
+            const v2 = SemanticVersionManager.parse('1.0.0');
+            expect(SemanticVersionManager.compare(v1, v2)).toBeLessThan(0);
+        });
+    });
+    describe('satisfies', () => {
+        it('should match exact version', () => {
+            const version = SemanticVersionManager.parse('1.2.3');
+            expect(SemanticVersionManager.satisfies(version, '1.2.3')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, '1.2.4')).toBe(false);
+        });
+        it('should match caret range', () => {
+            const version = SemanticVersionManager.parse('1.2.5');
+            expect(SemanticVersionManager.satisfies(version, '^1.2.3')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, '^1.3.0')).toBe(false);
+            expect(SemanticVersionManager.satisfies(version, '^2.0.0')).toBe(false);
+        });
+        it('should match tilde range', () => {
+            const version = SemanticVersionManager.parse('1.2.5');
+            expect(SemanticVersionManager.satisfies(version, '~1.2.3')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, '~1.3.0')).toBe(false);
+        });
+        it('should match greater than or equal', () => {
+            const version = SemanticVersionManager.parse('1.2.5');
+            expect(SemanticVersionManager.satisfies(version, '>=1.2.3')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, '>=1.2.5')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, '>=1.3.0')).toBe(false);
+        });
+        it('should match less than', () => {
+            const version = SemanticVersionManager.parse('1.2.5');
+            expect(SemanticVersionManager.satisfies(version, '<1.3.0')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, '<1.2.5')).toBe(false);
+        });
+        it('should match range', () => {
+            const version = SemanticVersionManager.parse('1.2.5');
+            expect(SemanticVersionManager.satisfies(version, '1.2.0 - 1.3.0')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, '1.3.0 - 1.4.0')).toBe(false);
+        });
+        it('should match wildcard', () => {
+            const version = SemanticVersionManager.parse('1.2.5');
+            expect(SemanticVersionManager.satisfies(version, '*')).toBe(true);
+            expect(SemanticVersionManager.satisfies(version, 'latest')).toBe(true);
+        });
+    });
+    describe('getCompatibilityLevel', () => {
+        it('should detect fully compatible versions', () => {
+            const from = SemanticVersionManager.parse('1.2.3');
+            const to = SemanticVersionManager.parse('1.2.3');
+            expect(SemanticVersionManager.getCompatibilityLevel(from, to)).toBe('fully-compatible');
+        });
+        it('should detect backward compatible versions', () => {
+            const from = SemanticVersionManager.parse('1.2.3');
+            const to = SemanticVersionManager.parse('1.3.0');
+            expect(SemanticVersionManager.getCompatibilityLevel(from, to)).toBe('backward-compatible');
+        });
+        it('should detect breaking changes', () => {
+            const from = SemanticVersionManager.parse('1.2.3');
+            const to = SemanticVersionManager.parse('2.0.0');
+            expect(SemanticVersionManager.getCompatibilityLevel(from, to)).toBe('breaking-changes');
+        });
+        it('should detect incompatible (downgrade)', () => {
+            const from = SemanticVersionManager.parse('1.3.0');
+            const to = SemanticVersionManager.parse('1.2.0');
+            expect(SemanticVersionManager.getCompatibilityLevel(from, to)).toBe('incompatible');
+        });
+    });
+});
+describe('DependencyResolver', () => {
+    let resolver;
+    let logger;
+    beforeEach(() => {
+        logger = createLogger({ level: 'silent' });
+        resolver = new DependencyResolver(logger);
+    });
+    describe('resolve', () => {
+        it('should resolve dependencies in topological order', () => {
+            const plugins = new Map([
+                ['a', { dependencies: [] }],
+                ['b', { dependencies: ['a'] }],
+                ['c', { dependencies: ['a', 'b'] }],
+            ]);
+            const order = resolver.resolve(plugins);
+            expect(order.indexOf('a')).toBeLessThan(order.indexOf('b'));
+            expect(order.indexOf('b')).toBeLessThan(order.indexOf('c'));
+        });
+        it('should handle plugins with no dependencies', () => {
+            const plugins = new Map([
+                ['a', { dependencies: [] }],
+                ['b', { dependencies: [] }],
+            ]);
+            const order = resolver.resolve(plugins);
+            expect(order).toHaveLength(2);
+            expect(order).toContain('a');
+            expect(order).toContain('b');
+        });
+        it('should detect circular dependencies', () => {
+            const plugins = new Map([
+                ['a', { dependencies: ['b'] }],
+                ['b', { dependencies: ['a'] }],
+            ]);
+            expect(() => resolver.resolve(plugins)).toThrow('Circular dependency');
+        });
+        it('should detect missing dependencies', () => {
+            const plugins = new Map([
+                ['a', { dependencies: ['missing'] }],
+            ]);
+            expect(() => resolver.resolve(plugins)).toThrow('Missing dependency');
+        });
+    });
+    describe('detectConflicts', () => {
+        it('should detect version mismatches', () => {
+            const plugins = new Map([
+                ['core', { version: '1.0.0', dependencies: {} }],
+                ['plugin-a', { version: '1.0.0', dependencies: { core: '^2.0.0' } }],
+            ]);
+            const conflicts = resolver.detectConflicts(plugins);
+            expect(conflicts.length).toBeGreaterThan(0);
+            expect(conflicts[0].type).toBe('version-mismatch');
+        });
+        it('should return no conflicts for compatible versions', () => {
+            const plugins = new Map([
+                ['core', { version: '1.2.0', dependencies: {} }],
+                ['plugin-a', { version: '1.0.0', dependencies: { core: '^1.0.0' } }],
+            ]);
+            const conflicts = resolver.detectConflicts(plugins);
+            expect(conflicts.length).toBe(0);
+        });
+    });
+    describe('findBestVersion', () => {
+        it('should find highest matching version', () => {
+            const available = ['1.0.0', '1.1.0', '1.2.0', '2.0.0'];
+            const constraints = ['^1.0.0'];
+            const best = resolver.findBestVersion(available, constraints);
+            expect(best).toBe('1.2.0');
+        });
+        it('should satisfy all constraints', () => {
+            const available = ['1.0.0', '1.1.0', '1.2.0', '2.0.0'];
+            const constraints = ['^1.0.0', '>=1.1.0', '<2.0.0'];
+            const best = resolver.findBestVersion(available, constraints);
+            expect(best).toBe('1.2.0');
+        });
+        it('should return undefined if no version satisfies', () => {
+            const available = ['1.0.0', '1.1.0'];
+            const constraints = ['^2.0.0'];
+            const best = resolver.findBestVersion(available, constraints);
+            expect(best).toBeUndefined();
+        });
+    });
+    describe('isAcyclic', () => {
+        it('should detect acyclic graph', () => {
+            const deps = new Map([
+                ['a', []],
+                ['b', ['a']],
+                ['c', ['a', 'b']],
+            ]);
+            expect(resolver.isAcyclic(deps)).toBe(true);
+        });
+        it('should detect cyclic graph', () => {
+            const deps = new Map([
+                ['a', ['b']],
+                ['b', ['a']],
+            ]);
+            expect(resolver.isAcyclic(deps)).toBe(false);
+        });
+    });
+});

package/dist/health-monitor.d.ts

@@ -0,0 +1,65 @@
+import type { PluginHealthStatus, PluginHealthCheck, PluginHealthReport } from '@objectstack/spec/system';
+import type { ObjectLogger } from './logger.js';
+import type { Plugin } from './types.js';
+/**
+ * Plugin Health Monitor
+ *
+ * Monitors plugin health status and performs automatic recovery actions.
+ * Implements the advanced lifecycle health monitoring protocol.
+ */
+export declare class PluginHealthMonitor {
+    private logger;
+    private healthChecks;
+    private healthStatus;
+    private healthReports;
+    private checkIntervals;
+    private failureCounters;
+    private successCounters;
+    private restartAttempts;
+    constructor(logger: ObjectLogger);
+    /**
+     * Register a plugin for health monitoring
+     */
+    registerPlugin(pluginName: string, config: PluginHealthCheck): void;
+    /**
+     * Start monitoring a plugin
+     */
+    startMonitoring(pluginName: string, plugin: Plugin): void;
+    /**
+     * Stop monitoring a plugin
+     */
+    stopMonitoring(pluginName: string): void;
+    /**
+     * Perform a health check on a plugin
+     */
+    private performHealthCheck;
+    /**
+     * Attempt to restart a plugin
+     */
+    private attemptRestart;
+    /**
+     * Calculate backoff delay for restarts
+     */
+    private calculateBackoff;
+    /**
+     * Get current health status of a plugin
+     */
+    getHealthStatus(pluginName: string): PluginHealthStatus | undefined;
+    /**
+     * Get latest health report for a plugin
+     */
+    getHealthReport(pluginName: string): PluginHealthReport | undefined;
+    /**
+     * Get all health statuses
+     */
+    getAllHealthStatuses(): Map<string, PluginHealthStatus>;
+    /**
+     * Shutdown health monitor
+     */
+    shutdown(): void;
+    /**
+     * Timeout helper
+     */
+    private timeout;
+}
+//# sourceMappingURL=health-monitor.d.ts.map

package/dist/health-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-monitor.d.ts","sourceRoot":"","sources":["../src/health-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,YAAY,CAAwC;IAC5D,OAAO,CAAC,YAAY,CAAyC;IAC7D,OAAO,CAAC,aAAa,CAAyC;IAC9D,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,eAAe,CAA6B;gBAExC,MAAM,EAAE,YAAY;IAIhC;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAanE;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAgCzD;;OAEG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IASxC;;OAEG;YACW,kBAAkB;IAoGhC;;OAEG;YACW,cAAc;IAoD5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAexB;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAInE;;OAEG;IACH,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAInE;;OAEG;IACH,oBAAoB,IAAI,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAIvD;;OAEG;IACH,QAAQ,IAAI,IAAI;IAgBhB;;OAEG;IACH,OAAO,CAAC,OAAO;CAKhB"}

package/dist/health-monitor.js

@@ -0,0 +1,269 @@
+/**
+ * Plugin Health Monitor
+ *
+ * Monitors plugin health status and performs automatic recovery actions.
+ * Implements the advanced lifecycle health monitoring protocol.
+ */
+export class PluginHealthMonitor {
+    constructor(logger) {
+        this.healthChecks = new Map();
+        this.healthStatus = new Map();
+        this.healthReports = new Map();
+        this.checkIntervals = new Map();
+        this.failureCounters = new Map();
+        this.successCounters = new Map();
+        this.restartAttempts = new Map();
+        this.logger = logger.child({ component: 'HealthMonitor' });
+    }
+    /**
+     * Register a plugin for health monitoring
+     */
+    registerPlugin(pluginName, config) {
+        this.healthChecks.set(pluginName, config);
+        this.healthStatus.set(pluginName, 'unknown');
+        this.failureCounters.set(pluginName, 0);
+        this.successCounters.set(pluginName, 0);
+        this.restartAttempts.set(pluginName, 0);
+        this.logger.info('Plugin registered for health monitoring', {
+            plugin: pluginName,
+            interval: config.interval
+        });
+    }
+    /**
+     * Start monitoring a plugin
+     */
+    startMonitoring(pluginName, plugin) {
+        const config = this.healthChecks.get(pluginName);
+        if (!config) {
+            this.logger.warn('Cannot start monitoring - plugin not registered', { plugin: pluginName });
+            return;
+        }
+        // Clear any existing interval
+        this.stopMonitoring(pluginName);
+        // Set up periodic health checks
+        const interval = setInterval(() => {
+            this.performHealthCheck(pluginName, plugin, config).catch(error => {
+                this.logger.error('Health check failed with error', {
+                    plugin: pluginName,
+                    error
+                });
+            });
+        }, config.interval);
+        this.checkIntervals.set(pluginName, interval);
+        this.logger.info('Health monitoring started', { plugin: pluginName });
+        // Perform initial health check
+        this.performHealthCheck(pluginName, plugin, config).catch(error => {
+            this.logger.error('Initial health check failed', {
+                plugin: pluginName,
+                error
+            });
+        });
+    }
+    /**
+     * Stop monitoring a plugin
+     */
+    stopMonitoring(pluginName) {
+        const interval = this.checkIntervals.get(pluginName);
+        if (interval) {
+            clearInterval(interval);
+            this.checkIntervals.delete(pluginName);
+            this.logger.info('Health monitoring stopped', { plugin: pluginName });
+        }
+    }
+    /**
+     * Perform a health check on a plugin
+     */
+    async performHealthCheck(pluginName, plugin, config) {
+        const startTime = Date.now();
+        let status = 'healthy';
+        let message;
+        const checks = [];
+        try {
+            // Check if plugin has a custom health check method
+            if (config.checkMethod && typeof plugin[config.checkMethod] === 'function') {
+                const checkResult = await Promise.race([
+                    plugin[config.checkMethod](),
+                    this.timeout(config.timeout, `Health check timeout after ${config.timeout}ms`)
+                ]);
+                if (checkResult === false || (checkResult && checkResult.status === 'unhealthy')) {
+                    status = 'unhealthy';
+                    message = checkResult?.message || 'Custom health check failed';
+                    checks.push({ name: config.checkMethod, status: 'failed', message });
+                }
+                else {
+                    checks.push({ name: config.checkMethod, status: 'passed' });
+                }
+            }
+            else {
+                // Default health check - just verify plugin is loaded
+                checks.push({ name: 'plugin-loaded', status: 'passed' });
+            }
+            // Update counters based on result
+            if (status === 'healthy') {
+                this.successCounters.set(pluginName, (this.successCounters.get(pluginName) || 0) + 1);
+                this.failureCounters.set(pluginName, 0);
+                // Recover from unhealthy state if we have enough successes
+                const currentStatus = this.healthStatus.get(pluginName);
+                if (currentStatus === 'unhealthy' || currentStatus === 'degraded') {
+                    const successCount = this.successCounters.get(pluginName) || 0;
+                    if (successCount >= config.successThreshold) {
+                        this.healthStatus.set(pluginName, 'healthy');
+                        this.logger.info('Plugin recovered to healthy state', { plugin: pluginName });
+                    }
+                    else {
+                        this.healthStatus.set(pluginName, 'recovering');
+                    }
+                }
+                else {
+                    this.healthStatus.set(pluginName, 'healthy');
+                }
+            }
+            else {
+                this.failureCounters.set(pluginName, (this.failureCounters.get(pluginName) || 0) + 1);
+                this.successCounters.set(pluginName, 0);
+                const failureCount = this.failureCounters.get(pluginName) || 0;
+                if (failureCount >= config.failureThreshold) {
+                    this.healthStatus.set(pluginName, 'unhealthy');
+                    this.logger.warn('Plugin marked as unhealthy', {
+                        plugin: pluginName,
+                        failures: failureCount
+                    });
+                    // Attempt auto-restart if configured
+                    if (config.autoRestart) {
+                        await this.attemptRestart(pluginName, plugin, config);
+                    }
+                }
+                else {
+                    this.healthStatus.set(pluginName, 'degraded');
+                }
+            }
+        }
+        catch (error) {
+            status = 'failed';
+            message = error instanceof Error ? error.message : 'Unknown error';
+            this.failureCounters.set(pluginName, (this.failureCounters.get(pluginName) || 0) + 1);
+            this.healthStatus.set(pluginName, 'failed');
+            checks.push({
+                name: 'health-check',
+                status: 'failed',
+                message: message
+            });
+            this.logger.error('Health check exception', {
+                plugin: pluginName,
+                error
+            });
+        }
+        // Create health report
+        const report = {
+            status: this.healthStatus.get(pluginName) || 'unknown',
+            timestamp: new Date().toISOString(),
+            message,
+            metrics: {
+                uptime: Date.now() - startTime,
+            },
+            checks: checks.length > 0 ? checks : undefined,
+        };
+        this.healthReports.set(pluginName, report);
+    }
+    /**
+     * Attempt to restart a plugin
+     */
+    async attemptRestart(pluginName, plugin, config) {
+        const attempts = this.restartAttempts.get(pluginName) || 0;
+        if (attempts >= config.maxRestartAttempts) {
+            this.logger.error('Max restart attempts reached, giving up', {
+                plugin: pluginName,
+                attempts
+            });
+            this.healthStatus.set(pluginName, 'failed');
+            return;
+        }
+        this.restartAttempts.set(pluginName, attempts + 1);
+        // Calculate backoff delay
+        const delay = this.calculateBackoff(attempts, config.restartBackoff);
+        this.logger.info('Scheduling plugin restart', {
+            plugin: pluginName,
+            attempt: attempts + 1,
+            delay
+        });
+        await new Promise(resolve => setTimeout(resolve, delay));
+        try {
+            // Call destroy and init to restart
+            if (plugin.destroy) {
+                await plugin.destroy();
+            }
+            // Note: Full restart would require kernel context
+            // This is a simplified version - actual implementation would need kernel integration
+            this.logger.info('Plugin restarted', { plugin: pluginName });
+            // Reset counters on successful restart
+            this.failureCounters.set(pluginName, 0);
+            this.successCounters.set(pluginName, 0);
+            this.healthStatus.set(pluginName, 'recovering');
+        }
+        catch (error) {
+            this.logger.error('Plugin restart failed', {
+                plugin: pluginName,
+                error
+            });
+            this.healthStatus.set(pluginName, 'failed');
+        }
+    }
+    /**
+     * Calculate backoff delay for restarts
+     */
+    calculateBackoff(attempt, strategy) {
+        const baseDelay = 1000; // 1 second base
+        switch (strategy) {
+            case 'fixed':
+                return baseDelay;
+            case 'linear':
+                return baseDelay * (attempt + 1);
+            case 'exponential':
+                return baseDelay * Math.pow(2, attempt);
+            default:
+                return baseDelay;
+        }
+    }
+    /**
+     * Get current health status of a plugin
+     */
+    getHealthStatus(pluginName) {
+        return this.healthStatus.get(pluginName);
+    }
+    /**
+     * Get latest health report for a plugin
+     */
+    getHealthReport(pluginName) {
+        return this.healthReports.get(pluginName);
+    }
+    /**
+     * Get all health statuses
+     */
+    getAllHealthStatuses() {
+        return new Map(this.healthStatus);
+    }
+    /**
+     * Shutdown health monitor
+     */
+    shutdown() {
+        // Stop all monitoring intervals
+        for (const pluginName of this.checkIntervals.keys()) {
+            this.stopMonitoring(pluginName);
+        }
+        this.healthChecks.clear();
+        this.healthStatus.clear();
+        this.healthReports.clear();
+        this.failureCounters.clear();
+        this.successCounters.clear();
+        this.restartAttempts.clear();
+        this.logger.info('Health monitor shutdown complete');
+    }
+    /**
+     * Timeout helper
+     */
+    timeout(ms, message) {
+        return new Promise((_, reject) => {
+            setTimeout(() => reject(new Error(message)), ms);
+        });
+    }
+}

package/dist/health-monitor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=health-monitor.test.d.ts.map

package/dist/health-monitor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-monitor.test.d.ts","sourceRoot":"","sources":["../src/health-monitor.test.ts"],"names":[],"mappings":""}

package/dist/health-monitor.test.js

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PluginHealthMonitor } from './health-monitor.js';
+import { createLogger } from './logger.js';
+describe('PluginHealthMonitor', () => {
+    let monitor;
+    let logger;
+    beforeEach(() => {
+        logger = createLogger({ level: 'silent' });
+        monitor = new PluginHealthMonitor(logger);
+    });
+    it('should register plugin for health monitoring', () => {
+        const config = {
+            interval: 5000,
+            timeout: 1000,
+            failureThreshold: 3,
+            successThreshold: 1,
+            autoRestart: false,
+            maxRestartAttempts: 3,
+            restartBackoff: 'exponential',
+        };
+        monitor.registerPlugin('test-plugin', config);
+        expect(monitor.getHealthStatus('test-plugin')).toBe('unknown');
+    });
+    it('should report healthy status initially', () => {
+        const config = {
+            interval: 5000,
+            timeout: 1000,
+            failureThreshold: 3,
+            successThreshold: 1,
+            autoRestart: false,
+            maxRestartAttempts: 3,
+            restartBackoff: 'fixed',
+        };
+        monitor.registerPlugin('test-plugin', config);
+        expect(monitor.getHealthStatus('test-plugin')).toBe('unknown');
+    });
+    it('should get all health statuses', () => {
+        const config = {
+            interval: 5000,
+            timeout: 1000,
+            failureThreshold: 3,
+            successThreshold: 1,
+            autoRestart: false,
+            maxRestartAttempts: 3,
+            restartBackoff: 'linear',
+        };
+        monitor.registerPlugin('plugin1', config);
+        monitor.registerPlugin('plugin2', config);
+        const statuses = monitor.getAllHealthStatuses();
+        expect(statuses.size).toBe(2);
+        expect(statuses.has('plugin1')).toBe(true);
+        expect(statuses.has('plugin2')).toBe(true);
+    });
+    it('should shutdown cleanly', () => {
+        const config = {
+            interval: 5000,
+            timeout: 1000,
+            failureThreshold: 3,
+            successThreshold: 1,
+            autoRestart: false,
+            maxRestartAttempts: 3,
+            restartBackoff: 'exponential',
+        };
+        monitor.registerPlugin('test-plugin', config);
+        monitor.shutdown();
+        expect(monitor.getAllHealthStatuses().size).toBe(0);
+    });
+});