@bolloon/bolloon-agent 0.1.1 → 0.1.2

package/dist/network/agent-network.js

@@ -1,49 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.agentMessaging = exports.AgentMessaging = exports.agentRegistry = exports.AgentRegistry = void 0;
-exports.initializeAgentNetwork = initializeAgentNetwork;
-exports.broadcastOwnAddress = broadcastOwnAddress;
-exports.findAndConnectToAgent = findAndConnectToAgent;
-exports.sendMessageToAgent = sendMessageToAgent;
-exports.sendUnverifiedMessageToAgent = sendUnverifiedMessageToAgent;
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const multiaddr_1 = require("@multiformats/multiaddr");
-const sdk_1 = require("@diap/sdk");
-const p2p_js_1 = require("./p2p.js");
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { multiaddr as createMultiaddr } from '@multiformats/multiaddr';
+import { KeyManager } from '@diap/sdk';
+import { p2pNetwork } from './p2p.js';
 const AGENT_REGISTRY_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'agent-registry.json');
 const KEY_PAIR_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'keypair.json');
 const ADDRESS_BROADCAST_INTERVAL = 5 * 60 * 1000;
@@ -51,7 +10,7 @@ const RELAY_RETRY_INTERVAL = 30000;
 const MAX_RELAY_HOPS = 3;
 const MESSAGE_TIMESTAMP_TOLERANCE = 24 * 60 * 60 * 1000;
 const SIGNED_MESSAGE_TYPES = ['task', 'response', 'discovery', 'address_broadcast'];
-class AgentRegistry {
+export class AgentRegistry {
     agents = new Map();
     registryPath;
     ownEndpoint = null;
@@ -81,7 +40,7 @@ class AgentRegistry {
         }
         catch {
             console.log(`[Registry] Generating new keypair...`);
-            const kp = sdk_1.KeyManager.generate();
+            const kp = KeyManager.generate();
             this.keyPair = {
                 privateKey: kp.privateKey,
                 publicKey: kp.publicKey,
@@ -144,7 +103,7 @@ class AgentRegistry {
             return null;
         }
         try {
-            const signature = await sdk_1.KeyManager.sign(this.keyPair, new TextEncoder().encode(data));
+            const signature = await KeyManager.sign(this.keyPair, new TextEncoder().encode(data));
             return signature;
         }
         catch (e) {
@@ -161,7 +120,7 @@ class AgentRegistry {
             }
             const publicKey = Buffer.from(agent.publicKey, 'hex');
             const keyPair = { privateKey: new Uint8Array(32), publicKey, did };
-            const isValid = await sdk_1.KeyManager.verify(keyPair, new TextEncoder().encode(data), signature);
+            const isValid = await KeyManager.verify(keyPair, new TextEncoder().encode(data), signature);
             if (!isValid) {
                 console.warn(`[Registry] Invalid signature from ${did.substring(0, 20)}`);
             }
@@ -232,7 +191,7 @@ class AgentRegistry {
         if (entry && now - entry.lastBroadcast < ADDRESS_BROADCAST_INTERVAL) {
             return null;
         }
-        const relayAddr = p2p_js_1.p2pNetwork.getRelayAddress?.() || null;
+        const relayAddr = p2pNetwork.getRelayAddress?.() || null;
         const broadcastData = JSON.stringify({
             type: 'address_broadcast',
             from: this.keyPair.did,
@@ -368,8 +327,8 @@ class AgentRegistry {
         if (agent.multiaddrs && agent.multiaddrs.length > 0) {
             for (const addr of agent.multiaddrs) {
                 try {
-                    const ma = (0, multiaddr_1.multiaddr)(addr);
-                    const node = p2p_js_1.p2pNetwork.node;
+                    const ma = createMultiaddr(addr);
+                    const node = p2pNetwork.node;
                     if (node) {
                         await node.dial(ma);
                         connected = true;
@@ -385,9 +344,9 @@ class AgentRegistry {
         if (!connected && agent.relayAddr) {
             console.log(`[Registry] Trying relay connection to ${agent.name} via ${agent.relayAddr}`);
             try {
-                const node = p2p_js_1.p2pNetwork.node;
+                const node = p2pNetwork.node;
                 if (node) {
-                    const ma = (0, multiaddr_1.multiaddr)(`${agent.relayAddr}/p2p/${agent.peerId}`);
+                    const ma = createMultiaddr(`${agent.relayAddr}/p2p/${agent.peerId}`);
                     await node.dial(ma);
                     connected = true;
                     console.log(`[Registry] Relay connection to ${agent.name} established`);
@@ -406,9 +365,9 @@ class AgentRegistry {
                     console.log(`[Registry] Trying to relay via ${relay.name} (${relay.peerId.substring(0, 12)}...)`);
                     const relayAddr = relay.relayAddr || relay.multiaddrs?.[0];
                     if (relayAddr) {
-                        const node = p2p_js_1.p2pNetwork.node;
+                        const node = p2pNetwork.node;
                         if (node) {
-                            const ma = (0, multiaddr_1.multiaddr)(`${relayAddr}/p2p/${agent.peerId}`);
+                            const ma = createMultiaddr(`${relayAddr}/p2p/${agent.peerId}`);
                             await node.dial(ma);
                             connected = true;
                             console.log(`[Registry] Connection to ${agent.name} via relay ${relay.name}`);
@@ -423,7 +382,7 @@ class AgentRegistry {
         }
         if (connected) {
             this.updateLastSeen(did);
-            p2p_js_1.p2pNetwork.addPersistentPeer({
+            p2pNetwork.addPersistentPeer({
                 peerId: agent.peerId,
                 multiaddrs: agent.multiaddrs,
                 did: agent.did,
@@ -451,7 +410,7 @@ class AgentRegistry {
         try {
             const peerId = targetAgent.peerId;
             const relayMsg = new TextEncoder().encode(`RELAY:${fromDid}|${hops + 1}|${new TextDecoder().decode(data)}`);
-            await p2p_js_1.p2pNetwork.sendMessage(peerId, 'relay', new TextDecoder().decode(relayMsg));
+            await p2pNetwork.sendMessage(peerId, 'relay', new TextDecoder().decode(relayMsg));
             return true;
         }
         catch (e) {
@@ -470,9 +429,8 @@ class AgentRegistry {
         };
     }
 }
-exports.AgentRegistry = AgentRegistry;
-exports.agentRegistry = new AgentRegistry();
-class AgentMessaging {
+export const agentRegistry = new AgentRegistry();
+export class AgentMessaging {
     registry;
     messageHandlers = new Map();
     constructor(registry) {
@@ -494,7 +452,7 @@ class AgentMessaging {
         }
         try {
             const messageStr = JSON.stringify(signedMsg);
-            await p2p_js_1.p2pNetwork.sendMessage(agent.peerId, 'signed', messageStr);
+            await p2pNetwork.sendMessage(agent.peerId, 'signed', messageStr);
             return true;
         }
         catch (e) {
@@ -510,7 +468,7 @@ class AgentMessaging {
         }
         const message = `${type}:${payload}`;
         try {
-            await p2p_js_1.p2pNetwork.sendMessage(agent.peerId, type, payload);
+            await p2pNetwork.sendMessage(agent.peerId, type, payload);
             return true;
         }
         catch (e) {
@@ -525,7 +483,7 @@ class AgentMessaging {
             if (agent.did === ownEndpoint?.did)
                 continue;
             try {
-                await p2p_js_1.p2pNetwork.sendMessage(agent.peerId, type, payload);
+                await p2pNetwork.sendMessage(agent.peerId, type, payload);
             }
             catch (e) {
                 console.warn(`[Messaging] Broadcast failed to ${agent.name}:`, e);
@@ -610,36 +568,35 @@ class AgentMessaging {
         }
     }
 }
-exports.AgentMessaging = AgentMessaging;
-exports.agentMessaging = new AgentMessaging(exports.agentRegistry);
-async function initializeAgentNetwork(ownDid, ownName, peerId, multiaddrs) {
-    await exports.agentRegistry.initialize();
-    const keyPair = exports.agentRegistry.getKeyPair();
+export const agentMessaging = new AgentMessaging(agentRegistry);
+export async function initializeAgentNetwork(ownDid, ownName, peerId, multiaddrs) {
+    await agentRegistry.initialize();
+    const keyPair = agentRegistry.getKeyPair();
     const publicKeyHex = keyPair ? Buffer.from(keyPair.publicKey).toString('hex') : undefined;
-    exports.agentRegistry.setOwnEndpoint({
+    agentRegistry.setOwnEndpoint({
         did: keyPair?.did || ownDid,
         name: ownName,
         peerId,
         multiaddrs,
         publicKey: publicKeyHex
     });
-    p2p_js_1.p2pNetwork.setOwnDid(keyPair?.did || ownDid);
-    p2p_js_1.p2pNetwork.onMessage('signed', async (data, from, did) => {
-        await exports.agentMessaging.dispatchSignedMessage(data, from);
+    p2pNetwork.setOwnDid(keyPair?.did || ownDid);
+    p2pNetwork.onMessage('signed', async (data, from, did) => {
+        await agentMessaging.dispatchSignedMessage(data, from);
     });
-    p2p_js_1.p2pNetwork.onMessage('address_broadcast', async (data, from, did) => {
+    p2pNetwork.onMessage('address_broadcast', async (data, from, did) => {
         try {
             const messageStr = new TextDecoder().decode(data);
             const broadcast = JSON.parse(messageStr);
             if (broadcast.type === 'address_broadcast') {
-                await exports.agentRegistry.handleAddressBroadcast(broadcast);
+                await agentRegistry.handleAddressBroadcast(broadcast);
             }
         }
         catch (e) {
             console.warn(`[AgentNetwork] Failed to handle address broadcast:`, e);
         }
     });
-    p2p_js_1.p2pNetwork.onMessage('relay', (data, from, did) => {
+    p2pNetwork.onMessage('relay', (data, from, did) => {
         try {
             const relayMsg = new TextDecoder().decode(data);
             const relayMatch = relayMsg.match(/^RELAY:(.+?)\|(\d+)\|(.+)$/);
@@ -647,7 +604,7 @@ async function initializeAgentNetwork(ownDid, ownName, peerId, multiaddrs) {
                 const [, targetDid, hopsStr, innerData] = relayMatch;
                 const hops = parseInt(hopsStr, 10);
                 if (hops < MAX_RELAY_HOPS) {
-                    exports.agentRegistry.relayMessage(targetDid, new TextEncoder().encode(innerData), did || from, hops);
+                    agentRegistry.relayMessage(targetDid, new TextEncoder().encode(innerData), did || from, hops);
                 }
             }
         }
@@ -655,12 +612,12 @@ async function initializeAgentNetwork(ownDid, ownName, peerId, multiaddrs) {
             console.warn(`[AgentNetwork] Failed to handle relay:`, e);
         }
     });
-    p2p_js_1.p2pNetwork.onMessage('discovery', async (data, from, did) => {
+    p2pNetwork.onMessage('discovery', async (data, from, did) => {
         try {
             const messageStr = new TextDecoder().decode(data);
             const discovery = JSON.parse(messageStr);
             if (discovery.type === 'discovery') {
-                const isValid = await exports.agentRegistry.verifySignature(discovery.from, JSON.stringify({ ...discovery, signature: undefined }), Buffer.from(discovery.signature, 'hex'));
+                const isValid = await agentRegistry.verifySignature(discovery.from, JSON.stringify({ ...discovery, signature: undefined }), Buffer.from(discovery.signature, 'hex'));
                 if (isValid) {
                     console.log(`[AgentNetwork] Verified discovery from: ${discovery.name}`);
                 }
@@ -672,21 +629,20 @@ async function initializeAgentNetwork(ownDid, ownName, peerId, multiaddrs) {
     });
     console.log(`[AgentNetwork] Initialized with DID: ${keyPair?.did.substring(0, 20) || ownDid.substring(0, 20)}...`);
 }
-async function broadcastOwnAddress() {
-    const broadcast = await exports.agentRegistry.createSignedBroadcast();
+export async function broadcastOwnAddress() {
+    const broadcast = await agentRegistry.createSignedBroadcast();
     if (broadcast) {
         const data = JSON.stringify(broadcast);
-        await p2p_js_1.p2pNetwork.broadcast('address_broadcast', data);
+        await p2pNetwork.broadcast('address_broadcast', data);
         console.log(`[AgentNetwork] Broadcast signed address to network`);
     }
 }
-async function findAndConnectToAgent(did) {
-    return exports.agentRegistry.connectToAgent(did);
+export async function findAndConnectToAgent(did) {
+    return agentRegistry.connectToAgent(did);
 }
-async function sendMessageToAgent(did, type, payload) {
-    return exports.agentMessaging.sendSignedToAgent(did, type, payload);
+export async function sendMessageToAgent(did, type, payload) {
+    return agentMessaging.sendSignedToAgent(did, type, payload);
 }
-async function sendUnverifiedMessageToAgent(did, type, payload) {
-    return exports.agentMessaging.sendToAgent(did, type, payload);
+export async function sendUnverifiedMessageToAgent(did, type, payload) {
+    return agentMessaging.sendToAgent(did, type, payload);
 }
-//# sourceMappingURL=agent-network.js.map

package/dist/network/hybrid-messenger.js

@@ -0,0 +1,125 @@
+import { irohTransport } from './iroh-transport.js';
+import { p2pNetwork } from './p2p.js';
+const DEFAULT_CONFIG = {
+    preferIrohForLarge: true,
+    largeThresholdBytes: 64 * 1024,
+    enableRelay: true,
+};
+export class HybridMessenger {
+    messageHandlers = new Map();
+    wildcardHandler = null;
+    config;
+    irohEnabled = true;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    selectTransport(type, payloadSize, priority = 'normal') {
+        if (this.irohEnabled && this.shouldUseIroh(type, payloadSize, priority)) {
+            return 'iroh';
+        }
+        if (priority === 'urgent' || type === 'relay') {
+            return 'libp2p';
+        }
+        return 'hyperswarm';
+    }
+    shouldUseIroh(type, payloadSize, priority) {
+        const bulkTypes = ['blob', 'stream', 'file', 'large-data'];
+        if (bulkTypes.includes(type) || payloadSize > this.config.largeThresholdBytes) {
+            return true;
+        }
+        if (priority === 'bulk' && payloadSize > 1024) {
+            return true;
+        }
+        return false;
+    }
+    async sendMessage(targetId, type, payload, options = {}) {
+        const { priority = 'normal', preferTransport, relayAddr } = options;
+        const payloadBytes = typeof payload === 'string'
+            ? new TextEncoder().encode(payload)
+            : payload;
+        const transport = preferTransport || this.selectTransport(type, payloadBytes.length, priority);
+        console.log(`[HybridMessenger] Sending "${type}" (${payloadBytes.length} bytes) via ${transport}`);
+        switch (transport) {
+            case 'iroh':
+                return this.sendViaIroh(targetId, type, payloadBytes);
+            case 'libp2p':
+                return this.sendViaLibp2p(targetId, type, payloadBytes, relayAddr);
+            case 'hyperswarm':
+            default:
+                return this.sendViaHyperswarm(targetId, type, payloadBytes);
+        }
+    }
+    async sendViaIroh(targetId, type, payload) {
+        try {
+            return await irohTransport.sendMessage(targetId, type, payload);
+        }
+        catch (e) {
+            console.warn('[HybridMessenger] iroh send failed:', e);
+            return false;
+        }
+    }
+    async sendViaLibp2p(targetId, type, payload, relayAddr) {
+        try {
+            await p2pNetwork.sendMessage(targetId, type, new TextDecoder().decode(payload));
+            return true;
+        }
+        catch (e) {
+            console.warn('[HybridMessenger] libp2p send failed:', e);
+            return false;
+        }
+    }
+    async sendViaHyperswarm(targetId, type, payload) {
+        try {
+            await p2pNetwork.sendMessage(targetId, type, new TextDecoder().decode(payload));
+            return true;
+        }
+        catch (e) {
+            console.warn('[HybridMessenger] Hyperswarm send failed:', e);
+            return false;
+        }
+    }
+    async broadcast(type, payload, options = {}) {
+        const { priority = 'normal', transport } = options;
+        const payloadBytes = typeof payload === 'string'
+            ? new TextEncoder().encode(payload)
+            : payload;
+        const selectedTransport = transport || this.selectTransport(type, payloadBytes.length, priority);
+        if (selectedTransport === 'iroh') {
+            await irohTransport.broadcast(type, payloadBytes);
+        }
+        else {
+            await p2pNetwork.broadcast(type, new TextDecoder().decode(payloadBytes));
+        }
+    }
+    onMessage(type, handler) {
+        this.messageHandlers.set(type, handler);
+    }
+    onWildcard(handler) {
+        this.wildcardHandler = handler;
+    }
+    dispatchMessage(msg) {
+        const handler = this.messageHandlers.get(msg.type);
+        if (handler) {
+            handler(msg);
+        }
+        else if (this.wildcardHandler) {
+            this.wildcardHandler(msg);
+        }
+    }
+    setIrohEnabled(enabled) {
+        this.irohEnabled = enabled;
+    }
+    isIrohEnabled() {
+        return this.irohEnabled;
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    setLargeThreshold(bytes) {
+        this.config.largeThresholdBytes = bytes;
+    }
+    setPreferIrohForLarge(enabled) {
+        this.config.preferIrohForLarge = enabled;
+    }
+}
+export const hybridMessenger = new HybridMessenger();

package/dist/network/iroh-bootstrap.js

@@ -0,0 +1,38 @@
+import { irohTransport } from './iroh-transport.js';
+export async function bootstrapIroh(auth, keyPair, agentName) {
+    console.log('[Iroh] Starting iroh transport...');
+    const node = await irohTransport.start();
+    const nodeId = node.nodeId;
+    console.log(`[Iroh] Node ID: ${nodeId}`);
+    const services = [
+        { serviceType: 'iroh', endpoint: nodeId },
+        { serviceType: 'iroh-quic', endpoint: `iroh://${nodeId}` },
+    ];
+    try {
+        const result = await auth.registerAgent({ name: agentName, services: services }, keyPair, nodeId);
+        console.log(`[Iroh] Registered with DIAP: DID=${result.did.substring(0, 20)}...`);
+    }
+    catch (e) {
+        console.warn('[Iroh] DIAP registration failed:', e);
+    }
+    irohTransport.onMessage('task', async (msg) => {
+        console.log(`[Iroh] Received task from ${msg.from}: ${new TextDecoder().decode(msg.payload).substring(0, 50)}...`);
+    });
+    irohTransport.onMessage('relay', (msg) => {
+        console.log(`[Iroh] Relay message from ${msg.from}`);
+    });
+    irohTransport.onMessage('blob', (msg) => {
+        console.log(`[Iroh] Blob from ${msg.from}: ${msg.payload.length} bytes`);
+    });
+    return nodeId;
+}
+export async function connectToIrohPeer(targetNodeId, type, payload) {
+    return irohTransport.sendMessage(targetNodeId, type, new TextEncoder().encode(payload));
+}
+export async function requestIrohPeer(targetNodeId, type, payload) {
+    const response = await irohTransport.requestResponse(targetNodeId, type, new TextEncoder().encode(payload));
+    return response ? new TextDecoder().decode(response) : null;
+}
+export function onIrohMessage(type, handler) {
+    irohTransport.onMessage(type, handler);
+}

package/dist/network/iroh-discovery.js

@@ -0,0 +1,145 @@
+import { irohTransport } from './iroh-transport.js';
+export class IrohDiscoveryService {
+    config;
+    discoveredAgents = new Map();
+    ownIrohNodeId = null;
+    refreshTimer = null;
+    discoveryTimer = null;
+    isRegistered = false;
+    constructor(config) {
+        this.config = {
+            discoveryIntervalMs: 30000,
+            refreshIntervalMs: 5 * 60 * 1000,
+            ...config,
+        };
+    }
+    async start() {
+        console.log('[IrohDiscovery] Starting...');
+        const node = await irohTransport.start();
+        this.ownIrohNodeId = node.nodeId;
+        console.log('[IrohDiscovery] Iroh node ID:', this.ownIrohNodeId.substring(0, 16) + '...');
+        await this.registerWithDIAP();
+        this.isRegistered = true;
+        this.startRefreshLoop();
+        this.startDiscoveryLoop();
+        return this.ownIrohNodeId;
+    }
+    async registerWithDIAP() {
+        if (!this.ownIrohNodeId)
+            return;
+        try {
+            const services = [
+                { serviceType: 'iroh', endpoint: this.ownIrohNodeId },
+                { serviceType: 'iroh-quic', endpoint: `iroh://${this.ownIrohNodeId}` },
+            ];
+            const agentInfo = {
+                name: this.config.agentName,
+                services: services,
+                description: this.config.agentDescription || 'Bolloon agent with iroh P2P',
+                tags: this.config.agentTags || ['bolloon', 'iroh'],
+            };
+            await this.config.agentAuthManager.registerAgent(agentInfo, this.config.keyPair, this.ownIrohNodeId);
+            console.log('[IrohDiscovery] Registered with DIAP');
+        }
+        catch (e) {
+            console.warn('[IrohDiscovery] DIAP registration failed:', e);
+        }
+    }
+    startRefreshLoop() {
+        this.refreshTimer = setInterval(async () => {
+            if (!this.isRegistered)
+                return;
+            console.log('[IrohDiscovery] Refreshing DIAP registration...');
+            await this.registerWithDIAP();
+        }, this.config.refreshIntervalMs);
+    }
+    startDiscoveryLoop() {
+        this.discoveryTimer = setInterval(async () => {
+            await this.discoverPeers();
+        }, this.discoveryIntervalMs);
+        setTimeout(() => this.discoverPeers(), 2000);
+    }
+    async discoverPeers() {
+        console.log('[IrohDiscovery] Discovering peers...');
+        const now = Date.now();
+        const staleThreshold = 10 * 60 * 1000;
+        for (const [did, agent] of this.discoveredAgents) {
+            if (now - agent.lastSeen > staleThreshold) {
+                this.discoveredAgents.delete(did);
+            }
+        }
+        console.log('[IrohDiscovery] Known agents:', this.discoveredAgents.size);
+        return Array.from(this.discoveredAgents.values());
+    }
+    async discoverViaDIAP() {
+        console.log('[IrohDiscovery] Querying DIAP for agents...');
+        const agents = [];
+        try {
+            const ipfsClient = this.config.agentAuthManager.identityManager?.ipfsClient;
+            if (ipfsClient) {
+                console.log('[IrohDiscovery] IPFS client available for discovery');
+            }
+        }
+        catch (e) {
+            console.warn('[IrohDiscovery] DIAP discovery error:', e);
+        }
+        return agents;
+    }
+    addDiscoveredAgent(agent) {
+        const existing = this.discoveredAgents.get(agent.did);
+        this.discoveredAgents.set(agent.did, {
+            ...agent,
+            lastSeen: Date.now(),
+            irohNodeId: agent.irohNodeId || existing?.irohNodeId || null,
+        });
+    }
+    getDiscoveredAgents() {
+        return Array.from(this.discoveredAgents.values());
+    }
+    getAgentByDid(did) {
+        return this.discoveredAgents.get(did);
+    }
+    getAgentsWithIroh() {
+        return Array.from(this.discoveredAgents.values()).filter((a) => a.irohNodeId !== null);
+    }
+    getOwnIrohNodeId() {
+        return this.ownIrohNodeId;
+    }
+    async connectToPeer(nodeId) {
+        return irohTransport.connect(nodeId);
+    }
+    async connectToAllIrohPeers() {
+        const agents = this.getAgentsWithIroh();
+        for (const agent of agents) {
+            if (agent.irohNodeId && agent.irohNodeId !== this.ownIrohNodeId) {
+                await this.connectToPeer(agent.irohNodeId);
+            }
+        }
+    }
+    async shutdown() {
+        this.isRegistered = false;
+        if (this.refreshTimer) {
+            clearInterval(this.refreshTimer);
+            this.refreshTimer = null;
+        }
+        if (this.discoveryTimer) {
+            clearInterval(this.discoveryTimer);
+            this.discoveryTimer = null;
+        }
+        this.discoveredAgents.clear();
+        await irohTransport.shutdown();
+        console.log('[IrohDiscovery] Shut down');
+    }
+}
+let discoveryInstance = null;
+export async function startIrohDiscovery(config) {
+    if (discoveryInstance) {
+        return discoveryInstance;
+    }
+    discoveryInstance = new IrohDiscoveryService(config);
+    await discoveryInstance.start();
+    return discoveryInstance;
+}
+export function getIrohDiscovery() {
+    return discoveryInstance;
+}

package/dist/network/iroh-integration.js

@@ -1,10 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IrohIntegration = void 0;
-exports.initIrohIntegration = initIrohIntegration;
-exports.getIrohIntegration = getIrohIntegration;
-const iroh_transport_js_1 = require("./iroh-transport.js");
-class IrohIntegration {
+import { irohTransport } from './iroh-transport.js';
+export class IrohIntegration {
     config;
     irohNodeId = null;
     registration = null;
@@ -22,10 +17,10 @@ class IrohIntegration {
     async start() {
         try {
             console.log('[IrohIntegration] Starting iroh transport...');
-            const node = await iroh_transport_js_1.irohTransport.start();
+            const node = await irohTransport.start();
             this.irohNodeId = node.nodeId;
             console.log(`[IrohIntegration] Node ID: ${this.irohNodeId}`);
-            iroh_transport_js_1.irohTransport.onMessage('*', (msg) => {
+            irohTransport.onMessage('*', (msg) => {
                 this.dispatchMessage(msg);
             });
             await this.registerWithDIAP();
@@ -77,10 +72,10 @@ class IrohIntegration {
         this.messageHandlers.set(type, handler);
     }
     async sendTo(targetNodeId, type, payload) {
-        return iroh_transport_js_1.irohTransport.sendMessage(targetNodeId, type, payload);
+        return irohTransport.sendMessage(targetNodeId, type, payload);
     }
     async requestFrom(targetNodeId, type, payload) {
-        return iroh_transport_js_1.irohTransport.requestResponse(targetNodeId, type, payload);
+        return irohTransport.requestResponse(targetNodeId, type, payload);
     }
     getNodeId() {
         return this.irohNodeId;
@@ -96,13 +91,12 @@ class IrohIntegration {
             clearInterval(this.refreshTimer);
             this.refreshTimer = null;
         }
-        await iroh_transport_js_1.irohTransport.shutdown();
+        await irohTransport.shutdown();
         console.log('[IrohIntegration] Shut down');
     }
 }
-exports.IrohIntegration = IrohIntegration;
 let integrationInstance = null;
-async function initIrohIntegration(config) {
+export async function initIrohIntegration(config) {
     if (integrationInstance) {
         console.log('[IrohIntegration] Already initialized');
         return integrationInstance;
@@ -111,7 +105,6 @@ async function initIrohIntegration(config) {
     await integrationInstance.start();
     return integrationInstance;
 }
-function getIrohIntegration() {
+export function getIrohIntegration() {
     return integrationInstance;
 }
-//# sourceMappingURL=iroh-integration.js.map