@bolloon/bolloon-agent 0.1.0

package/src/network/hybrid-messenger.ts

@@ -0,0 +1,199 @@
+import { irohTransport } from './iroh-transport.js';
+import { p2pNetwork, type PersistentPeerInfo } from './p2p.js';
+
+export type TransportType = 'hyperswarm' | 'iroh' | 'libp2p';
+export type MessagePriority = 'urgent' | 'normal' | 'bulk';
+
+export interface HybridMessage {
+  type: string;
+  payload: Uint8Array;
+  from: string;
+  transport?: TransportType;
+}
+
+export type HybridMessageHandler = (msg: HybridMessage) => void;
+
+export interface TransportConfig {
+  preferIrohForLarge: boolean;
+  largeThresholdBytes: number;
+  enableRelay: boolean;
+}
+
+const DEFAULT_CONFIG: TransportConfig = {
+  preferIrohForLarge: true,
+  largeThresholdBytes: 64 * 1024,
+  enableRelay: true,
+};
+
+export class HybridMessenger {
+  private messageHandlers: Map<string, HybridMessageHandler> = new Map();
+  private wildcardHandler: HybridMessageHandler | null = null;
+  private config: TransportConfig;
+  private irohEnabled: boolean = true;
+
+  constructor(config: Partial<TransportConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  private selectTransport(
+    type: string,
+    payloadSize: number,
+    priority: MessagePriority = 'normal'
+  ): TransportType {
+    if (this.irohEnabled && this.shouldUseIroh(type, payloadSize, priority)) {
+      return 'iroh';
+    }
+
+    if (priority === 'urgent' || type === 'relay') {
+      return 'libp2p';
+    }
+
+    return 'hyperswarm';
+  }
+
+  private shouldUseIroh(
+    type: string,
+    payloadSize: number,
+    priority: MessagePriority
+  ): boolean {
+    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: string,
+    type: string,
+    payload: string | Uint8Array,
+    options: {
+      priority?: MessagePriority;
+      preferTransport?: TransportType;
+      relayAddr?: string;
+    } = {}
+  ): Promise<boolean> {
+    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);
+    }
+  }
+
+  private async sendViaIroh(targetId: string, type: string, payload: Uint8Array): Promise<boolean> {
+    try {
+      return await irohTransport.sendMessage(targetId, type, payload);
+    } catch (e) {
+      console.warn('[HybridMessenger] iroh send failed:', e);
+      return false;
+    }
+  }
+
+  private async sendViaLibp2p(
+    targetId: string,
+    type: string,
+    payload: Uint8Array,
+    relayAddr?: string
+  ): Promise<boolean> {
+    try {
+      await p2pNetwork.sendMessage(targetId, type, new TextDecoder().decode(payload));
+      return true;
+    } catch (e) {
+      console.warn('[HybridMessenger] libp2p send failed:', e);
+      return false;
+    }
+  }
+
+  private async sendViaHyperswarm(targetId: string, type: string, payload: Uint8Array): Promise<boolean> {
+    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: string,
+    payload: string | Uint8Array,
+    options: {
+      priority?: MessagePriority;
+      transport?: TransportType;
+    } = {}
+  ): Promise<void> {
+    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: string, handler: HybridMessageHandler): void {
+    this.messageHandlers.set(type, handler);
+  }
+
+  onWildcard(handler: HybridMessageHandler): void {
+    this.wildcardHandler = handler;
+  }
+
+  dispatchMessage(msg: HybridMessage): void {
+    const handler = this.messageHandlers.get(msg.type);
+    if (handler) {
+      handler(msg);
+    } else if (this.wildcardHandler) {
+      this.wildcardHandler(msg);
+    }
+  }
+
+  setIrohEnabled(enabled: boolean): void {
+    this.irohEnabled = enabled;
+  }
+
+  isIrohEnabled(): boolean {
+    return this.irohEnabled;
+  }
+
+  getConfig(): TransportConfig {
+    return { ...this.config };
+  }
+
+  setLargeThreshold(bytes: number): void {
+    this.config.largeThresholdBytes = bytes;
+  }
+
+  setPreferIrohForLarge(enabled: boolean): void {
+    this.config.preferIrohForLarge = enabled;
+  }
+}
+
+export const hybridMessenger = new HybridMessenger();

package/src/network/iroh-bootstrap.ts

@@ -0,0 +1,57 @@
+import { AgentAuthManager, KeyManager } from '@diap/sdk';
+import { irohTransport } from './iroh-transport.js';
+
+export async function bootstrapIroh(
+  auth: AgentAuthManager,
+  keyPair: Awaited<ReturnType<typeof KeyManager.generate>>,
+  agentName: string
+): Promise<string | null> {
+  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 as any } as any,
+      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: string, type: string, payload: string): Promise<boolean> {
+  return irohTransport.sendMessage(targetNodeId, type, new TextEncoder().encode(payload));
+}
+
+export async function requestIrohPeer(targetNodeId: string, type: string, payload: string): Promise<string | null> {
+  const response = await irohTransport.requestResponse(targetNodeId, type, new TextEncoder().encode(payload));
+  return response ? new TextDecoder().decode(response) : null;
+}
+
+export function onIrohMessage(type: string, handler: (msg: { type: string; payload: Uint8Array; from: string }) => void): void {
+  irohTransport.onMessage(type, handler);
+}

package/src/network/iroh-discovery.ts

@@ -0,0 +1,207 @@
+import { AgentAuthManager, type AgentInfo, type KeyPair } from '@diap/sdk';
+import { irohTransport } from './iroh-transport.js';
+
+export interface DiscoveredAgent {
+  did: string;
+  name: string;
+  peerId: string;
+  irohNodeId: string | null;
+  lastSeen: number;
+  services: string[];
+}
+
+export interface IrohDiscoveryConfig {
+  agentAuthManager: AgentAuthManager;
+  keyPair: KeyPair;
+  agentName: string;
+  agentDescription?: string;
+  agentTags?: string[];
+  discoveryIntervalMs?: number;
+  refreshIntervalMs?: number;
+}
+
+export class IrohDiscoveryService {
+  private config: IrohDiscoveryConfig;
+  private discoveredAgents: Map<string, DiscoveredAgent> = new Map();
+  private ownIrohNodeId: string | null = null;
+  private refreshTimer: ReturnType<typeof setInterval> | null = null;
+  private discoveryTimer: ReturnType<typeof setInterval> | null = null;
+  private isRegistered: boolean = false;
+
+  constructor(config: IrohDiscoveryConfig) {
+    this.config = {
+      discoveryIntervalMs: 30000,
+      refreshIntervalMs: 5 * 60 * 1000,
+      ...config,
+    };
+  }
+
+  async start(): Promise<string | null> {
+    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;
+  }
+
+  private async registerWithDIAP(): Promise<void> {
+    if (!this.ownIrohNodeId) return;
+
+    try {
+      const services = [
+        { serviceType: 'iroh', endpoint: this.ownIrohNodeId },
+        { serviceType: 'iroh-quic', endpoint: `iroh://${this.ownIrohNodeId}` },
+      ];
+
+      const agentInfo: AgentInfo = {
+        name: this.config.agentName,
+        services: services as any,
+        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);
+    }
+  }
+
+  private startRefreshLoop(): void {
+    this.refreshTimer = setInterval(async () => {
+      if (!this.isRegistered) return;
+      console.log('[IrohDiscovery] Refreshing DIAP registration...');
+      await this.registerWithDIAP();
+    }, this.config.refreshIntervalMs!);
+  }
+
+  private startDiscoveryLoop(): void {
+    this.discoveryTimer = setInterval(async () => {
+      await this.discoverPeers();
+    }, this.discoveryIntervalMs!);
+
+    setTimeout(() => this.discoverPeers(), 2000);
+  }
+
+  async discoverPeers(): Promise<DiscoveredAgent[]> {
+    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(): Promise<DiscoveredAgent[]> {
+    console.log('[IrohDiscovery] Querying DIAP for agents...');
+
+    const agents: DiscoveredAgent[] = [];
+
+    try {
+      const ipfsClient = (this.config.agentAuthManager as any).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: DiscoveredAgent): void {
+    const existing = this.discoveredAgents.get(agent.did);
+    this.discoveredAgents.set(agent.did, {
+      ...agent,
+      lastSeen: Date.now(),
+      irohNodeId: agent.irohNodeId || existing?.irohNodeId || null,
+    });
+  }
+
+  getDiscoveredAgents(): DiscoveredAgent[] {
+    return Array.from(this.discoveredAgents.values());
+  }
+
+  getAgentByDid(did: string): DiscoveredAgent | undefined {
+    return this.discoveredAgents.get(did);
+  }
+
+  getAgentsWithIroh(): DiscoveredAgent[] {
+    return Array.from(this.discoveredAgents.values()).filter(
+      (a) => a.irohNodeId !== null
+    );
+  }
+
+  getOwnIrohNodeId(): string | null {
+    return this.ownIrohNodeId;
+  }
+
+  async connectToPeer(nodeId: string): Promise<boolean> {
+    return irohTransport.connect(nodeId);
+  }
+
+  async connectToAllIrohPeers(): Promise<void> {
+    const agents = this.getAgentsWithIroh();
+    for (const agent of agents) {
+      if (agent.irohNodeId && agent.irohNodeId !== this.ownIrohNodeId) {
+        await this.connectToPeer(agent.irohNodeId);
+      }
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    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: IrohDiscoveryService | null = null;
+
+export async function startIrohDiscovery(
+  config: IrohDiscoveryConfig
+): Promise<IrohDiscoveryService> {
+  if (discoveryInstance) {
+    return discoveryInstance;
+  }
+
+  discoveryInstance = new IrohDiscoveryService(config);
+  await discoveryInstance.start();
+  return discoveryInstance;
+}
+
+export function getIrohDiscovery(): IrohDiscoveryService | null {
+  return discoveryInstance;
+}

package/src/network/iroh-integration.ts

@@ -0,0 +1,158 @@
+import { irohTransport, type IrohMessage } from './iroh-transport.js';
+import { AgentAuthManager, KeyManager, type AgentInfo, type IdentityRegistration, type KeyPair } from '@diap/sdk';
+
+export interface IrohDiscoveryResult {
+  did: string;
+  name: string;
+  irohNodeId: string;
+  lastSeen: number;
+}
+
+export interface IrohIntegrationConfig {
+  agentAuthManager: AgentAuthManager;
+  keyPair: KeyPair;
+  agentName: string;
+  agentDescription?: string;
+  agentTags?: string[];
+  refreshIntervalMs?: number;
+  discoveryIntervalMs?: number;
+}
+
+export class IrohIntegration {
+  private config: IrohIntegrationConfig;
+  private irohNodeId: string | null = null;
+  private registration: IdentityRegistration | null = null;
+  private messageHandlers: Map<string, (msg: IrohMessage, from: string) => void> = new Map();
+  private discoveredPeers: Map<string, IrohDiscoveryResult> = new Map();
+  private refreshTimer: ReturnType<typeof setInterval> | null = null;
+  private connectedPeers: Set<string> = new Set();
+
+  constructor(config: IrohIntegrationConfig) {
+    this.config = {
+      refreshIntervalMs: 5 * 60 * 1000,
+      discoveryIntervalMs: 30 * 1000,
+      ...config,
+    };
+  }
+
+  async start(): Promise<string | null> {
+    try {
+      console.log('[IrohIntegration] Starting iroh transport...');
+
+      const node = await irohTransport.start();
+      this.irohNodeId = node.nodeId;
+      console.log(`[IrohIntegration] Node ID: ${this.irohNodeId}`);
+
+      irohTransport.onMessage('*', (msg) => {
+        this.dispatchMessage(msg);
+      });
+
+      await this.registerWithDIAP();
+      this.startRefreshLoop();
+
+      console.log('[IrohIntegration] Started successfully');
+      return this.irohNodeId;
+    } catch (e) {
+      console.error('[IrohIntegration] Failed to start:', e);
+      return null;
+    }
+  }
+
+  private async registerWithDIAP(): Promise<void> {
+    if (!this.irohNodeId) {
+      console.warn('[IrohIntegration] No iroh node ID');
+      return;
+    }
+
+    try {
+      const services = [
+        { serviceType: 'iroh', endpoint: this.irohNodeId },
+        { serviceType: 'iroh-quic', endpoint: `iroh://${this.irohNodeId}` },
+      ];
+
+      const agentInfo: AgentInfo = {
+        name: this.config.agentName,
+        services: services as any,
+        description: this.config.agentDescription || 'Bolloon agent with iroh P2P',
+        tags: this.config.agentTags || ['bolloon', 'iroh', 'p2p'],
+      };
+
+      this.registration = await this.config.agentAuthManager.registerAgent(
+        agentInfo,
+        this.config.keyPair,
+        this.irohNodeId
+      );
+
+      console.log(`[IrohIntegration] DIAP registered: DID=${this.registration.did.substring(0, 20)}...`);
+    } catch (e) {
+      console.error('[IrohIntegration] DIAP registration failed:', e);
+    }
+  }
+
+  private startRefreshLoop(): void {
+    this.refreshTimer = setInterval(async () => {
+      console.log('[IrohIntegration] Refreshing DIAP registration...');
+      await this.registerWithDIAP();
+    }, this.config.refreshIntervalMs!);
+  }
+
+  private dispatchMessage(msg: IrohMessage): void {
+    const handler = this.messageHandlers.get(msg.type);
+    if (handler) {
+      handler(msg, msg.from);
+    }
+  }
+
+  onMessage(type: string, handler: (msg: IrohMessage, from: string) => void): void {
+    this.messageHandlers.set(type, handler);
+  }
+
+  async sendTo(targetNodeId: string, type: string, payload: Uint8Array): Promise<boolean> {
+    return irohTransport.sendMessage(targetNodeId, type, payload);
+  }
+
+  async requestFrom(targetNodeId: string, type: string, payload: Uint8Array): Promise<Uint8Array | null> {
+    return irohTransport.requestResponse(targetNodeId, type, payload);
+  }
+
+  getNodeId(): string | null {
+    return this.irohNodeId;
+  }
+
+  getRegistration(): IdentityRegistration | null {
+    return this.registration;
+  }
+
+  getConnectedPeers(): string[] {
+    return Array.from(this.connectedPeers);
+  }
+
+  async shutdown(): Promise<void> {
+    if (this.refreshTimer) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+
+    await irohTransport.shutdown();
+    console.log('[IrohIntegration] Shut down');
+  }
+}
+
+let integrationInstance: IrohIntegration | null = null;
+
+export async function initIrohIntegration(
+  config: IrohIntegrationConfig
+): Promise<IrohIntegration> {
+  if (integrationInstance) {
+    console.log('[IrohIntegration] Already initialized');
+    return integrationInstance;
+  }
+
+  integrationInstance = new IrohIntegration(config);
+  await integrationInstance.start();
+  return integrationInstance;
+}
+
+export function getIrohIntegration(): IrohIntegration | null {
+  return integrationInstance;
+}