@bolloon/bolloon-agent 0.1.36 → 0.1.38

package/src/network/hybrid-messenger.ts

@@ -1,199 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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 {
-    const interval = this.config.discoveryIntervalMs ?? 30000;
-    this.discoveryTimer = setInterval(async () => {
-      await this.discoverPeers();
-    }, interval);
-
-    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

@@ -1,158 +0,0 @@
-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;
-}