swarmdo 1.4.8 → 1.5.0

package/v3/@swarmdo/plugin-iot-cognitum/dist/plugin.d.ts

@@ -1,23 +0,0 @@
-import type { ClaudeFlowPlugin, PluginContext, MCPToolDefinition, CLICommandDefinition, AgentTypeDefinition } from '@swarmdo/shared/src/plugin-interface.js';
-export declare class IoTCognitumPlugin implements ClaudeFlowPlugin {
-    readonly name = "@swarmdo/plugin-iot-cognitum";
-    readonly version = "1.0.0-alpha.1";
-    readonly description = "IoT Cognitum Seed device-agent bridge";
-    readonly author = "Swarmdo Team";
-    readonly dependencies: string[];
-    private coordinator;
-    private healthProbe;
-    private telemetryIngest;
-    private anomalyScan;
-    private meshSync;
-    private firmwareWatch;
-    private witnessAudit;
-    private context;
-    initialize(context: PluginContext): Promise<void>;
-    shutdown(): Promise<void>;
-    registerMCPTools(): MCPToolDefinition[];
-    registerCLICommands(): CLICommandDefinition[];
-    registerAgentTypes(): AgentTypeDefinition[];
-    healthCheck(): Promise<boolean>;
-}
-//# sourceMappingURL=plugin.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/plugin.js

@@ -1,239 +0,0 @@
-import { IoTCoordinator } from './application/iot-coordinator.js';
-import { HealthProbeWorker } from './workers/health-probe-worker.js';
-import { TelemetryIngestWorker } from './workers/telemetry-ingest-worker.js';
-import { AnomalyScanWorker } from './workers/anomaly-scan-worker.js';
-import { MeshSyncWorker } from './workers/mesh-sync-worker.js';
-import { FirmwareWatchWorker } from './workers/firmware-watch-worker.js';
-import { WitnessAuditWorker } from './workers/witness-audit-worker.js';
-import { InMemoryDeviceRepository } from './infrastructure/in-memory-device-repository.js';
-import { InMemoryTrustHistoryRepository } from './infrastructure/in-memory-trust-history-repository.js';
-import { InMemoryFleetRepository } from './infrastructure/in-memory-fleet-repository.js';
-import { createMcpTools } from './mcp-tools.js';
-import { createCliCommands } from './cli-commands.js';
-export class IoTCognitumPlugin {
-    name = '@swarmdo/plugin-iot-cognitum';
-    version = '1.0.0-alpha.1';
-    description = 'IoT Cognitum Seed device-agent bridge';
-    author = 'Swarmdo Team';
-    dependencies = ['@swarmdo/shared'];
-    coordinator = null;
-    healthProbe = null;
-    telemetryIngest = null;
-    anomalyScan = null;
-    meshSync = null;
-    firmwareWatch = null;
-    witnessAudit = null;
-    context = null;
-    async initialize(context) {
-        this.context = context;
-        const config = context.config;
-        const defaultFleetId = config['fleetId'] ?? 'default';
-        const defaultZoneId = config['zoneId'] ?? 'zone-0';
-        const insecure = config['tlsInsecure'] ?? true;
-        this.coordinator = new IoTCoordinator({
-            defaultFleetId,
-            defaultZoneId,
-            defaultTls: { insecure },
-            deviceRepository: new InMemoryDeviceRepository(),
-            trustHistoryRepository: new InMemoryTrustHistoryRepository(),
-            fleetRepository: new InMemoryFleetRepository(),
-        }, {
-            onDeviceRegistered: (device) => {
-                context.logger.info(`Device registered: ${device.deviceId} at ${device.endpoint}`);
-                context.eventBus.emit('iot:device-registered', device);
-            },
-            onTrustChange: (deviceId, oldLevel, newLevel) => {
-                context.logger.info(`Trust change for ${deviceId}: ${oldLevel} -> ${newLevel}`);
-                context.eventBus.emit('iot:trust-change', { deviceId, oldLevel, newLevel });
-            },
-        });
-        context.services.register('iot:coordinator', this.coordinator);
-        const healthIntervalMs = config['healthIntervalMs'] ?? 30_000;
-        this.healthProbe = new HealthProbeWorker(this.coordinator, {
-            intervalMs: healthIntervalMs,
-            onDeviceOffline: (deviceId) => {
-                context.logger.warn(`Device offline: ${deviceId}`);
-                context.eventBus.emit('iot:device-offline', { deviceId });
-            },
-            onDeviceOnline: (deviceId) => {
-                context.logger.info(`Device back online: ${deviceId}`);
-                context.eventBus.emit('iot:device-online', { deviceId });
-            },
-        });
-        this.healthProbe.start();
-        const telemetryIntervalMs = config['telemetryIntervalMs'] ?? 60_000;
-        this.telemetryIngest = new TelemetryIngestWorker(this.coordinator, {
-            intervalMs: telemetryIntervalMs,
-            onIngestionComplete: (deviceId, vectorCount) => {
-                context.logger.debug(`Telemetry ingest for ${deviceId}: ${vectorCount} vectors`);
-            },
-            onIngestionError: (deviceId, error) => {
-                context.logger.warn(`Telemetry ingest error for ${deviceId}: ${error.message}`);
-            },
-        });
-        this.telemetryIngest.start();
-        const anomalyScanIntervalMs = config['anomalyScanIntervalMs'] ?? 300_000;
-        this.anomalyScan = new AnomalyScanWorker(this.coordinator, {
-            intervalMs: anomalyScanIntervalMs,
-            onAnomalyDetected: (deviceId, score) => {
-                context.logger.warn(`Anomaly detected on ${deviceId}: trust score ${score.toFixed(3)}`);
-                context.eventBus.emit('iot:anomaly-detected', { deviceId, score });
-            },
-            onScanError: (deviceId, error) => {
-                context.logger.warn(`Anomaly scan error for ${deviceId}: ${error.message}`);
-            },
-        });
-        this.anomalyScan.start();
-        const meshSyncIntervalMs = config['meshSyncIntervalMs'] ?? 120_000;
-        this.meshSync = new MeshSyncWorker(this.coordinator, {
-            intervalMs: meshSyncIntervalMs,
-            onMeshPartition: (deviceId, peerCount) => {
-                context.logger.warn(`Mesh partition detected for ${deviceId}: ${peerCount} peers`);
-                context.eventBus.emit('iot:mesh-partition', { deviceId, peerCount });
-            },
-            onSyncError: (deviceId, error) => {
-                context.logger.warn(`Mesh sync error for ${deviceId}: ${error.message}`);
-            },
-        });
-        this.meshSync.start();
-        const firmwareWatchIntervalMs = config['firmwareWatchIntervalMs'] ?? 300_000;
-        this.firmwareWatch = new FirmwareWatchWorker(this.coordinator, {
-            intervalMs: firmwareWatchIntervalMs,
-            onVersionMismatch: (deviceId, expected, actual) => {
-                context.logger.warn(`Firmware mismatch on ${deviceId}: expected ${expected}, got ${actual}`);
-                context.eventBus.emit('iot:firmware-mismatch', { deviceId, expected, actual });
-            },
-            onWatchError: (deviceId, error) => {
-                context.logger.warn(`Firmware watch error for ${deviceId}: ${error.message}`);
-            },
-        });
-        this.firmwareWatch.start();
-        const witnessAuditIntervalMs = config['witnessAuditIntervalMs'] ?? 600_000;
-        this.witnessAudit = new WitnessAuditWorker(this.coordinator, {
-            intervalMs: witnessAuditIntervalMs,
-            onGapDetected: (deviceId, fromEpoch, toEpoch) => {
-                context.logger.warn(`Witness chain gap on ${deviceId}: epoch ${fromEpoch} → ${toEpoch}`);
-                context.eventBus.emit('iot:witness-gap', { deviceId, fromEpoch, toEpoch });
-            },
-            onAuditError: (deviceId, error) => {
-                context.logger.warn(`Witness audit error for ${deviceId}: ${error.message}`);
-            },
-        });
-        this.witnessAudit.start();
-        context.logger.info('IoT Cognitum plugin initialized');
-    }
-    async shutdown() {
-        if (this.witnessAudit) {
-            this.witnessAudit.stop();
-            this.witnessAudit = null;
-        }
-        if (this.firmwareWatch) {
-            this.firmwareWatch.stop();
-            this.firmwareWatch = null;
-        }
-        if (this.meshSync) {
-            this.meshSync.stop();
-            this.meshSync = null;
-        }
-        if (this.anomalyScan) {
-            this.anomalyScan.stop();
-            this.anomalyScan = null;
-        }
-        if (this.telemetryIngest) {
-            this.telemetryIngest.stop();
-            this.telemetryIngest = null;
-        }
-        if (this.healthProbe) {
-            this.healthProbe.stop();
-            this.healthProbe = null;
-        }
-        if (this.coordinator) {
-            await this.coordinator.shutdown();
-            this.coordinator = null;
-        }
-        this.context?.logger.info('IoT Cognitum plugin shut down');
-        this.context = null;
-    }
-    registerMCPTools() {
-        return createMcpTools(() => this.coordinator, () => this.context);
-    }
-    registerCLICommands() {
-        return createCliCommands(() => this.coordinator, () => this.context);
-    }
-    registerAgentTypes() {
-        return [
-            {
-                type: 'device-coordinator',
-                name: 'Device Coordinator',
-                description: 'Manages Cognitum Seed device fleet as Swarmdo agent swarm members',
-                defaultConfig: {
-                    id: '',
-                    name: 'device-coordinator',
-                    type: 'coordinator',
-                    capabilities: ['iot:discover', 'iot:register', 'iot:monitor', 'iot:deploy'],
-                    maxConcurrentTasks: 10,
-                    priority: 85,
-                    timeout: 300_000,
-                    metadata: { pluginSource: '@swarmdo/plugin-iot-cognitum' },
-                },
-                requiredCapabilities: ['iot:discover', 'iot:register'],
-                metadata: { trustAware: true, meshAware: true },
-            },
-            {
-                type: 'telemetry-analyzer',
-                name: 'Telemetry Analyzer',
-                description: 'Analyzes Cognitum Seed device telemetry for anomalies and drift patterns',
-                defaultConfig: {
-                    id: '',
-                    name: 'telemetry-analyzer',
-                    type: 'analyzer',
-                    capabilities: ['iot:telemetry', 'iot:anomaly-detect', 'iot:baseline'],
-                    maxConcurrentTasks: 5,
-                    priority: 75,
-                    timeout: 120_000,
-                    metadata: { pluginSource: '@swarmdo/plugin-iot-cognitum' },
-                },
-                requiredCapabilities: ['iot:telemetry'],
-                metadata: { anomalyAware: true, baselineAware: true },
-            },
-            {
-                type: 'fleet-manager',
-                name: 'Fleet Manager',
-                description: 'Manages device fleets, firmware rollouts, and fleet-wide policies',
-                defaultConfig: {
-                    id: '',
-                    name: 'fleet-manager',
-                    type: 'coordinator',
-                    capabilities: ['iot:fleet-create', 'iot:fleet-manage', 'iot:firmware-deploy', 'iot:firmware-rollback'],
-                    maxConcurrentTasks: 8,
-                    priority: 90,
-                    timeout: 600_000,
-                    metadata: { pluginSource: '@swarmdo/plugin-iot-cognitum' },
-                },
-                requiredCapabilities: ['iot:fleet-create', 'iot:fleet-manage'],
-                metadata: { firmwareAware: true, rolloutAware: true },
-            },
-            {
-                type: 'witness-auditor',
-                name: 'Witness Chain Auditor',
-                description: 'Verifies Ed25519 witness chain integrity and detects provenance gaps',
-                defaultConfig: {
-                    id: '',
-                    name: 'witness-auditor',
-                    type: 'auditor',
-                    capabilities: ['iot:witness-verify', 'iot:witness-audit', 'iot:custody-check'],
-                    maxConcurrentTasks: 3,
-                    priority: 70,
-                    timeout: 180_000,
-                    metadata: { pluginSource: '@swarmdo/plugin-iot-cognitum' },
-                },
-                requiredCapabilities: ['iot:witness-verify'],
-                metadata: { cryptoAware: true, auditAware: true },
-            },
-        ];
-    }
-    async healthCheck() {
-        return this.coordinator !== null;
-    }
-}
-//# sourceMappingURL=plugin.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/anomaly-scan-worker.d.ts

@@ -1,17 +0,0 @@
-import type { IoTCoordinator } from '../application/iot-coordinator.js';
-export interface AnomalyScanConfig {
-    intervalMs: number;
-    onAnomalyDetected?: (deviceId: string, score: number) => void;
-    onScanError?: (deviceId: string, error: Error) => void;
-}
-export declare class AnomalyScanWorker {
-    private timer;
-    private readonly coordinator;
-    private readonly config;
-    constructor(coordinator: IoTCoordinator, config?: Partial<AnomalyScanConfig>);
-    start(): void;
-    stop(): void;
-    scan(): Promise<void>;
-    isRunning(): boolean;
-}
-//# sourceMappingURL=anomaly-scan-worker.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/anomaly-scan-worker.js

@@ -1,42 +0,0 @@
-export class AnomalyScanWorker {
-    timer = null;
-    coordinator;
-    config;
-    constructor(coordinator, config = {}) {
-        this.coordinator = coordinator;
-        this.config = {
-            intervalMs: config.intervalMs ?? 300_000,
-            onAnomalyDetected: config.onAnomalyDetected,
-            onScanError: config.onScanError,
-        };
-    }
-    start() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => void this.scan(), this.config.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    async scan() {
-        const devices = this.coordinator.listDevices();
-        for (const device of devices) {
-            try {
-                const refreshed = await this.coordinator.getDeviceStatus(device.deviceId);
-                if (refreshed.trustScore.overall < 0.5) {
-                    this.config.onAnomalyDetected?.(device.deviceId, refreshed.trustScore.overall);
-                }
-            }
-            catch (err) {
-                this.config.onScanError?.(device.deviceId, err);
-            }
-        }
-    }
-    isRunning() {
-        return this.timer !== null;
-    }
-}
-//# sourceMappingURL=anomaly-scan-worker.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/firmware-watch-worker.d.ts

@@ -1,18 +0,0 @@
-import type { IoTCoordinator } from '../application/iot-coordinator.js';
-export interface FirmwareWatchConfig {
-    intervalMs: number;
-    onVersionMismatch?: (deviceId: string, expected: string, actual: string) => void;
-    onWatchError?: (deviceId: string, error: Error) => void;
-}
-export declare class FirmwareWatchWorker {
-    private timer;
-    private readonly coordinator;
-    private readonly config;
-    private readonly knownVersions;
-    constructor(coordinator: IoTCoordinator, config?: Partial<FirmwareWatchConfig>);
-    start(): void;
-    stop(): void;
-    watch(): Promise<void>;
-    isRunning(): boolean;
-}
-//# sourceMappingURL=firmware-watch-worker.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/firmware-watch-worker.js

@@ -1,45 +0,0 @@
-export class FirmwareWatchWorker {
-    timer = null;
-    coordinator;
-    config;
-    knownVersions = new Map();
-    constructor(coordinator, config = {}) {
-        this.coordinator = coordinator;
-        this.config = {
-            intervalMs: config.intervalMs ?? 300_000,
-            onVersionMismatch: config.onVersionMismatch,
-            onWatchError: config.onWatchError,
-        };
-    }
-    start() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => void this.watch(), this.config.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    async watch() {
-        const devices = this.coordinator.listDevices();
-        for (const device of devices) {
-            try {
-                const refreshed = await this.coordinator.getDeviceStatus(device.deviceId);
-                const knownVersion = this.knownVersions.get(device.deviceId);
-                if (knownVersion && knownVersion !== refreshed.firmwareVersion) {
-                    this.config.onVersionMismatch?.(device.deviceId, knownVersion, refreshed.firmwareVersion);
-                }
-                this.knownVersions.set(device.deviceId, refreshed.firmwareVersion);
-            }
-            catch (err) {
-                this.config.onWatchError?.(device.deviceId, err);
-            }
-        }
-    }
-    isRunning() {
-        return this.timer !== null;
-    }
-}
-//# sourceMappingURL=firmware-watch-worker.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/health-probe-worker.d.ts

@@ -1,19 +0,0 @@
-import type { IoTCoordinator } from '../application/iot-coordinator.js';
-export interface HealthProbeConfig {
-    intervalMs: number;
-    onDeviceOffline?: (deviceId: string) => void;
-    onDeviceOnline?: (deviceId: string) => void;
-    onProbeError?: (deviceId: string, error: Error) => void;
-}
-export declare class HealthProbeWorker {
-    private timer;
-    private readonly coordinator;
-    private readonly config;
-    private readonly lastKnownStatus;
-    constructor(coordinator: IoTCoordinator, config?: Partial<HealthProbeConfig>);
-    start(): void;
-    stop(): void;
-    probe(): Promise<void>;
-    isRunning(): boolean;
-}
-//# sourceMappingURL=health-probe-worker.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/health-probe-worker.js

@@ -1,50 +0,0 @@
-export class HealthProbeWorker {
-    timer = null;
-    coordinator;
-    config;
-    lastKnownStatus = new Map();
-    constructor(coordinator, config = {}) {
-        this.coordinator = coordinator;
-        this.config = {
-            intervalMs: config.intervalMs ?? 30_000,
-            onDeviceOffline: config.onDeviceOffline,
-            onDeviceOnline: config.onDeviceOnline,
-            onProbeError: config.onProbeError,
-        };
-    }
-    start() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => void this.probe(), this.config.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    async probe() {
-        const devices = this.coordinator.listDevices();
-        for (const device of devices) {
-            const prevStatus = this.lastKnownStatus.get(device.deviceId);
-            try {
-                await this.coordinator.getDeviceStatus(device.deviceId);
-                this.lastKnownStatus.set(device.deviceId, 'online');
-                if (prevStatus === 'offline') {
-                    this.config.onDeviceOnline?.(device.deviceId);
-                }
-            }
-            catch (err) {
-                this.lastKnownStatus.set(device.deviceId, 'offline');
-                if (prevStatus !== 'offline') {
-                    this.config.onDeviceOffline?.(device.deviceId);
-                }
-                this.config.onProbeError?.(device.deviceId, err);
-            }
-        }
-    }
-    isRunning() {
-        return this.timer !== null;
-    }
-}
-//# sourceMappingURL=health-probe-worker.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/mesh-sync-worker.d.ts

@@ -1,19 +0,0 @@
-import type { IoTCoordinator } from '../application/iot-coordinator.js';
-export interface MeshSyncConfig {
-    intervalMs: number;
-    onMeshPartition?: (deviceId: string, peerCount: number) => void;
-    onSyncComplete?: (deviceId: string, peerCount: number) => void;
-    onSyncError?: (deviceId: string, error: Error) => void;
-}
-export declare class MeshSyncWorker {
-    private timer;
-    private readonly coordinator;
-    private readonly config;
-    private readonly lastPeerCounts;
-    constructor(coordinator: IoTCoordinator, config?: Partial<MeshSyncConfig>);
-    start(): void;
-    stop(): void;
-    sync(): Promise<void>;
-    isRunning(): boolean;
-}
-//# sourceMappingURL=mesh-sync-worker.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/mesh-sync-worker.js

@@ -1,47 +0,0 @@
-export class MeshSyncWorker {
-    timer = null;
-    coordinator;
-    config;
-    lastPeerCounts = new Map();
-    constructor(coordinator, config = {}) {
-        this.coordinator = coordinator;
-        this.config = {
-            intervalMs: config.intervalMs ?? 120_000,
-            onMeshPartition: config.onMeshPartition,
-            onSyncComplete: config.onSyncComplete,
-            onSyncError: config.onSyncError,
-        };
-    }
-    start() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => void this.sync(), this.config.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    async sync() {
-        const devices = this.coordinator.listDevices();
-        for (const device of devices) {
-            try {
-                const topology = await this.coordinator.getDeviceMeshTopology(device.deviceId);
-                const prevCount = this.lastPeerCounts.get(device.deviceId) ?? topology.peerCount;
-                if (topology.peerCount === 0 && prevCount > 0) {
-                    this.config.onMeshPartition?.(device.deviceId, topology.peerCount);
-                }
-                this.lastPeerCounts.set(device.deviceId, topology.peerCount);
-                this.config.onSyncComplete?.(device.deviceId, topology.peerCount);
-            }
-            catch (err) {
-                this.config.onSyncError?.(device.deviceId, err);
-            }
-        }
-    }
-    isRunning() {
-        return this.timer !== null;
-    }
-}
-//# sourceMappingURL=mesh-sync-worker.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/telemetry-ingest-worker.d.ts

@@ -1,17 +0,0 @@
-import type { IoTCoordinator } from '../application/iot-coordinator.js';
-export interface TelemetryIngestConfig {
-    intervalMs: number;
-    onIngestionComplete?: (deviceId: string, vectorCount: number) => void;
-    onIngestionError?: (deviceId: string, error: Error) => void;
-}
-export declare class TelemetryIngestWorker {
-    private timer;
-    private readonly coordinator;
-    private readonly config;
-    constructor(coordinator: IoTCoordinator, config?: Partial<TelemetryIngestConfig>);
-    start(): void;
-    stop(): void;
-    ingest(): Promise<void>;
-    isRunning(): boolean;
-}
-//# sourceMappingURL=telemetry-ingest-worker.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/telemetry-ingest-worker.js

@@ -1,40 +0,0 @@
-export class TelemetryIngestWorker {
-    timer = null;
-    coordinator;
-    config;
-    constructor(coordinator, config = {}) {
-        this.coordinator = coordinator;
-        this.config = {
-            intervalMs: config.intervalMs ?? 60_000,
-            onIngestionComplete: config.onIngestionComplete,
-            onIngestionError: config.onIngestionError,
-        };
-    }
-    start() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => void this.ingest(), this.config.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    async ingest() {
-        const devices = this.coordinator.listDevices();
-        for (const device of devices) {
-            try {
-                const storeStatus = await this.coordinator.getDeviceStoreStatus(device.deviceId);
-                this.config.onIngestionComplete?.(device.deviceId, storeStatus.totalVectors);
-            }
-            catch (err) {
-                this.config.onIngestionError?.(device.deviceId, err);
-            }
-        }
-    }
-    isRunning() {
-        return this.timer !== null;
-    }
-}
-//# sourceMappingURL=telemetry-ingest-worker.js.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/witness-audit-worker.d.ts

@@ -1,18 +0,0 @@
-import type { IoTCoordinator } from '../application/iot-coordinator.js';
-export interface WitnessAuditConfig {
-    intervalMs: number;
-    onGapDetected?: (deviceId: string, fromEpoch: number, toEpoch: number) => void;
-    onAuditComplete?: (deviceId: string, chainLength: number) => void;
-    onAuditError?: (deviceId: string, error: Error) => void;
-}
-export declare class WitnessAuditWorker {
-    private timer;
-    private readonly coordinator;
-    private readonly config;
-    constructor(coordinator: IoTCoordinator, config?: Partial<WitnessAuditConfig>);
-    start(): void;
-    stop(): void;
-    audit(): Promise<void>;
-    isRunning(): boolean;
-}
-//# sourceMappingURL=witness-audit-worker.d.ts.map

package/v3/@swarmdo/plugin-iot-cognitum/dist/workers/witness-audit-worker.js

@@ -1,51 +0,0 @@
-export class WitnessAuditWorker {
-    timer = null;
-    coordinator;
-    config;
-    constructor(coordinator, config = {}) {
-        this.coordinator = coordinator;
-        this.config = {
-            intervalMs: config.intervalMs ?? 600_000,
-            onGapDetected: config.onGapDetected,
-            onAuditComplete: config.onAuditComplete,
-            onAuditError: config.onAuditError,
-        };
-    }
-    start() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => void this.audit(), this.config.intervalMs);
-    }
-    stop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-    }
-    async audit() {
-        const devices = this.coordinator.listDevices();
-        for (const device of devices) {
-            try {
-                const chain = await this.coordinator.getDeviceWitnessChain(device.deviceId);
-                const entries = chain.entries ?? [];
-                const sorted = [...entries].sort((a, b) => a.epoch - b.epoch);
-                for (let i = 1; i < sorted.length; i++) {
-                    const expected = sorted[i - 1].epoch + 1;
-                    const actual = sorted[i].epoch;
-                    if (actual > expected) {
-                        this.config.onGapDetected?.(device.deviceId, sorted[i - 1].epoch, actual);
-                    }
-                }
-                const chainLength = chain.length ?? entries.length ?? 0;
-                this.config.onAuditComplete?.(device.deviceId, chainLength);
-            }
-            catch (err) {
-                this.config.onAuditError?.(device.deviceId, err);
-            }
-        }
-    }
-    isRunning() {
-        return this.timer !== null;
-    }
-}
-//# sourceMappingURL=witness-audit-worker.js.map