@highway1/core 0.1.53 → 0.1.55

package/src/messaging/types.ts

@@ -1,149 +0,0 @@
-/**
- * Message Queue Types
- *
- * Types for message queue, storage, and filtering operations.
- */
-
-import type { MessageEnvelope } from './envelope.js';
-
-/**
- * Message direction
- */
-export type MessageDirection = 'inbound' | 'outbound';
-
-/**
- * Message status
- */
-export type MessageStatus = 'pending' | 'delivered' | 'failed' | 'archived';
-
-/**
- * Stored message with metadata
- */
-export interface StoredMessage {
-  envelope: MessageEnvelope;
-  direction: MessageDirection;
-  status: MessageStatus;
-  receivedAt?: number;
-  sentAt?: number;
-  readAt?: number;
-  trustScore?: number;
-  error?: string;
-}
-
-/**
- * Message filter for queries
- */
-export interface MessageFilter {
-  fromDid?: string | string[];
-  toDid?: string | string[];
-  protocol?: string | string[];
-  minTrustScore?: number;
-  maxAge?: number; // milliseconds
-  type?: 'request' | 'response' | 'notification';
-  unreadOnly?: boolean;
-  status?: MessageStatus | MessageStatus[];
-}
-
-/**
- * Pagination options
- */
-export interface PaginationOptions {
-  limit?: number;
-  offset?: number;
-  startKey?: string; // For cursor-based pagination
-}
-
-/**
- * Paginated message results
- */
-export interface MessagePage {
-  messages: StoredMessage[];
-  total: number;
-  hasMore: boolean;
-  nextKey?: string;
-}
-
-/**
- * Blocklist entry
- */
-export interface BlocklistEntry {
-  did: string;
-  reason: string;
-  blockedAt: number;
-  blockedBy: string; // Local agent DID
-}
-
-/**
- * Allowlist entry
- */
-export interface AllowlistEntry {
-  did: string;
-  addedAt: number;
-  note?: string;
-}
-
-/**
- * Seen cache entry (for deduplication)
- */
-export interface SeenEntry {
-  messageId: string;
-  seenAt: number;
-  fromDid: string;
-}
-
-/**
- * Rate limit state
- */
-export interface RateLimitState {
-  did: string;
-  tokens: number;
-  lastRefill: number;
-  totalRequests: number;
-  firstSeen: number;
-}
-
-/**
- * Defense check result
- */
-export interface DefenseResult {
-  allowed: boolean;
-  reason?: 'blocked' | 'duplicate' | 'trust_too_low' | 'rate_limited' | 'invalid';
-  trustScore?: number;
-  remainingTokens?: number;
-  resetTime?: number;
-}
-
-/**
- * Rate limit result
- */
-export interface RateLimitResult {
-  allowed: boolean;
-  remaining: number;
-  resetTime: number;
-  limit: number;
-}
-
-/**
- * Queue statistics
- */
-export interface QueueStats {
-  inboxTotal: number;
-  inboxUnread: number;
-  outboxPending: number;
-  outboxFailed: number;
-  blockedAgents: number;
-  allowedAgents: number;
-  rateLimitedAgents: number;
-}
-
-/**
- * Subscription callback
- */
-export type MessageCallback = (message: StoredMessage) => void | Promise<void>;
-
-/**
- * Subscription filter
- */
-export interface SubscriptionFilter extends MessageFilter {
-  webhookUrl?: string;
-}

package/src/transport/connection.ts

@@ -1,77 +0,0 @@
-import type { Libp2p } from 'libp2p';
-import { createLogger } from '../utils/logger.js';
-import { TransportError } from '../utils/errors.js';
-
-const logger = createLogger('connection');
-
-export interface ConnectionManager {
-  connect: (peerId: string) => Promise<void>;
-  disconnect: (peerId: string) => Promise<void>;
-  isConnected: (peerId: string) => boolean;
-  getConnectedPeers: () => string[];
-}
-
-/**
- * Create a connection manager for a libp2p node
- */
-export function createConnectionManager(
-  libp2p: Libp2p
-): ConnectionManager {
-  return {
-    connect: async (peerIdStr: string) => {
-      try {
-        // Parse peer ID and multiaddr
-        const connections = libp2p.getConnections();
-        const existing = connections.find(
-          (conn) => conn.remotePeer.toString() === peerIdStr
-        );
-
-        if (existing) {
-          logger.debug('Already connected to peer', { peerId: peerIdStr });
-          return;
-        }
-
-        // In a real implementation, we would dial the peer
-        // For now, we rely on libp2p's automatic connection management
-        logger.info('Connecting to peer', { peerId: peerIdStr });
-      } catch (error) {
-        throw new TransportError('Failed to connect to peer', error);
-      }
-    },
-
-    disconnect: async (peerIdStr: string) => {
-      try {
-        const connections = libp2p.getConnections();
-        const matching = connections.filter(
-          (conn) => conn.remotePeer.toString() === peerIdStr
-        );
-
-        for (const conn of matching) {
-          await conn.close();
-        }
-
-        logger.info('Disconnected from peer', { peerId: peerIdStr });
-      } catch (error) {
-        throw new TransportError('Failed to disconnect from peer', error);
-      }
-    },
-
-    isConnected: (peerIdStr: string) => {
-      const connections = libp2p.getConnections();
-      return connections.some(
-        (conn) => conn.remotePeer.toString() === peerIdStr
-      );
-    },
-
-    getConnectedPeers: () => {
-      const connections = libp2p.getConnections();
-      const peers = new Set<string>();
-
-      for (const conn of connections) {
-        peers.add(conn.remotePeer.toString());
-      }
-
-      return Array.from(peers);
-    },
-  };
-}

package/src/transport/index.ts

@@ -1,2 +0,0 @@
-export * from './node.js';
-export * from './connection.js';

package/src/transport/node.ts

@@ -1,154 +0,0 @@
-import { createLibp2p, Libp2p } from 'libp2p';
-import { tcp } from '@libp2p/tcp';
-import { webSockets } from '@libp2p/websockets';
-import { noise } from '@chainsafe/libp2p-noise';
-import { mplex } from '@libp2p/mplex';
-import { kadDHT, passthroughMapper } from '@libp2p/kad-dht';
-import { bootstrap } from '@libp2p/bootstrap';
-import { identify } from '@libp2p/identify';
-import { ping } from '@libp2p/ping';
-import {
-  circuitRelayTransport,
-  circuitRelayServer,
-} from '@libp2p/circuit-relay-v2';
-import { createLogger } from '../utils/logger.js';
-import { TransportError } from '../utils/errors.js';
-import type { KeyPair } from '../identity/keys.js';
-import type { PrivateKey } from '@libp2p/interface';
-
-const logger = createLogger('transport');
-
-export interface TransportConfig {
-  keyPair?: KeyPair;
-  listenAddresses?: string[];
-  bootstrapPeers?: string[];
-  enableDHT?: boolean;
-  /** Run as a relay server so NAT'd agents can receive messages through this node */
-  enableRelay?: boolean;
-  /** Reserve a relay slot on bootstrap nodes so others can reach us (only needed for hw1 join) */
-  reserveRelaySlot?: boolean;
-  /** Enable mDNS local peer discovery (default: false) */
-  enableMDNS?: boolean;
-  /** libp2p PrivateKey for persistent PeerID (from @libp2p/crypto) */
-  privateKey?: PrivateKey;
-}
-
-export interface ClawiverseNode {
-  libp2p: Libp2p;
-  start: () => Promise<void>;
-  stop: () => Promise<void>;
-  getMultiaddrs: () => string[];
-  getPeerId: () => string;
-}
-
-/**
- * Create a Clawiverse transport node with libp2p
- */
-export async function createNode(
-  config: TransportConfig
-): Promise<ClawiverseNode> {
-  try {
-    const {
-      listenAddresses = ['/ip4/0.0.0.0/tcp/0', '/ip4/0.0.0.0/tcp/0/ws'], // CVP-0010 §5: Add WebSocket listener
-      bootstrapPeers = [],
-      enableDHT = true,
-      enableRelay = false,
-      reserveRelaySlot = false,
-      enableMDNS = false,
-      privateKey,
-    } = config;
-
-    // Reserve relay slots by adding p2p-circuit listen addresses (for hw1 join)
-    const relayListenAddrs = reserveRelaySlot
-      ? bootstrapPeers.map((peer) => `${peer}/p2p-circuit`)
-      : [];
-
-    const libp2pConfig: any = {
-      addresses: {
-        listen: [...listenAddresses, ...relayListenAddrs],
-      },
-      ...(privateKey ? { privateKey } : {}),
-      transports: [
-        tcp(),
-        webSockets(),           // CVP-0010 §5: WebSocket for firewall traversal
-        circuitRelayTransport(),
-      ],
-      connectionEncrypters: [noise()],
-      streamMuxers: [mplex()],
-      connectionManager: {
-        minConnections: bootstrapPeers.length > 0 ? 1 : 0,
-        maxConnections: 50,
-      },
-      services: {
-        identify: identify(),
-        ping: ping(),
-      },
-    };
-
-    if (enableRelay) {
-      libp2pConfig.services.relay = circuitRelayServer({
-        reservations: {
-          maxReservations: 100, // Allow up to 100 concurrent relay reservations
-        },
-      });
-    }
-
-    if (enableDHT) {
-      libp2pConfig.services.dht = kadDHT({
-        clientMode: false,
-        peerInfoMapper: passthroughMapper,
-        validators: {
-          clawiverse: async () => {},
-        },
-        selectors: {
-          clawiverse: () => 0,
-        },
-        // Optimize for small networks: reduce replication factor and query timeout
-        kBucketSize: 20,  // Default K=20, keep for compatibility
-        querySelfInterval: 30000,  // Self-query every 30 seconds (libp2p default)
-        // Allow queries to complete faster in small networks
-        allowQueryWithZeroPeers: true,
-      });
-    }
-
-    const peerDiscovery: any[] = [];
-    if (bootstrapPeers.length > 0) peerDiscovery.push(bootstrap({ list: bootstrapPeers }));
-    if (enableMDNS) {
-      const { mdns } = await import('@libp2p/mdns');
-      peerDiscovery.push(mdns());
-    }
-    if (peerDiscovery.length > 0) libp2pConfig.peerDiscovery = peerDiscovery;
-
-    const libp2p = await createLibp2p(libp2pConfig);
-
-    logger.info('Libp2p node created', {
-      listenAddresses: libp2pConfig.addresses.listen,
-      reserveRelaySlot,
-    });
-
-    return {
-      libp2p,
-      start: async () => {
-        await libp2p.start();
-        logger.info('Node started', {
-          peerId: libp2p.peerId.toString(),
-          addresses: libp2p.getMultiaddrs().map((ma) => ma.toString()),
-          relay: enableRelay,
-          reserveRelaySlot,
-        });
-      },
-      stop: async () => {
-        await libp2p.stop();
-        logger.info('Node stopped');
-      },
-      getMultiaddrs: () => {
-        return libp2p.getMultiaddrs().map((ma) => ma.toString());
-      },
-      getPeerId: () => {
-        return libp2p.peerId.toString();
-      },
-    };
-  } catch (error) {
-    throw new TransportError('Failed to create transport node', error);
-  }
-}