agentic-qe 2.7.4 → 2.8.0

package/dist/edge/p2p/coordination/CoordinationManager.js

@@ -0,0 +1,851 @@
+"use strict";
+/**
+ * Coordination Manager for Two-Machine Coordination
+ *
+ * Manages coordination between two or more peers in the P2P network.
+ * Handles connection establishment, authentication, pattern synchronization,
+ * and connection health monitoring.
+ *
+ * @module edge/p2p/coordination/CoordinationManager
+ * @version 1.0.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoordinationManager = void 0;
+exports.createCoordinationManager = createCoordinationManager;
+const types_1 = require("./types");
+const HealthMonitor_1 = require("./HealthMonitor");
+const SyncOrchestrator_1 = require("./SyncOrchestrator");
+// ============================================
+// Coordination Manager Class
+// ============================================
+/**
+ * CoordinationManager - Manages two-machine coordination
+ *
+ * @example
+ * ```typescript
+ * const manager = new CoordinationManager({
+ *   localIdentity: myIdentity,
+ *   localKeyPair: myKeyPair,
+ *   autoReconnect: true,
+ * });
+ *
+ * // Set up message transport
+ * manager.setMessageSender(async (peerId, message) => {
+ *   await dataChannel.send(peerId, JSON.stringify(message));
+ * });
+ *
+ * // Connect to peer
+ * await manager.connect('peer-123');
+ *
+ * // Start synchronization
+ * await manager.syncPatterns('peer-123');
+ *
+ * // Listen for events
+ * manager.on(CoordinationEventType.SYNC_COMPLETED, (event) => {
+ *   console.log('Sync completed with', event.peerId);
+ * });
+ * ```
+ */
+class CoordinationManager {
+    /**
+     * Create a new CoordinationManager
+     *
+     * @param config - Coordination configuration
+     */
+    constructor(config) {
+        this.peers = new Map();
+        this.eventHandlers = new Map();
+        this.isDestroyed = false;
+        this.config = {
+            ...types_1.DEFAULT_COORDINATION_CONFIG,
+            ...config,
+            syncConfig: {
+                ...types_1.DEFAULT_COORDINATION_CONFIG.syncConfig,
+                ...config.syncConfig,
+            },
+        };
+        this.localCapabilities = (0, types_1.createDefaultCapabilities)();
+        // Setup logging
+        this.setupLogging();
+    }
+    // ============================================
+    // Public API - Connection Management
+    // ============================================
+    /**
+     * Set the message sender callback for transport
+     */
+    setMessageSender(sender) {
+        this.messageSender = sender;
+    }
+    /**
+     * Connect to a peer
+     *
+     * @param peerId - Peer to connect to
+     * @param role - Role in the connection
+     * @returns Promise resolving when connected
+     */
+    async connect(peerId, role) {
+        this.ensureNotDestroyed();
+        // Check if already connected
+        const existing = this.peers.get(peerId);
+        if (existing && existing.info.state === 'synchronized') {
+            return existing.info;
+        }
+        const connectionRole = role ?? this.config.defaultRole;
+        this.log(`Connecting to peer: ${peerId} with role: ${connectionRole}`);
+        // Create peer state
+        const peerState = this.createPeerState(peerId, connectionRole);
+        this.peers.set(peerId, peerState);
+        // Update state to connecting
+        this.updatePeerState(peerId, types_1.CoordinationState.CONNECTING);
+        try {
+            // If initiator, send auth challenge
+            if (connectionRole === 'initiator' || connectionRole === 'bidirectional') {
+                await this.sendAuthChallenge(peerId, peerState);
+            }
+            return peerState.info;
+        }
+        catch (error) {
+            this.updatePeerState(peerId, types_1.CoordinationState.ERROR);
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from a peer
+     *
+     * @param peerId - Peer to disconnect from
+     * @param reason - Reason for disconnection
+     */
+    async disconnect(peerId, reason) {
+        const peerState = this.peers.get(peerId);
+        if (!peerState) {
+            return;
+        }
+        this.log(`Disconnecting from peer: ${peerId}, reason: ${reason ?? 'user requested'}`);
+        try {
+            // Send disconnect message
+            await this.sendMessage(peerId, {
+                type: types_1.CoordinationMessageType.DISCONNECT,
+                messageId: (0, types_1.generateMessageId)(),
+                senderId: this.config.localIdentity.agentId,
+                payload: { reason: reason ?? 'disconnect requested' },
+                timestamp: Date.now(),
+            });
+        }
+        catch {
+            // Ignore send errors during disconnect
+        }
+        // Cleanup peer state
+        this.cleanupPeer(peerId);
+        this.emit(types_1.CoordinationEventType.PEER_DISCONNECTED, peerId, { reason });
+    }
+    /**
+     * Handle incoming message from a peer
+     *
+     * @param peerId - Sender peer ID
+     * @param message - Received message
+     */
+    async handleMessage(peerId, message) {
+        this.ensureNotDestroyed();
+        let peerState = this.peers.get(peerId);
+        // Create peer state if this is a new incoming connection
+        if (!peerState) {
+            peerState = this.createPeerState(peerId, types_1.CoordinationRole.RESPONDER);
+            this.peers.set(peerId, peerState);
+        }
+        // Update metrics
+        peerState.info.metrics.messagesReceived++;
+        peerState.info.lastSeenAt = Date.now();
+        this.logDebug(`Received message from ${peerId}: ${message.type}`);
+        try {
+            switch (message.type) {
+                case types_1.CoordinationMessageType.AUTH_CHALLENGE:
+                    await this.handleAuthChallenge(peerId, peerState, message.payload, message.messageId);
+                    break;
+                case types_1.CoordinationMessageType.AUTH_RESPONSE:
+                    await this.handleAuthResponse(peerId, peerState, message.payload, message.correlationId);
+                    break;
+                case types_1.CoordinationMessageType.AUTH_RESULT:
+                    await this.handleAuthResult(peerId, peerState, message.payload);
+                    break;
+                case types_1.CoordinationMessageType.CAPABILITIES:
+                    await this.handleCapabilities(peerId, peerState, message.payload);
+                    break;
+                case types_1.CoordinationMessageType.PING:
+                    await this.handlePing(peerId, peerState, message.payload);
+                    break;
+                case types_1.CoordinationMessageType.PONG:
+                    await this.handlePong(peerId, peerState, message.payload);
+                    break;
+                case types_1.CoordinationMessageType.SYNC_REQUEST:
+                case types_1.CoordinationMessageType.SYNC_RESPONSE:
+                case types_1.CoordinationMessageType.SYNC_COMPLETE:
+                case types_1.CoordinationMessageType.PATTERN_BATCH:
+                    await peerState.syncOrchestrator.handleMessage(message);
+                    break;
+                case types_1.CoordinationMessageType.CONFLICT:
+                    await this.handleConflict(peerId, peerState, message.payload);
+                    break;
+                case types_1.CoordinationMessageType.ERROR:
+                    await this.handleError(peerId, peerState, message.payload);
+                    break;
+                case types_1.CoordinationMessageType.DISCONNECT:
+                    await this.handleDisconnect(peerId, peerState, message.payload);
+                    break;
+                default:
+                    this.logWarn(`Unknown message type: ${message.type}`);
+            }
+            // Resolve pending response if this is a response
+            if (message.correlationId) {
+                const pending = peerState.pendingResponses.get(message.correlationId);
+                if (pending) {
+                    clearTimeout(pending.timeout);
+                    pending.resolve(message.payload);
+                    peerState.pendingResponses.delete(message.correlationId);
+                }
+            }
+        }
+        catch (error) {
+            this.logError(`Error handling message from ${peerId}:`, error);
+            this.emit(types_1.CoordinationEventType.ERROR, peerId, { error, message });
+        }
+    }
+    // ============================================
+    // Public API - Synchronization
+    // ============================================
+    /**
+     * Start pattern synchronization with a peer
+     *
+     * @param peerId - Peer to sync with
+     * @param patterns - Local patterns to sync
+     * @returns Sync result
+     */
+    async syncPatterns(peerId, patterns) {
+        const peerState = this.getPeerStateOrThrow(peerId);
+        if (!peerState.info.isAuthenticated) {
+            throw new types_1.CoordinationError('Peer not authenticated', types_1.CoordinationErrorCode.PEER_NOT_AUTHENTICATED, peerId);
+        }
+        this.log(`Starting pattern sync with peer: ${peerId}`);
+        this.updatePeerState(peerId, types_1.CoordinationState.SYNCING);
+        this.emit(types_1.CoordinationEventType.SYNC_STARTED, peerId, {
+            patternCount: patterns?.length ?? 0,
+        });
+        try {
+            const result = await peerState.syncOrchestrator.startSync(patterns);
+            if (result.state === 'completed') {
+                this.updatePeerState(peerId, types_1.CoordinationState.SYNCHRONIZED);
+                peerState.info.metrics.successfulSyncs++;
+                this.emit(types_1.CoordinationEventType.SYNC_COMPLETED, peerId, result);
+            }
+            else if (result.state === 'failed') {
+                peerState.info.metrics.failedSyncs++;
+                this.emit(types_1.CoordinationEventType.SYNC_FAILED, peerId, result);
+            }
+            return result;
+        }
+        catch (error) {
+            peerState.info.metrics.failedSyncs++;
+            this.emit(types_1.CoordinationEventType.SYNC_FAILED, peerId, { error });
+            throw error;
+        }
+    }
+    /**
+     * Get sync status for a peer
+     */
+    getSyncStatus(peerId) {
+        return this.peers.get(peerId)?.info.syncStatus;
+    }
+    // ============================================
+    // Public API - Health & Metrics
+    // ============================================
+    /**
+     * Get health status for a peer
+     */
+    getHealthStatus(peerId) {
+        return this.peers.get(peerId)?.info.health;
+    }
+    /**
+     * Get coordination metrics for a peer
+     */
+    getMetrics(peerId) {
+        return this.peers.get(peerId)?.info.metrics;
+    }
+    /**
+     * Get peer information
+     */
+    getPeerInfo(peerId) {
+        return this.peers.get(peerId)?.info;
+    }
+    /**
+     * Get all connected peers
+     */
+    getConnectedPeers() {
+        return Array.from(this.peers.values())
+            .filter((state) => state.info.state !== types_1.CoordinationState.DISCONNECTED &&
+            state.info.state !== types_1.CoordinationState.ERROR)
+            .map((state) => state.info);
+    }
+    /**
+     * Get all authenticated peers
+     */
+    getAuthenticatedPeers() {
+        return Array.from(this.peers.values())
+            .filter((state) => state.info.isAuthenticated)
+            .map((state) => state.info);
+    }
+    /**
+     * Get coordination state for a peer
+     */
+    getState(peerId) {
+        return this.peers.get(peerId)?.info.state;
+    }
+    /**
+     * Get local identity
+     */
+    getLocalIdentity() {
+        return this.config.localIdentity;
+    }
+    // ============================================
+    // Public API - Events
+    // ============================================
+    /**
+     * Register event handler
+     *
+     * @param event - Event type to handle
+     * @param handler - Event handler function
+     * @returns Unsubscribe function
+     */
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+        return () => {
+            this.eventHandlers.get(event)?.delete(handler);
+        };
+    }
+    /**
+     * Remove event handler
+     */
+    off(event, handler) {
+        this.eventHandlers.get(event)?.delete(handler);
+    }
+    // ============================================
+    // Public API - Lifecycle
+    // ============================================
+    /**
+     * Destroy the coordination manager
+     */
+    async destroy() {
+        this.isDestroyed = true;
+        // Disconnect all peers
+        const disconnectPromises = Array.from(this.peers.keys()).map((peerId) => this.disconnect(peerId, 'manager destroyed'));
+        await Promise.all(disconnectPromises);
+        // Clear event handlers
+        this.eventHandlers.clear();
+        this.log('CoordinationManager destroyed');
+    }
+    // ============================================
+    // Private - Authentication
+    // ============================================
+    async sendAuthChallenge(peerId, peerState) {
+        const challenge = (0, types_1.generateChallenge)();
+        const timestamp = Date.now();
+        const expiresIn = this.config.authTimeout;
+        // Store pending challenge
+        peerState.pendingChallenge = {
+            challenge,
+            timestamp,
+            expiresAt: timestamp + expiresIn,
+        };
+        this.updatePeerState(peerId, types_1.CoordinationState.AUTHENTICATING);
+        const payload = {
+            challenge,
+            timestamp: new Date(timestamp).toISOString(),
+            expiresIn,
+            capabilities: this.localCapabilities,
+        };
+        await this.sendMessage(peerId, {
+            type: types_1.CoordinationMessageType.AUTH_CHALLENGE,
+            messageId: (0, types_1.generateMessageId)(),
+            senderId: this.config.localIdentity.agentId,
+            payload,
+            timestamp,
+        });
+    }
+    async handleAuthChallenge(peerId, peerState, payload, messageId) {
+        this.log(`Received auth challenge from ${peerId}`);
+        this.updatePeerState(peerId, types_1.CoordinationState.AUTHENTICATING);
+        // Update peer capabilities
+        peerState.info.capabilities = payload.capabilities;
+        // Create identity proof by signing the challenge
+        const identityProof = await this.createIdentityProof(payload.challenge, payload.expiresIn);
+        const response = {
+            identityProof,
+            capabilities: this.localCapabilities,
+        };
+        await this.sendMessage(peerId, {
+            type: types_1.CoordinationMessageType.AUTH_RESPONSE,
+            messageId: (0, types_1.generateMessageId)(),
+            correlationId: messageId,
+            senderId: this.config.localIdentity.agentId,
+            payload: response,
+            timestamp: Date.now(),
+        });
+    }
+    async handleAuthResponse(peerId, peerState, payload, correlationId) {
+        this.log(`Received auth response from ${peerId}`);
+        // Verify we have a pending challenge
+        if (!peerState.pendingChallenge) {
+            throw new types_1.CoordinationError('No pending challenge', types_1.CoordinationErrorCode.AUTH_FAILED, peerId);
+        }
+        // Check challenge hasn't expired
+        if (Date.now() > peerState.pendingChallenge.expiresAt) {
+            throw new types_1.CoordinationError('Challenge expired', types_1.CoordinationErrorCode.AUTH_TIMEOUT, peerId);
+        }
+        // Verify the identity proof
+        const isValid = await this.verifyIdentityProof(payload.identityProof, peerState.pendingChallenge.challenge);
+        // Clear pending challenge
+        peerState.pendingChallenge = undefined;
+        if (!isValid) {
+            peerState.info.isAuthenticated = false;
+            this.emit(types_1.CoordinationEventType.AUTH_FAILED, peerId, { reason: 'Invalid signature' });
+            await this.sendMessage(peerId, {
+                type: types_1.CoordinationMessageType.AUTH_RESULT,
+                messageId: (0, types_1.generateMessageId)(),
+                correlationId,
+                senderId: this.config.localIdentity.agentId,
+                payload: { success: false, error: 'Invalid signature' },
+                timestamp: Date.now(),
+            });
+            return;
+        }
+        // Check trust if callback provided
+        if (this.config.onVerifyTrust) {
+            const identity = {
+                agentId: payload.identityProof.agentId,
+                publicKey: payload.identityProof.publicKey,
+                createdAt: new Date().toISOString(),
+            };
+            const isTrusted = await this.config.onVerifyTrust(identity);
+            peerState.info.isTrusted = isTrusted;
+        }
+        // Update peer info
+        peerState.info.identity = {
+            agentId: payload.identityProof.agentId,
+            publicKey: payload.identityProof.publicKey,
+            createdAt: new Date().toISOString(),
+        };
+        peerState.info.publicKey = payload.identityProof.publicKey;
+        peerState.info.capabilities = payload.capabilities;
+        peerState.info.isAuthenticated = true;
+        // Generate session ID using cryptographically secure random
+        const randomBytes = new Uint8Array(4);
+        crypto.getRandomValues(randomBytes);
+        const randomPart = Array.from(randomBytes).map(b => b.toString(36)).join('').substring(0, 6);
+        const sessionId = `session-${Date.now().toString(36)}-${randomPart}`;
+        peerState.sessionId = sessionId;
+        // Send success result
+        await this.sendMessage(peerId, {
+            type: types_1.CoordinationMessageType.AUTH_RESULT,
+            messageId: (0, types_1.generateMessageId)(),
+            correlationId,
+            senderId: this.config.localIdentity.agentId,
+            payload: {
+                success: true,
+                sessionId,
+                capabilities: this.localCapabilities,
+            },
+            timestamp: Date.now(),
+        });
+        this.log(`Peer ${peerId} authenticated successfully`);
+        this.emit(types_1.CoordinationEventType.PEER_AUTHENTICATED, peerId, {
+            identity: peerState.info.identity,
+            sessionId,
+        });
+        // Update state based on sync config
+        if (this.config.syncConfig.autoSyncOnConnect) {
+            this.updatePeerState(peerId, types_1.CoordinationState.SYNCING);
+        }
+        else {
+            this.updatePeerState(peerId, types_1.CoordinationState.SYNCHRONIZED);
+        }
+    }
+    async handleAuthResult(peerId, peerState, payload) {
+        if (!payload.success) {
+            this.logError(`Authentication failed with ${peerId}: ${payload.error}`);
+            peerState.info.isAuthenticated = false;
+            this.updatePeerState(peerId, types_1.CoordinationState.ERROR);
+            this.emit(types_1.CoordinationEventType.AUTH_FAILED, peerId, { error: payload.error });
+            return;
+        }
+        this.log(`Authentication successful with ${peerId}`);
+        peerState.info.isAuthenticated = true;
+        peerState.sessionId = payload.sessionId;
+        if (payload.capabilities) {
+            peerState.info.capabilities = payload.capabilities;
+        }
+        peerState.info.connectedAt = Date.now();
+        this.emit(types_1.CoordinationEventType.PEER_AUTHENTICATED, peerId, {
+            sessionId: payload.sessionId,
+        });
+        this.emit(types_1.CoordinationEventType.PEER_CONNECTED, peerId, {
+            capabilities: peerState.info.capabilities,
+        });
+        // Update state
+        if (this.config.syncConfig.autoSyncOnConnect) {
+            this.updatePeerState(peerId, types_1.CoordinationState.SYNCING);
+        }
+        else {
+            this.updatePeerState(peerId, types_1.CoordinationState.SYNCHRONIZED);
+        }
+    }
+    async createIdentityProof(challenge, expiresIn) {
+        // Sign the challenge with our private key
+        const encoder = new TextEncoder();
+        const data = encoder.encode(challenge);
+        // Import private key and sign
+        // In a real implementation, use proper Ed25519 signing via @noble/ed25519
+        // For browser compatibility, we use a simplified approach
+        const signature = await this.signData(data);
+        return {
+            agentId: this.config.localIdentity.agentId,
+            publicKey: this.config.localKeyPair.publicKey,
+            challenge,
+            signature: this.arrayToBase64(signature),
+            timestamp: new Date().toISOString(),
+            expiresIn,
+        };
+    }
+    async verifyIdentityProof(proof, expectedChallenge) {
+        // Verify challenge matches
+        if (proof.challenge !== expectedChallenge) {
+            return false;
+        }
+        // Check expiration
+        const proofTime = new Date(proof.timestamp).getTime();
+        if (Date.now() > proofTime + proof.expiresIn) {
+            return false;
+        }
+        // Verify signature
+        // In a real implementation, use proper Ed25519 verification
+        try {
+            const encoder = new TextEncoder();
+            const data = encoder.encode(proof.challenge);
+            const signature = this.base64ToArray(proof.signature);
+            const publicKey = this.base64ToArray(proof.publicKey);
+            return await this.verifySignature(data, signature, publicKey);
+        }
+        catch {
+            return false;
+        }
+    }
+    // ============================================
+    // Private - Health Monitoring
+    // ============================================
+    async handlePing(peerId, peerState, payload) {
+        const pong = {
+            sequence: payload.sequence,
+            originalTimestamp: payload.timestamp,
+            timestamp: Date.now(),
+        };
+        await this.sendMessage(peerId, {
+            type: types_1.CoordinationMessageType.PONG,
+            messageId: (0, types_1.generateMessageId)(),
+            senderId: this.config.localIdentity.agentId,
+            payload: pong,
+            timestamp: Date.now(),
+        });
+    }
+    async handlePong(_peerId, peerState, payload) {
+        peerState.healthMonitor.recordPong(payload.sequence, payload.originalTimestamp, payload.timestamp);
+    }
+    async handleCapabilities(peerId, peerState, capabilities) {
+        peerState.info.capabilities = capabilities;
+        this.log(`Updated capabilities for ${peerId}`);
+    }
+    async handleConflict(peerId, peerState, payload) {
+        peerState.info.metrics.conflictsDetected++;
+        this.emit(types_1.CoordinationEventType.CONFLICT_DETECTED, peerId, payload);
+    }
+    async handleError(peerId, _peerState, payload) {
+        this.logError(`Received error from ${peerId}:`, payload);
+        this.emit(types_1.CoordinationEventType.ERROR, peerId, payload);
+    }
+    async handleDisconnect(peerId, _peerState, payload) {
+        this.log(`Peer ${peerId} disconnected: ${payload.reason ?? 'no reason given'}`);
+        this.cleanupPeer(peerId);
+        this.emit(types_1.CoordinationEventType.PEER_DISCONNECTED, peerId, payload);
+    }
+    // ============================================
+    // Private - Peer State Management
+    // ============================================
+    createPeerState(peerId, role) {
+        const info = {
+            peerId,
+            state: types_1.CoordinationState.DISCONNECTED,
+            role,
+            health: (0, types_1.createDefaultHealthStatus)(),
+            metrics: (0, types_1.createDefaultMetrics)(),
+            syncStatus: (0, types_1.createDefaultSyncStatus)(),
+            isAuthenticated: false,
+            isTrusted: false,
+            capabilities: (0, types_1.createDefaultCapabilities)(),
+            lastSeenAt: Date.now(),
+            reconnectAttempts: 0,
+        };
+        const healthMonitor = new HealthMonitor_1.HealthMonitor({
+            peerId,
+            pingInterval: this.config.pingInterval,
+            onPing: async (sequence) => {
+                await this.sendPing(peerId, sequence);
+            },
+            onHealthChange: (health) => {
+                const peerState = this.peers.get(peerId);
+                if (peerState) {
+                    peerState.info.health = health;
+                    this.handleHealthChange(peerId, health);
+                }
+            },
+        });
+        const syncOrchestrator = new SyncOrchestrator_1.SyncOrchestrator({
+            localAgentId: this.config.localIdentity.agentId,
+            peerId,
+            config: this.config.syncConfig,
+            sendMessage: async (message) => {
+                await this.sendMessage(peerId, message);
+            },
+            onSyncProgress: (status) => {
+                const peerState = this.peers.get(peerId);
+                if (peerState) {
+                    peerState.info.syncStatus = status;
+                    this.emit(types_1.CoordinationEventType.SYNC_PROGRESS, peerId, status);
+                }
+            },
+        });
+        return {
+            info,
+            healthMonitor,
+            syncOrchestrator,
+            pendingResponses: new Map(),
+            lastSequence: 0,
+        };
+    }
+    updatePeerState(peerId, newState) {
+        const peerState = this.peers.get(peerId);
+        if (!peerState) {
+            return;
+        }
+        const previousState = peerState.info.state;
+        peerState.info.state = newState;
+        this.emit(types_1.CoordinationEventType.STATE_CHANGED, peerId, {
+            previousState,
+            newState,
+        });
+    }
+    handleHealthChange(peerId, health) {
+        if (health.level === types_1.HealthLevel.WARNING) {
+            this.emit(types_1.CoordinationEventType.HEALTH_WARNING, peerId, health);
+            // Update state to degraded if currently synchronized
+            const peerState = this.peers.get(peerId);
+            if (peerState?.info.state === types_1.CoordinationState.SYNCHRONIZED) {
+                this.updatePeerState(peerId, types_1.CoordinationState.DEGRADED);
+            }
+        }
+        else if (health.level === types_1.HealthLevel.CRITICAL || health.level === types_1.HealthLevel.UNHEALTHY) {
+            this.emit(types_1.CoordinationEventType.HEALTH_CRITICAL, peerId, health);
+            // Trigger reconnection if configured
+            if (this.config.autoReconnect) {
+                this.attemptReconnection(peerId);
+            }
+        }
+        else if (health.level === types_1.HealthLevel.HEALTHY) {
+            // Recover from degraded state
+            const peerState = this.peers.get(peerId);
+            if (peerState?.info.state === types_1.CoordinationState.DEGRADED) {
+                this.updatePeerState(peerId, types_1.CoordinationState.SYNCHRONIZED);
+                this.emit(types_1.CoordinationEventType.HEALTH_RECOVERED, peerId, health);
+            }
+        }
+    }
+    async attemptReconnection(peerId) {
+        const peerState = this.peers.get(peerId);
+        if (!peerState) {
+            return;
+        }
+        if (peerState.info.reconnectAttempts >= this.config.maxReconnectAttempts) {
+            this.logError(`Max reconnection attempts reached for ${peerId}`);
+            this.updatePeerState(peerId, types_1.CoordinationState.ERROR);
+            this.emit(types_1.CoordinationEventType.RECONNECT_FAILED, peerId, {
+                attempts: peerState.info.reconnectAttempts,
+            });
+            return;
+        }
+        peerState.info.reconnectAttempts++;
+        peerState.info.metrics.reconnectionAttempts++;
+        this.updatePeerState(peerId, types_1.CoordinationState.RECONNECTING);
+        this.emit(types_1.CoordinationEventType.RECONNECTING, peerId, {
+            attempt: peerState.info.reconnectAttempts,
+            maxAttempts: this.config.maxReconnectAttempts,
+        });
+        // Exponential backoff
+        const delay = Math.min(1000 * Math.pow(2, peerState.info.reconnectAttempts - 1), this.config.reconnectTimeout);
+        await this.delay(delay);
+        try {
+            // Reset authentication state
+            peerState.info.isAuthenticated = false;
+            peerState.pendingChallenge = undefined;
+            peerState.sessionId = undefined;
+            // Attempt to reconnect
+            await this.sendAuthChallenge(peerId, peerState);
+        }
+        catch (error) {
+            this.logError(`Reconnection attempt ${peerState.info.reconnectAttempts} failed:`, error);
+            await this.attemptReconnection(peerId);
+        }
+    }
+    cleanupPeer(peerId) {
+        const peerState = this.peers.get(peerId);
+        if (!peerState) {
+            return;
+        }
+        // Stop health monitoring
+        peerState.healthMonitor.stop();
+        // Stop sync orchestrator
+        peerState.syncOrchestrator.stop();
+        // Clear pending responses
+        peerState.pendingResponses.forEach((pending) => {
+            clearTimeout(pending.timeout);
+            pending.reject(new Error('Peer disconnected'));
+        });
+        peerState.pendingResponses.clear();
+        // Remove from peers map
+        this.peers.delete(peerId);
+    }
+    getPeerStateOrThrow(peerId) {
+        const peerState = this.peers.get(peerId);
+        if (!peerState) {
+            throw new types_1.CoordinationError(`Peer not found: ${peerId}`, types_1.CoordinationErrorCode.PEER_NOT_FOUND, peerId);
+        }
+        return peerState;
+    }
+    // ============================================
+    // Private - Messaging
+    // ============================================
+    async sendMessage(peerId, message) {
+        if (!this.messageSender) {
+            throw new types_1.CoordinationError('No message sender configured', types_1.CoordinationErrorCode.CONNECTION_FAILED, peerId);
+        }
+        const peerState = this.peers.get(peerId);
+        if (peerState) {
+            peerState.info.metrics.messagesSent++;
+        }
+        await this.messageSender(peerId, message);
+    }
+    async sendPing(peerId, sequence) {
+        const payload = {
+            sequence,
+            timestamp: Date.now(),
+        };
+        await this.sendMessage(peerId, {
+            type: types_1.CoordinationMessageType.PING,
+            messageId: (0, types_1.generateMessageId)(),
+            senderId: this.config.localIdentity.agentId,
+            payload,
+            timestamp: Date.now(),
+        });
+    }
+    // ============================================
+    // Private - Crypto Helpers
+    // ============================================
+    async signData(data) {
+        // Simplified signing using Web Crypto API
+        // In production, use proper Ed25519 signing via @noble/ed25519
+        const keyData = this.base64ToArray(this.config.localKeyPair.privateKey);
+        // Use HMAC as a placeholder for Ed25519 signing
+        // This is for demonstration - use proper Ed25519 in production
+        const key = await crypto.subtle.importKey('raw', keyData.slice(0, 32).buffer, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+        const signature = await crypto.subtle.sign('HMAC', key, data.buffer);
+        return new Uint8Array(signature);
+    }
+    async verifySignature(data, signature, publicKey) {
+        // Simplified verification using Web Crypto API
+        // In production, use proper Ed25519 verification
+        try {
+            const key = await crypto.subtle.importKey('raw', publicKey.buffer, { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
+            return await crypto.subtle.verify('HMAC', key, signature.buffer, data.buffer);
+        }
+        catch {
+            return false;
+        }
+    }
+    arrayToBase64(array) {
+        return btoa(Array.from(array).map((b) => String.fromCharCode(b)).join(''));
+    }
+    base64ToArray(base64) {
+        const binary = atob(base64);
+        const array = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            array[i] = binary.charCodeAt(i);
+        }
+        return array;
+    }
+    // ============================================
+    // Private - Utilities
+    // ============================================
+    emit(type, peerId, data) {
+        const event = {
+            type,
+            timestamp: Date.now(),
+            peerId,
+            data,
+        };
+        const handlers = this.eventHandlers.get(type);
+        handlers?.forEach((handler) => {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                this.logError(`Event handler error for ${type}:`, error);
+            }
+        });
+    }
+    ensureNotDestroyed() {
+        if (this.isDestroyed) {
+            throw new types_1.CoordinationError('CoordinationManager has been destroyed', types_1.CoordinationErrorCode.CONNECTION_CLOSED);
+        }
+    }
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    setupLogging() {
+        const noop = () => { };
+        if (!this.config.enableLogging) {
+            this.log = noop;
+            this.logDebug = noop;
+            this.logWarn = noop;
+            this.logError = noop;
+            return;
+        }
+        const prefix = '[CoordinationManager]';
+        this.log = (...args) => console.log(prefix, ...args);
+        this.logDebug = this.config.logLevel === 'debug'
+            ? (...args) => console.debug(prefix, ...args)
+            : noop;
+        this.logWarn = ['debug', 'info', 'warn'].includes(this.config.logLevel)
+            ? (...args) => console.warn(prefix, ...args)
+            : noop;
+        this.logError = (...args) => console.error(prefix, ...args);
+    }
+}
+exports.CoordinationManager = CoordinationManager;
+// ============================================
+// Factory Functions
+// ============================================
+/**
+ * Create a new CoordinationManager instance
+ */
+function createCoordinationManager(config) {
+    return new CoordinationManager(config);
+}
+//# sourceMappingURL=CoordinationManager.js.map