claude-flow
Version:
Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration
264 lines (245 loc) • 10.5 kB
text/typescript
import type {
ClaudeFlowPlugin,
PluginContext,
MCPToolDefinition,
CLICommandDefinition,
AgentTypeDefinition,
} from '@claude-flow/shared/src/plugin-interface.js';
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 implements ClaudeFlowPlugin {
readonly name = '@claude-flow/plugin-iot-cognitum';
readonly version = '1.0.0-alpha.1';
readonly description = 'IoT Cognitum Seed device-agent bridge';
readonly author = 'Claude Flow Team';
readonly dependencies = ['@claude-flow/shared'];
private coordinator: IoTCoordinator | null = null;
private healthProbe: HealthProbeWorker | null = null;
private telemetryIngest: TelemetryIngestWorker | null = null;
private anomalyScan: AnomalyScanWorker | null = null;
private meshSync: MeshSyncWorker | null = null;
private firmwareWatch: FirmwareWatchWorker | null = null;
private witnessAudit: WitnessAuditWorker | null = null;
private context: PluginContext | null = null;
async initialize(context: PluginContext): Promise<void> {
this.context = context;
const config = context.config;
const defaultFleetId = (config['fleetId'] as string) ?? 'default';
const defaultZoneId = (config['zoneId'] as string) ?? 'zone-0';
const insecure = (config['tlsInsecure'] as boolean) ?? 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'] as number) ?? 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'] as number) ?? 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'] as number) ?? 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'] as number) ?? 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'] as number) ?? 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'] as number) ?? 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(): Promise<void> {
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(): MCPToolDefinition[] {
return createMcpTools(() => this.coordinator, () => this.context);
}
registerCLICommands(): CLICommandDefinition[] {
return createCliCommands(() => this.coordinator, () => this.context);
}
registerAgentTypes(): AgentTypeDefinition[] {
return [
{
type: 'device-coordinator',
name: 'Device Coordinator',
description: 'Manages Cognitum Seed device fleet as Ruflo 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: '@claude-flow/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: '@claude-flow/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: '@claude-flow/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: '@claude-flow/plugin-iot-cognitum' },
},
requiredCapabilities: ['iot:witness-verify'],
metadata: { cryptoAware: true, auditAware: true },
},
];
}
async healthCheck(): Promise<boolean> {
return this.coordinator !== null;
}
}