@highway1/cli 0.1.50 → 0.1.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.50",
+  "version": "0.1.53",
   "description": "CLI tool for Clawiverse network",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@highway1/core": "^0.1.46",
+    "@highway1/core": "^0.1.53",
     "chalk": "^5.3.0",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",

package/src/commands/discover.ts

@@ -1,13 +1,25 @@
 import { Command } from 'commander';
 import {
-  createNode,
+  createRelayClient,
+  createRelayIndexOperations,
   importKeyPair,
-  createDHTOperations,
+  createAgentCard,
+  signAgentCard,
+  sign,
 } from '@highway1/core';
-import { getIdentity, getBootstrapPeers } from '../config.js';
+import { getIdentity, getAgentCard } from '../config.js';
 import { error, spinner, printHeader, info, success } from '../ui.js';
 import Table from 'cli-table3';
 
+const DEFAULT_RELAY_URLS = ['ws://relay.highway1.net:8080'];
+
+function getRelayUrls(options: any): string[] {
+  if (options.relay) return [options.relay];
+  const envRelays = process.env.HW1_RELAY_URLS;
+  if (envRelays) return envRelays.split(',').map((u: string) => u.trim());
+  return DEFAULT_RELAY_URLS;
+}
+
 export function registerDiscoverCommand(program: Command): void {
   program
     .command('discover')
@@ -18,7 +30,7 @@ export function registerDiscoverCommand(program: Command): void {
     .option('--min-trust <score>', 'Minimum trust score (0-1)')
     .option('--language <lang>', 'Filter by language')
     .option('--limit <number>', 'Maximum number of results', '10')
-    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
+    .option('--relay <url>', 'Relay WebSocket URL')
     .action(async (options) => {
       try {
         printHeader('Discover Agents');
@@ -30,56 +42,58 @@ export function registerDiscoverCommand(program: Command): void {
           process.exit(1);
         }
 
-        const spin = spinner('Starting node...');
+        const spin = spinner('Connecting to relay...');
 
         const keyPair = importKeyPair({
           publicKey: identity.publicKey,
           privateKey: identity.privateKey,
         });
 
-        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
-
-        const node = await createNode({
+        const relayUrls = getRelayUrls(options);
+        const card = getAgentCard();
+        const capabilities = (card?.capabilities ?? []).map((c: string) => ({
+          id: c, name: c, description: `Capability: ${c}`,
+        }));
+        const agentCard = createAgentCard(
+          identity.did,
+          card?.name ?? 'Clawiverse Agent',
+          card?.description ?? '',
+          capabilities,
+          [],
+        );
+        const signedCard = await signAgentCard(agentCard, (data) => sign(data, keyPair.privateKey));
+
+        const relayClient = createRelayClient({
+          relayUrls,
+          did: identity.did,
           keyPair,
-          bootstrapPeers,
-          enableDHT: true,
-        });
-
-        await node.start();
-
-        spin.text = 'Waiting for DHT peers...';
-        // Wait until connected to at least one peer, then give DHT time to sync
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 15000);
-          node.libp2p.addEventListener('peer:connect', () => {
-            clearTimeout(timeout);
-            setTimeout(resolve, 3000); // give DHT routing table time to populate
-          }, { once: true });
+          card: signedCard,
         });
 
-        spin.text = 'Querying DHT...';
+        await relayClient.start();
+        spin.text = 'Querying relay...';
 
-        const dht = createDHTOperations(node.libp2p);
+        const relayIndex = createRelayIndexOperations(relayClient);
 
         if (options.did) {
-          const card = await dht.queryAgentCard(options.did);
+          const agentCard = await relayIndex.queryAgentCard(options.did);
 
-          if (card) {
+          if (agentCard) {
             spin.succeed('Agent found!');
             console.log();
-            info(`DID:          ${card.did}`);
-            info(`Name:         ${card.name}`);
-            info(`Description:  ${card.description}`);
-            info(`Version:      ${card.version}`);
-            info(`Capabilities: ${card.capabilities.join(', ') || '(none)'}`);
-            info(`Peer ID:      ${card.peerId || '(unknown)'}`);
-            info(`Endpoints:    ${card.endpoints.length > 0 ? card.endpoints.join('\n              ') : '(none)'}`);
-            info(`Timestamp:    ${new Date(card.timestamp).toISOString()}`);
+            info(`DID:          ${agentCard.did}`);
+            info(`Name:         ${agentCard.name}`);
+            info(`Description:  ${agentCard.description}`);
+            info(`Version:      ${agentCard.version}`);
+            const caps = agentCard.capabilities.map((c: any) =>
+              typeof c === 'string' ? c : c.name
+            ).join(', ');
+            info(`Capabilities: ${caps || '(none)'}`);
+            info(`Timestamp:    ${new Date(agentCard.timestamp).toISOString()}`);
           } else {
             spin.fail('Agent not found');
           }
         } else if (options.capability || options.query) {
-          // Semantic search
           const query: any = {
             limit: parseInt(options.limit, 10),
           };
@@ -91,9 +105,7 @@ export function registerDiscoverCommand(program: Command): void {
           }
 
           if (options.minTrust) {
-            query.filters = {
-              minTrustScore: parseFloat(options.minTrust),
-            };
+            query.filters = { minTrustScore: parseFloat(options.minTrust) };
           }
 
           if (options.language) {
@@ -101,7 +113,7 @@ export function registerDiscoverCommand(program: Command): void {
             query.filters.language = options.language;
           }
 
-          const cards = await dht.searchSemantic(query);
+          const cards = await relayIndex.searchSemantic(query);
 
           spin.succeed(`Found ${cards.length} agents`);
 
@@ -133,7 +145,6 @@ export function registerDiscoverCommand(program: Command): void {
             console.log();
             console.log(table.toString());
 
-            // Show detailed info for first result if query was used
             if (options.query && cards.length > 0) {
               const card = cards[0];
               console.log();
@@ -156,10 +167,9 @@ export function registerDiscoverCommand(program: Command): void {
           info('Usage: hw1 discover --did <did>');
           info('       hw1 discover --capability <capability>');
           info('       hw1 discover --query "translate Japanese"');
-          info('       hw1 discover --query "code review" --min-trust 0.8');
         }
 
-        await node.stop();
+        await relayClient.stop();
       } catch (err) {
         error(`Failed to discover: ${(err as Error).message}`);
         process.exit(1);

package/src/commands/join.ts

@@ -1,26 +1,37 @@
 import { Command } from 'commander';
 import {
-  createNode,
+  createRelayClient,
+  createRelayIndexOperations,
+  createMessageRouter,
   importKeyPair,
   createAgentCard,
   signAgentCard,
-  createDHTOperations,
-  createMessageRouter,
   sign,
   verify,
   extractPublicKey,
 } from '@highway1/core';
-import { getIdentity, getAgentCard, getBootstrapPeers } from '../config.js';
+import { getIdentity, getAgentCard } from '../config.js';
 import { success, error, spinner, printHeader, info } from '../ui.js';
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 
+// Default relay URLs (CVP-0011)
+const DEFAULT_RELAY_URLS = [
+  'ws://relay.highway1.net:8080',
+];
+
+function getRelayUrls(options: any): string[] {
+  if (options.relay) return [options.relay];
+  const envRelays = process.env.HW1_RELAY_URLS;
+  if (envRelays) return envRelays.split(',').map((u: string) => u.trim());
+  return DEFAULT_RELAY_URLS;
+}
+
 export function registerJoinCommand(program: Command): void {
   program
     .command('join')
-    .description('Join the Clawiverse network')
-    .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
-    .option('--relay', 'Run as a relay server and advertise relay capability')
+    .description('Join the Clawiverse network via relay')
+    .option('--relay <url>', 'Relay WebSocket URL (e.g. ws://localhost:8080)')
     .option('--save-dir <path>', 'Directory to save received file attachments', './downloads')
     .action(async (options) => {
       try {
@@ -34,236 +45,47 @@ export function registerJoinCommand(program: Command): void {
           process.exit(1);
         }
 
-        const spin = spinner('Starting libp2p node...');
+        const spin = spinner('Connecting to relay...');
 
         const keyPair = importKeyPair({
           publicKey: identity.publicKey,
           privateKey: identity.privateKey,
         });
 
-        const bootstrapPeers = options.bootstrap || getBootstrapPeers();
-        const bootstrapPeerIds = bootstrapPeers
-          .map((addr: string) => addr.split('/p2p/')[1])
-          .filter((peerId: string | undefined): peerId is string => Boolean(peerId));
-
-        const node = await createNode({
-          keyPair,
-          bootstrapPeers,
-          enableDHT: true,
-          reserveRelaySlot: true,
-          enableRelay: options.relay ?? false,
-        });
-
-        await node.start();
-
-        spin.succeed('Node started successfully!');
-
-        info(`Peer ID: ${node.getPeerId()}`);
-        info(`DID: ${identity.did}`);
-        info(`Listening on: ${node.getMultiaddrs().join(', ')}`);
-
-        // Wait for bootstrap peer connection before publishing to DHT
-        const connectSpin = spinner('Connecting to bootstrap peers...');
-
-        // Phase 1: wait for peer:connect (up to 10s)
-        let connected = false;
-        await new Promise<void>((resolve) => {
-          const timeout = setTimeout(resolve, 10000);
-          node.libp2p.addEventListener('peer:connect', () => {
-            connected = true;
-            clearTimeout(timeout);
-            resolve();
-          }, { once: true });
-        });
-
-        // If discovery has not connected us yet, proactively dial bootstrap peers once.
-        if (!connected && bootstrapPeers.length > 0) {
-          info('No peer discovered yet, dialing bootstrap peers...');
-          for (const bootstrapAddr of bootstrapPeers) {
-            try {
-              await node.libp2p.dial(bootstrapAddr);
-              connected = true;
-              break;
-            } catch {
-              // try next bootstrap peer
-            }
-          }
-        }
-
-        // Phase 2: wait for relay reservation using event + polling (more reliable across libp2p versions)
-        const countRelayAddrs = () => node.getMultiaddrs().filter(a => a.includes('/p2p-circuit')).length;
-        const initialRelayCount = countRelayAddrs();
-
-        info(`Initial relay addresses: ${initialRelayCount}`);
-        info('Waiting for relay reservation...');
-
-        let reservationSucceeded = false;
-        if (initialRelayCount === 0) {
-          await new Promise<void>((resolve) => {
-            const RELAY_WAIT_MS = 30000;
-            const POLL_MS = 500;
-            let settled = false;
-
-            const finish = () => {
-              if (settled) return;
-              settled = true;
-              clearTimeout(timeout);
-              clearInterval(pollTimer);
-              (node.libp2p as any).removeEventListener('relay:reservation', onReservation);
-              (node.libp2p as any).removeEventListener('self:peer:update', onPeerUpdate);
-              resolve();
-            };
-
-            const onReservation = () => {
-              reservationSucceeded = true;
-              info('✓ Relay reservation successful!');
-              setTimeout(finish, 300);
-            };
-
-            const onPeerUpdate = () => {
-              if (countRelayAddrs() > 0) {
-                reservationSucceeded = true;
-                info('✓ Relay address detected from peer update');
-                finish();
-              }
-            };
-
-            const pollTimer = setInterval(() => {
-              if (countRelayAddrs() > 0) {
-                reservationSucceeded = true;
-                info('✓ Relay address detected');
-                finish();
-              }
-            }, POLL_MS);
-
-            const timeout = setTimeout(() => {
-              if (!reservationSucceeded) {
-                info(`Relay reservation timeout after ${RELAY_WAIT_MS / 1000}s.`);
-                info(`Connected peers: ${node.libp2p.getPeers().map(p => p.toString()).join(', ')}`);
-              }
-              finish();
-            }, RELAY_WAIT_MS);
-
-            // Event names vary by libp2p internals; keep as any to avoid typing mismatch.
-            (node.libp2p as any).addEventListener('relay:reservation', onReservation);
-            (node.libp2p as any).addEventListener('self:peer:update', onPeerUpdate);
-          });
-        } else {
-          reservationSucceeded = true;
-          info('✓ Relay address already present');
-        }
-
-        if (!reservationSucceeded) {
-          info('⚠ Relay reservation did not complete, continuing with fallback relay addresses');
-        }
-
-        connectSpin.succeed('Connected to network!');
-
-        // Publish Agent Card with peerId and multiaddrs so others can dial us
-        const cardSpin = spinner('Publishing Agent Card to DHT...');
-
-        // Use relay addresses from libp2p (populated after reservation), fall back to manual construction
-        const directAddrs = node.getMultiaddrs().filter(a => !a.includes('/p2p-circuit'));
-        const relayAddrs = node.getMultiaddrs().filter(a => a.includes('/p2p-circuit'));
-        const fallbackRelayAddrs = relayAddrs.length === 0
-          ? bootstrapPeers.map((r: string) => `${r}/p2p-circuit/p2p/${node.getPeerId()}`)
-          : [];
-        const allAddrs = [...directAddrs, ...relayAddrs, ...fallbackRelayAddrs];
+        const relayUrls = getRelayUrls(options);
 
         const capabilities = (card.capabilities ?? []).map((capability: string) => ({
           id: capability,
           name: capability,
           description: `Capability: ${capability}`,
         }));
-        if (options.relay) {
-          capabilities.push({
-            id: 'relay',
-            name: 'relay',
-            description: 'Provides circuit relay service for NAT traversal',
-          });
-        }
 
         const agentCard = createAgentCard(
           identity.did,
           card.name,
           card.description,
           capabilities,
-          allAddrs,
-          node.getPeerId()
+          [],
         );
 
         const signedCard = await signAgentCard(agentCard, (data) =>
           sign(data, keyPair.privateKey)
         );
 
-        const dht = createDHTOperations(node.libp2p);
-        await dht.publishAgentCard(signedCard);
-
-        cardSpin.succeed('Agent Card published!');
-
-        // Keep bootstrap connectivity stable: proactively re-dial missing bootstrap peers.
-        const ensureBootstrapConnections = async () => {
-          const connections = node.libp2p.getConnections();
-          const connectedPeerIds = new Set(connections.map((conn) => conn.remotePeer.toString()));
-
-          for (const bootstrapAddr of bootstrapPeers) {
-            const targetPeerId = bootstrapAddr.split('/p2p/')[1];
-            if (!targetPeerId || connectedPeerIds.has(targetPeerId)) continue;
-
-            try {
-              await node.libp2p.dial(bootstrapAddr);
-              info(`Reconnected bootstrap peer: ${targetPeerId}`);
-            } catch {
-              // best effort; keep trying on next tick
-            }
-          }
-        };
+        const relayClient = createRelayClient({
+          relayUrls,
+          did: identity.did,
+          keyPair,
+          card: signedCard,
+        });
 
-        // Keep connection alive by pinging peers periodically
-        const pingInterval = setInterval(async () => {
-          const peers = node.libp2p.getPeers();
-          if (peers.length === 0) {
-            // No peers connected, try to reconnect to bootstrap
-            for (const bootstrapAddr of bootstrapPeers) {
-              try {
-                await node.libp2p.dial(bootstrapAddr);
-                info('Reconnected to bootstrap peer');
-                break;
-              } catch {
-                // try next bootstrap peer
-              }
-            }
-          } else {
-            await ensureBootstrapConnections();
-            // Ping existing peers to keep connection alive
-            for (const peer of peers) {
-              try {
-                await (node.libp2p.services.ping as any).ping(peer);
-              } catch {
-                // ignore ping failures
-              }
-            }
-          }
-        }, 15000); // ping every 15s (reduced from 30s for better stability)
+        await relayClient.start();
 
-        // If a bootstrap peer disconnects, attempt immediate recovery.
-        const onPeerDisconnect = async (evt: any) => {
-          const disconnectedPeerId = evt?.detail?.toString?.() ?? '';
-          if (!bootstrapPeerIds.includes(disconnectedPeerId)) return;
+        spin.succeed('Connected to relay!');
 
-          info(`Bootstrap peer disconnected: ${disconnectedPeerId}, attempting reconnect...`);
-          for (const bootstrapAddr of bootstrapPeers) {
-            if (!bootstrapAddr.endsWith(`/p2p/${disconnectedPeerId}`)) continue;
-            try {
-              await node.libp2p.dial(bootstrapAddr);
-              info(`Recovered bootstrap connection: ${disconnectedPeerId}`);
-              return;
-            } catch {
-              // Continue trying other bootstrap peers if available
-            }
-          }
-        };
-        node.libp2p.addEventListener('peer:disconnect', onPeerDisconnect);
+        info(`DID: ${identity.did}`);
+        info(`Connected relays: ${relayClient.getConnectedRelays().join(', ')}`);
+        info(`Network peers: ${relayClient.getPeerCount()}`);
 
         const verifyFn = async (signature: Uint8Array, data: Uint8Array): Promise<boolean> => {
           try {
@@ -276,16 +98,10 @@ export function registerJoinCommand(program: Command): void {
           }
         };
 
-        // Register message handlers for incoming messages
-        const router = createMessageRouter(
-          node.libp2p,
-          verifyFn,
-          dht
-        );
+        const router = createMessageRouter(relayClient, verifyFn);
 
         const saveDir = resolve(options.saveDir ?? './downloads');
 
-        // Generic message handler that accepts any protocol
         const messageHandler = async (envelope: any) => {
           const payload = envelope.payload as Record<string, unknown>;
           console.log();
@@ -294,7 +110,6 @@ export function registerJoinCommand(program: Command): void {
           info(`    Protocol:   ${envelope.protocol}`);
           info(`    Type:       ${envelope.type}`);
 
-          // Handle file attachment
           let savedPath: string | undefined;
           if (payload.attachment) {
             const att = payload.attachment as {
@@ -305,7 +120,6 @@ export function registerJoinCommand(program: Command): void {
             };
             try {
               await mkdir(saveDir, { recursive: true });
-              // Avoid filename collisions by prefixing with message id fragment
               const safeName = att.filename.replace(/[^a-zA-Z0-9._-]/g, '_');
               savedPath = join(saveDir, `${envelope.id.slice(-8)}_${safeName}`);
               await writeFile(savedPath, Buffer.from(att.data, 'base64'));
@@ -321,7 +135,6 @@ export function registerJoinCommand(program: Command): void {
           }
           console.log();
 
-          // If this is a request, send back a simple acknowledgment response
           if (envelope.type === 'request') {
             info('    Sending acknowledgment response...');
 
@@ -356,11 +169,8 @@ export function registerJoinCommand(program: Command): void {
           return undefined;
         };
 
-        // Register handlers for common protocols
         router.registerHandler('/clawiverse/msg/1.0.0', messageHandler);
         router.registerHandler('/clawiverse/greet/1.0.0', messageHandler);
-
-        // Register catch-all handler for any other protocol
         router.registerCatchAllHandler(messageHandler);
 
         await router.start();
@@ -372,12 +182,10 @@ export function registerJoinCommand(program: Command): void {
 
         process.on('SIGINT', async () => {
           console.log();
-          const stopSpin = spinner('Stopping node...');
-          clearInterval(pingInterval);
-          node.libp2p.removeEventListener('peer:disconnect', onPeerDisconnect);
+          const stopSpin = spinner('Stopping...');
           await router.stop();
-          await node.stop();
-          stopSpin.succeed('Node stopped');
+          await relayClient.stop();
+          stopSpin.succeed('Disconnected');
           process.exit(0);
         });