agentic-flow 2.0.3 → 2.0.4

package/dist/swarm/real-p2p-swarm.d.ts

@@ -1,183 +0,0 @@
-/**
- * Real P2P Swarm Coordination
- *
- * IMPROVED VERSION with actual P2P connections:
- * - Real GunDB relay connections
- * - Actual WebRTC via PeerJS
- * - Persistent learning storage
- * - Better error handling
- */
-/**
- * Encryption utilities
- */
-declare class SwarmCrypto {
-    private algorithm;
-    generateKey(): string;
-    encrypt(data: string, keyBase64: string): {
-        ciphertext: string;
-        iv: string;
-        tag: string;
-    };
-    decrypt(ciphertext: string, keyBase64: string, ivBase64: string, tagBase64: string): string;
-    hash(data: string): string;
-}
-/**
- * Real GunDB Swarm (connects to actual relays)
- */
-export declare class RealGunDBSwarm {
-    private gun;
-    private swarmNode;
-    private crypto;
-    private swarmKey;
-    private swarmId;
-    private connected;
-    static readonly FREE_RELAYS: string[];
-    constructor(swarmKey?: string, relays?: string[]);
-    /**
-     * Connect to GunDB relays
-     */
-    connect(relays?: string[]): Promise<boolean>;
-    /**
-     * Register agent with swarm
-     */
-    registerAgent(agentId: string, capabilities: string[]): Promise<void>;
-    /**
-     * Publish message to swarm (real-time sync)
-     */
-    publish(topic: string, data: any): Promise<string>;
-    /**
-     * Subscribe to topic
-     */
-    subscribe(topic: string, callback: (data: any) => void): void;
-    /**
-     * Sync Q-table to swarm
-     */
-    syncQTable(agentId: string, qTable: number[][]): Promise<string>;
-    /**
-     * Sync memory vectors
-     */
-    syncMemory(agentId: string, vectors: number[][], namespace: string): Promise<string>;
-    /**
-     * Get connection status
-     */
-    isConnected(): boolean;
-    /**
-     * Get swarm key (for sharing)
-     */
-    getSwarmKey(): string;
-    /**
-     * Get swarm ID
-     */
-    getSwarmId(): string;
-}
-/**
- * Real WebRTC Swarm (using PeerJS)
- */
-export declare class RealWebRTCSwarm {
-    private peer;
-    private connections;
-    private crypto;
-    private swarmKey;
-    private swarmId;
-    private peerId;
-    constructor(swarmKey?: string);
-    /**
-     * Initialize PeerJS connection
-     */
-    initialize(agentId: string): Promise<string | null>;
-    /**
-     * Handle incoming connection
-     */
-    private handleConnection;
-    /**
-     * Handle decrypted message
-     */
-    private handleMessage;
-    /**
-     * Connect to another peer
-     */
-    connectToPeer(peerId: string): Promise<boolean>;
-    /**
-     * Send encrypted message to peer
-     */
-    sendToPeer(peerId: string, data: any): Promise<boolean>;
-    /**
-     * Broadcast to all connected peers
-     */
-    broadcast(data: any): Promise<number>;
-    /**
-     * Get connected peer count
-     */
-    getConnectedPeers(): number;
-    /**
-     * Get peer ID
-     */
-    getPeerId(): string | null;
-    /**
-     * Disconnect
-     */
-    disconnect(): void;
-}
-/**
- * Combined Real P2P Swarm Coordinator
- */
-export declare class RealP2PSwarmCoordinator {
-    private gundb;
-    private webrtc;
-    private swarmKey;
-    private initialized;
-    constructor(swarmKey?: string);
-    /**
-     * Initialize all P2P connections
-     */
-    initialize(agentId: string): Promise<{
-        gundb: boolean;
-        webrtc: boolean;
-        swarmId: string;
-    }>;
-    /**
-     * Publish via GunDB (real-time)
-     */
-    publish(topic: string, data: any): Promise<string>;
-    /**
-     * Subscribe via GunDB
-     */
-    subscribe(topic: string, callback: (data: any) => void): void;
-    /**
-     * Send direct P2P message
-     */
-    sendDirect(peerId: string, data: any): Promise<boolean>;
-    /**
-     * Broadcast via WebRTC
-     */
-    broadcastDirect(data: any): Promise<number>;
-    /**
-     * Sync learning state
-     */
-    syncLearning(agentId: string, qTable: number[][], vectors?: number[][]): Promise<{
-        qTableId: string;
-        memoryId?: string;
-    }>;
-    /**
-     * Get status
-     */
-    getStatus(): {
-        gundb: boolean;
-        webrtc: {
-            connected: boolean;
-            peers: number;
-        };
-        swarmId: string;
-        swarmKey: string;
-    };
-    /**
-     * Cleanup
-     */
-    disconnect(): void;
-}
-/**
- * Quick start helper
- */
-export declare function createRealP2PSwarm(agentId: string, swarmKey?: string): Promise<RealP2PSwarmCoordinator>;
-export { SwarmCrypto };
-//# sourceMappingURL=real-p2p-swarm.d.ts.map

package/dist/swarm/real-p2p-swarm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"real-p2p-swarm.d.ts","sourceRoot":"","sources":["../../src/swarm/real-p2p-swarm.ts"],"names":[],"mappings":"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"}

package/dist/swarm/real-p2p-swarm.js

@@ -1,469 +0,0 @@
-/**
- * Real P2P Swarm Coordination
- *
- * IMPROVED VERSION with actual P2P connections:
- * - Real GunDB relay connections
- * - Actual WebRTC via PeerJS
- * - Persistent learning storage
- * - Better error handling
- */
-import crypto from 'crypto';
-import { logger } from '../utils/logger.js';
-// Lazy-load P2P modules
-let Gun = null;
-let Peer = null;
-/**
- * Load GunDB (lazy)
- */
-async function getGun() {
-    if (!Gun) {
-        try {
-            Gun = (await import('gun')).default;
-        }
-        catch {
-            logger.warn('GunDB not installed. Run: npm install gun');
-            return null;
-        }
-    }
-    return Gun;
-}
-/**
- * Load PeerJS (lazy)
- */
-async function getPeer() {
-    if (!Peer) {
-        try {
-            const peerjs = await import('peerjs');
-            Peer = peerjs.Peer || peerjs.default;
-        }
-        catch {
-            logger.warn('PeerJS not installed. Run: npm install peerjs');
-            return null;
-        }
-    }
-    return Peer;
-}
-/**
- * Encryption utilities
- */
-class SwarmCrypto {
-    algorithm = 'aes-256-gcm';
-    generateKey() {
-        return crypto.randomBytes(32).toString('base64');
-    }
-    encrypt(data, keyBase64) {
-        const key = Buffer.from(keyBase64, 'base64');
-        const iv = crypto.randomBytes(16);
-        const cipher = crypto.createCipheriv(this.algorithm, key, iv);
-        let ciphertext = cipher.update(data, 'utf8', 'base64');
-        ciphertext += cipher.final('base64');
-        return {
-            ciphertext,
-            iv: iv.toString('base64'),
-            tag: cipher.getAuthTag().toString('base64'),
-        };
-    }
-    decrypt(ciphertext, keyBase64, ivBase64, tagBase64) {
-        const key = Buffer.from(keyBase64, 'base64');
-        const iv = Buffer.from(ivBase64, 'base64');
-        const tag = Buffer.from(tagBase64, 'base64');
-        const decipher = crypto.createDecipheriv(this.algorithm, key, iv);
-        decipher.setAuthTag(tag);
-        let plaintext = decipher.update(ciphertext, 'base64', 'utf8');
-        plaintext += decipher.final('utf8');
-        return plaintext;
-    }
-    hash(data) {
-        return crypto.createHash('sha256').update(data).digest('hex');
-    }
-}
-/**
- * Real GunDB Swarm (connects to actual relays)
- */
-export class RealGunDBSwarm {
-    gun = null;
-    swarmNode = null;
-    crypto;
-    swarmKey;
-    swarmId;
-    connected = false;
-    static FREE_RELAYS = [
-        'https://gun-manhattan.herokuapp.com/gun',
-        'https://gun-us.herokuapp.com/gun',
-        'https://gun-eu.herokuapp.com/gun',
-    ];
-    constructor(swarmKey, relays) {
-        this.crypto = new SwarmCrypto();
-        this.swarmKey = swarmKey || this.crypto.generateKey();
-        this.swarmId = this.crypto.hash(this.swarmKey).slice(0, 16);
-    }
-    /**
-     * Connect to GunDB relays
-     */
-    async connect(relays) {
-        const GunDB = await getGun();
-        if (!GunDB) {
-            logger.warn('GunDB not available, using simulation mode');
-            return false;
-        }
-        try {
-            this.gun = GunDB(relays || RealGunDBSwarm.FREE_RELAYS);
-            this.swarmNode = this.gun.get(`agentic-flow-swarm-${this.swarmId}`);
-            this.connected = true;
-            logger.info('Connected to GunDB relays', {
-                swarmId: this.swarmId,
-                relays: relays?.length || RealGunDBSwarm.FREE_RELAYS.length,
-            });
-            return true;
-        }
-        catch (error) {
-            logger.error('Failed to connect to GunDB', { error });
-            return false;
-        }
-    }
-    /**
-     * Register agent with swarm
-     */
-    async registerAgent(agentId, capabilities) {
-        if (!this.connected || !this.swarmNode) {
-            logger.warn('Not connected to GunDB');
-            return;
-        }
-        const agentData = {
-            id: agentId,
-            capabilities: capabilities.join(','),
-            joinedAt: Date.now(),
-            status: 'active',
-        };
-        // Encrypt sensitive data
-        const encrypted = this.crypto.encrypt(JSON.stringify(agentData), this.swarmKey);
-        this.swarmNode.get('agents').get(agentId).put({
-            ...encrypted,
-            agentId, // Keep ID visible for routing
-        });
-        logger.debug('Agent registered to GunDB', { agentId });
-    }
-    /**
-     * Publish message to swarm (real-time sync)
-     */
-    async publish(topic, data) {
-        const messageId = this.crypto.hash(JSON.stringify(data) + Date.now()).slice(0, 16);
-        const message = {
-            id: messageId,
-            topic,
-            timestamp: Date.now(),
-        };
-        // Encrypt payload
-        const encrypted = this.crypto.encrypt(JSON.stringify(data), this.swarmKey);
-        if (this.connected && this.swarmNode) {
-            this.swarmNode.get('messages').get(topic).get(messageId).put({
-                ...message,
-                ...encrypted,
-            });
-        }
-        return messageId;
-    }
-    /**
-     * Subscribe to topic
-     */
-    subscribe(topic, callback) {
-        if (!this.connected || !this.swarmNode) {
-            logger.warn('Not connected to GunDB');
-            return;
-        }
-        this.swarmNode.get('messages').get(topic).map().on((msg, id) => {
-            if (msg && msg.ciphertext) {
-                try {
-                    const decrypted = this.crypto.decrypt(msg.ciphertext, this.swarmKey, msg.iv, msg.tag);
-                    callback(JSON.parse(decrypted));
-                }
-                catch (error) {
-                    // Ignore decryption errors (wrong key)
-                }
-            }
-        });
-    }
-    /**
-     * Sync Q-table to swarm
-     */
-    async syncQTable(agentId, qTable) {
-        return this.publish('q_table_sync', {
-            agentId,
-            qTable,
-            dimensions: `${qTable.length}x${qTable[0]?.length || 0}`,
-        });
-    }
-    /**
-     * Sync memory vectors
-     */
-    async syncMemory(agentId, vectors, namespace) {
-        return this.publish('memory_sync', {
-            agentId,
-            vectorCount: vectors.length,
-            dimensions: vectors[0]?.length || 0,
-            namespace,
-            checksum: this.crypto.hash(JSON.stringify(vectors)).slice(0, 8),
-        });
-    }
-    /**
-     * Get connection status
-     */
-    isConnected() {
-        return this.connected;
-    }
-    /**
-     * Get swarm key (for sharing)
-     */
-    getSwarmKey() {
-        return this.swarmKey;
-    }
-    /**
-     * Get swarm ID
-     */
-    getSwarmId() {
-        return this.swarmId;
-    }
-}
-/**
- * Real WebRTC Swarm (using PeerJS)
- */
-export class RealWebRTCSwarm {
-    peer = null;
-    connections = new Map();
-    crypto;
-    swarmKey;
-    swarmId;
-    peerId = null;
-    constructor(swarmKey) {
-        this.crypto = new SwarmCrypto();
-        this.swarmKey = swarmKey || this.crypto.generateKey();
-        this.swarmId = this.crypto.hash(this.swarmKey).slice(0, 16);
-    }
-    /**
-     * Initialize PeerJS connection
-     */
-    async initialize(agentId) {
-        const PeerClass = await getPeer();
-        if (!PeerClass) {
-            logger.warn('PeerJS not available');
-            return null;
-        }
-        return new Promise((resolve) => {
-            try {
-                this.peerId = `swarm-${this.swarmId}-${agentId}`;
-                this.peer = new PeerClass(this.peerId);
-                this.peer.on('open', (id) => {
-                    logger.info('WebRTC peer connected', { peerId: id });
-                    resolve(id);
-                });
-                this.peer.on('connection', (conn) => {
-                    this.handleConnection(conn);
-                });
-                this.peer.on('error', (err) => {
-                    logger.error('PeerJS error', { error: err.message });
-                    resolve(null);
-                });
-                // Timeout after 10 seconds
-                setTimeout(() => resolve(null), 10000);
-            }
-            catch (error) {
-                logger.error('Failed to initialize PeerJS', { error });
-                resolve(null);
-            }
-        });
-    }
-    /**
-     * Handle incoming connection
-     */
-    handleConnection(conn) {
-        conn.on('open', () => {
-            this.connections.set(conn.peer, conn);
-            logger.debug('Peer connected', { peer: conn.peer });
-        });
-        conn.on('data', (data) => {
-            if (data.encrypted) {
-                try {
-                    const decrypted = this.crypto.decrypt(data.ciphertext, this.swarmKey, data.iv, data.tag);
-                    this.handleMessage(JSON.parse(decrypted), conn.peer);
-                }
-                catch {
-                    // Ignore decryption errors
-                }
-            }
-        });
-        conn.on('close', () => {
-            this.connections.delete(conn.peer);
-        });
-    }
-    /**
-     * Handle decrypted message
-     */
-    handleMessage(message, from) {
-        logger.debug('Received P2P message', { from, type: message.type });
-        // Override in subclass or add event emitter
-    }
-    /**
-     * Connect to another peer
-     */
-    async connectToPeer(peerId) {
-        if (!this.peer) {
-            return false;
-        }
-        return new Promise((resolve) => {
-            const conn = this.peer.connect(peerId);
-            conn.on('open', () => {
-                this.connections.set(peerId, conn);
-                resolve(true);
-            });
-            conn.on('error', () => {
-                resolve(false);
-            });
-            setTimeout(() => resolve(false), 5000);
-        });
-    }
-    /**
-     * Send encrypted message to peer
-     */
-    async sendToPeer(peerId, data) {
-        const conn = this.connections.get(peerId);
-        if (!conn) {
-            return false;
-        }
-        const encrypted = this.crypto.encrypt(JSON.stringify(data), this.swarmKey);
-        conn.send({
-            encrypted: true,
-            ...encrypted,
-        });
-        return true;
-    }
-    /**
-     * Broadcast to all connected peers
-     */
-    async broadcast(data) {
-        let sent = 0;
-        for (const [peerId] of this.connections) {
-            if (await this.sendToPeer(peerId, data)) {
-                sent++;
-            }
-        }
-        return sent;
-    }
-    /**
-     * Get connected peer count
-     */
-    getConnectedPeers() {
-        return this.connections.size;
-    }
-    /**
-     * Get peer ID
-     */
-    getPeerId() {
-        return this.peerId;
-    }
-    /**
-     * Disconnect
-     */
-    disconnect() {
-        if (this.peer) {
-            this.peer.destroy();
-            this.peer = null;
-        }
-        this.connections.clear();
-    }
-}
-/**
- * Combined Real P2P Swarm Coordinator
- */
-export class RealP2PSwarmCoordinator {
-    gundb;
-    webrtc;
-    swarmKey;
-    initialized = false;
-    constructor(swarmKey) {
-        const crypto = new SwarmCrypto();
-        this.swarmKey = swarmKey || crypto.generateKey();
-        this.gundb = new RealGunDBSwarm(this.swarmKey);
-        this.webrtc = new RealWebRTCSwarm(this.swarmKey);
-    }
-    /**
-     * Initialize all P2P connections
-     */
-    async initialize(agentId) {
-        const gundbConnected = await this.gundb.connect();
-        const webrtcPeerId = await this.webrtc.initialize(agentId);
-        if (gundbConnected) {
-            await this.gundb.registerAgent(agentId, ['coordinator']);
-        }
-        this.initialized = true;
-        return {
-            gundb: gundbConnected,
-            webrtc: webrtcPeerId !== null,
-            swarmId: this.gundb.getSwarmId(),
-        };
-    }
-    /**
-     * Publish via GunDB (real-time)
-     */
-    async publish(topic, data) {
-        return this.gundb.publish(topic, data);
-    }
-    /**
-     * Subscribe via GunDB
-     */
-    subscribe(topic, callback) {
-        this.gundb.subscribe(topic, callback);
-    }
-    /**
-     * Send direct P2P message
-     */
-    async sendDirect(peerId, data) {
-        return this.webrtc.sendToPeer(peerId, data);
-    }
-    /**
-     * Broadcast via WebRTC
-     */
-    async broadcastDirect(data) {
-        return this.webrtc.broadcast(data);
-    }
-    /**
-     * Sync learning state
-     */
-    async syncLearning(agentId, qTable, vectors) {
-        const qTableId = await this.gundb.syncQTable(agentId, qTable);
-        let memoryId;
-        if (vectors && vectors.length > 0) {
-            memoryId = await this.gundb.syncMemory(agentId, vectors, 'default');
-        }
-        return { qTableId, memoryId };
-    }
-    /**
-     * Get status
-     */
-    getStatus() {
-        return {
-            gundb: this.gundb.isConnected(),
-            webrtc: {
-                connected: this.webrtc.getPeerId() !== null,
-                peers: this.webrtc.getConnectedPeers(),
-            },
-            swarmId: this.gundb.getSwarmId(),
-            swarmKey: this.swarmKey,
-        };
-    }
-    /**
-     * Cleanup
-     */
-    disconnect() {
-        this.webrtc.disconnect();
-    }
-}
-/**
- * Quick start helper
- */
-export async function createRealP2PSwarm(agentId, swarmKey) {
-    const swarm = new RealP2PSwarmCoordinator(swarmKey);
-    await swarm.initialize(agentId);
-    return swarm;
-}
-export { SwarmCrypto };
-//# sourceMappingURL=real-p2p-swarm.js.map